[AlexCooper]

Сейчас найду свой исходник.

Добавлено через 19 минут
Писать пора не в кадрах иначе ничего толкового не получиться.

Постараюсь объяснить что тут и как. Все что не прокомментированно пропускайте. Естественно адаптируйте под свои задачи

Main

package  {
 
	import flash.display.Sprite;
	import flash.events.Event;
 
	import flash.display.StageScaleMode;
 
	import multiapi.MultiConnector;
	import flash.system.Security;
 
 
	public class Preloader extends Sprite {
 
		var cont:Sprite = new Sprite();
 
		public function Preloader() {		
 
			addChild(cont);
 
			stage.scaleMode = "noScale";
 
			if (stage) init();
			else addEventListener(Event.ADDED_TO_STAGE, init);
		}
 
		private function init(e:Event=null):void {
			removeEventListener(Event.ADDED_TO_STAGE, init);
 
			MultiConnector.stage = cont;
			MultiConnector.connected('inquestion_v2.26.swf');
 
		}
 
		//  A. Получить доступ 
		public function get external():Object {
			return MultiConnector.external;
		}
	}
}

MultiConnector

package multiapi {
 
	import flash.events.Event;
	import flash.display.Sprite;
	import flash.display.Stage;
 
	import multiapi.data.GlobalData;
 
	public class MultiConnector extends Object {
 
		public static var stage:Sprite;
 
		// статическая ссылка на класс
		protected static var _instance:*;
 
		public function MultiConnector(){}
 
		// B. возвращаем класс 
		public static function get external():Object {
 
			GlobalData.log.add('get external');
 
			// класс который будет доступен внутренему клипу
			if (!_instance) _instance = GlobalData.api;
 
			GlobalData.log.add('external ready');
 
			return _instance;
		}
 
		public static function connected($url:String):void {
 
			stage.addChild(GlobalData.log);
 
			GlobalData.api.init();
 
			GlobalData.loader.add($url, {'id':'main'});
			GlobalData.loader.get('main').addEventListener(Event.COMPLETE, loadingMainComplete);
			GlobalData.loader.start();
 
		}
 
		private static function loadingMainComplete(e:Event):void {
 
			GlobalData.loader.get('main').removeEventListener(Event.COMPLETE, loadingMainComplete);
			GlobalData.main = GlobalData.loader.getContent('main',true);
 
			while (GlobalData.mainTurn.length) {
				GlobalData.core.callMain(GlobalData.mainTurn[0].using,GlobalData.mainTurn[0].data);
				GlobalData.mainTurn.shift();
			}
			stage.addChild(GlobalData.main);
		}
 
	}
}

GlobalData

package multiapi.data {
 
	import multiapi.Core;
	import multiapi.connector.UnitedAPI;
	import multiapi.logger.Logger;
	import multiapi.processor.Poster;
 
	import br.com.stimuli.loading.BulkLoader;
 
	import flash.display.MovieClip;
 
 
	public class GlobalData extends Object {
 
		public function GlobalData() {
 
		}
 
		{
			// собственно сам класс 
			api = new UnitedAPI();
			core = new Core();
			log = new Logger();
			loader = new BulkLoader("loader");
			poster = new Poster();
 
			cache = new Object();
			mainTurn = new Array();
 
			devApi = 'vk';
		}
 
		public static var core:Core;
		public static var log:Logger;
		public static var loader:BulkLoader;
		public static var api:UnitedAPI;
 
		public static var poster:Poster;
 
		public static var account:Object;
		public static var cache:Object;
 
		public static var main:MovieClip;
		public static var mainTurn:Array;
 
		public static var devApi:String;
	}
}

Все публичные свойства и методы этого класса будут доступны
UnitedAPI

package multiapi.connector {
 
	import flash.display.Sprite;
 
	import vk.VKConnection;
	import vk.events.*;
 
	import fs.FSConnection;
 
	import com.adobe.serialization.json.JSON;
 
	import multiapi.data.GlobalData;
 
	import flash.events.Event;
 
	public class UnitedAPI extends Sprite {
 
		protected var status:Object;
 
		public var version = "vk";
 
		public var me:Object = new Object();
		public var api2:Object = new Object();
		public var app:Object = new Object();
 
		private var ex:External = new External();
 
		public var multi:*;
 
		public function UnitedAPI() {
			status = new Object();
		};
 
		public function init():void {
 
			if (status.ex) return;
 
			ex.init();
 
			status.ex = true;
		}
 
		public function initConnection(data:Object=null):void {
 
			if (!data) data = ex.call("exportAppData");
 
			if (status.connection) return;
 
			status.connection = true;
 
			version = data.api;
 
			GlobalData.log.add("API detect:"+version);
			//GlobalData.log.add(data);
 
			var flashVars = new Object();
 
			switch (data.api) {
				case "fs": {
 
					me.user_id =  data.userId;
 
					flashVars['apiUrl'] = data.apiUrl;
					flashVars['apiId'] = data.apiId;
					//flashVars['method'] = data.viewer_id;
					//flashVars['sig'] = data.sid;
 
					multi = new FSConnection(me.user_id, flashVars);
					multi.ex = ex;
 
					GlobalData.core.run('SET_UID');
					break;
				}
				case "vk": {
 
					api2.api_id 	=  data.api_id;
					api2.api_url = data.api_url;
					api2.auth_key = data.auth_key;
					api2.access_token = data.access_token;
					api2.secret = data.secret;
 
					app.install = data.is_app_user;
					app.setting = data.api_settings;
					app.lc_name = data.lc_name;
					app.session_id = data.sid; 
 
					me.api = "vk";
					me.user_id= data.viewer_id;
					me.view_id = data.user_id;
 
					flashVars['api_id'] = data.api_id;
					flashVars['viewer_id'] = data.viewer_id;
					flashVars['sid'] = data.sid;
					flashVars['secret'] = data.secret;
 
					multi = new VKConnection(flashVars);
 
					GlobalData.core.run('SET_UID');
 
					break;
				} default: {
					GlobalData.core.run('API_UNDEFINED');
					return;
				}
			}		
		}
 
		public function getMyUser():void {
 
			GlobalData.log.add("getMyUser");
 
			var method = ApiConvertor.usersget(version);
 
			var params = new Object();
				params[ApiConvertor.uids(version)] = me.user_id;
				params[ApiConvertor.fields(version)] = ApiConvertor.fieldsParamsUser(version); 			
 
			multi.api(method, params , fetchUserInfo, onApiRequestFail);
		}
 
		public function join(event:String, callBack:Function):void {
			(ex.join(ApiConvertor.event(version,event),callBack)) ? GlobalData.log.add('Join '+event) : GlobalData.log.add('Join '+event+' already');
		}
 
		public function post(user_id:String,options:Object,callBackOk:Function=null,callBackFail=null):void {
 
			GlobalData.log.add('posting for user > '+user_id);
			GlobalData.log.add(options);
 
			if (!callBackFail) callBackFail = onApiRequestFail;
 
			multi.api("photos.getWallUploadServer", {"uid":user_id}, function(data:Object):void { GlobalData.log.add(data); GlobalData.poster.images(data,user_id,options,callBackOk,callBackFail) } , callBackFail);
		}
 
		public function method($method:String, $data:Object=null):void {
 
			var method:String = ApiConvertor.method(version,$method);
 
			GlobalData.log.add('UnitedMethod: '+$method+' API: '+method);
 
			var send:Object = new Object();
				send.method = method;
 
			if ($data) send.data = $data;
 
			ex.call('method', send);
		}
 
		private function createPendingEvent(event:String,data:Object=null):void {
			GlobalData.log.add("Event "+event);
			dispatchEvent(new Event(event));
		}
 
		public function test():String {
			return "Test call";
		}
 
		private function fetchUserInfo(data: Object): void {
 
			GlobalData.log.add("<b>*** fetchUserInfo ***</b>");
 
			var SocialData = ApiConvertor.parsUserData(version,data);			
 
			if (SocialData) {
				GlobalData.log.add(SocialData);
 
				GlobalData.core.run('SOCIAL_USERDATA', SocialData);
				GlobalData.core.run('SOCIAL_AUTH');
			} else {
				GlobalData.log.add("Error "+data);
				GlobalData.log.add(data);
			}
		}
		private function onApiRequestFail(data: Object): void {
 
			GlobalData.log.add("Error: "+data.error_msg);
		}
		private function wallPostSuccess(data: Object): void {
			GlobalData.log.add("Success wall.post post_id: "+data.post_id.toString());
		}
		private function wallPostFail(data: Object): void {
			GlobalData.log.add("Fail wall.post error_msg: "+data.error_msg);
		}
 
	}
 
}

Internal

ADDED_TO_STAGE
 
wrapper = Object(parent.parent);
 
// функция из класса UnitedAPI
wrapper.external.getMyUser();