fabridge.as

QS我也没用过

			result.value = value;
		}
		else
		{
			// serialize a class
			result.type = TYPE_ASINSTANCE;
			
			// make sure the type info is available
			var className:String = getQualifiedClassName(value);
			if(retrieveCachedTypeDescription(className,false) == null) {
				result.newTypes.push(retrieveCachedTypeDescription(className,true));
			}
			
			// make sure the reference is known
			var objRef:Number = getRef(value,false);
			if(isNaN(objRef)) {
				objRef = getRef(value,true);
				result.newRefs[objRef] = className;
			}
			result.value = objRef;
		}
		return result;
	}

	/** deserializes a value passed in from javascript. See serialize for details on how values are packed and 
	 * unpacked for transfer across the bridge.	
	 */
	public function deserialize(valuePackage:*):*
	{
		var result:*;
		if(valuePackage is Number || valuePackage is Boolean || valuePackage is String || valuePackage == null || valuePackage == undefined  || valuePackage is int || valuePackage is uint)
		{
			result = valuePackage;
		}
		else if(valuePackage is Array)
		{
			result = [];
			for(var i:int = 0;i<valuePackage.length;i++)
			{
				result[i] = deserialize(valuePackage[i]);
			}
		}
		else if (valuePackage.type == FABridge.TYPE_JSFUNCTION) 
		{
			result = getRemoteFunctionProxy(valuePackage.value,true);
		}
		else if (valuePackage.type == FABridge.TYPE_ASFUNCTION) 
		{
			throw new Error("as functions can't be passed back to as yet");
		}
		else if (valuePackage.type == FABridge.TYPE_ASINSTANCE)
		{
			result = resolveRef(valuePackage.value);
		}
		else if (valuePackage.type == FABridge.TYPE_ANONYMOUS)
		{
			result = valuePackage.value;
		}
		return result;
	}
	
	
/*------------------------------------------------------------------------------------
// type management
/*----------------------------------------------------------------------------------*/

	/** retrieves a type description for the type indicated by className, building one and caching it if necessary */
	public function retrieveCachedTypeDescription(className:String,createifNecessary:Boolean):Object
	{
		if(localTypeMap[className] == null && createifNecessary == true)
		{
			localTypeMap[className] = buildTypeDescription(className);
		}
		return localTypeMap[className];
		
	}
	
	/** builds a type description for the type indiciated by className */
	public function buildTypeDescription(className:String):Object
	{		
		var desc:Object = {};
		
		className = className.replace(/::/,".");
		var objClass:Class = Class(ApplicationDomain.currentDomain.getDefinition(className));

		var xData:XML = describeType(objClass);

		desc.name = [e-mail]();

		
		var methods:Array = [];
		var xMethods:XMLList = xData.factory.method;
		for(var i:int = 0;i < xMethods.length();i++) {
			methods.push(xMethods[i][e-mail]());	
		}		
		desc.methods = methods;

		var accessors:Array = [];
		var xAcc:XMLList = xData.factory.accessor;
		for(var i:int = 0;i < xAcc.length();i++) {
			accessors.push(xAcc[i][e-mail]());	
		}		
		xAcc = xData.factory.variable;
		for(var i:int = 0;i < xAcc.length();i++) {
			accessors.push(xAcc[i][e-mail]());	
		}		
		desc.accessors = accessors;

		return desc;
	}

/*------------------------------------------------------------------------------------
// instance mgmt
/*----------------------------------------------------------------------------------*/
	
	/** resolves an instance id passed from JS to an instance previously cached for representing in JS*/
	private function resolveRef(objRef:Number):Object
	{
		return (objRef == -1)? baseObject:localInstanceMap[objRef];
	}
	
	/** returns an id associated with the object provided for passing across the bridge to JS */
	private function getRef(obj:Object,createIfNecessary:Boolean):Number
	{
		var ref:Number;
		
		if(createIfNecessary)
		{
			var newRef:Number = nextID++;
			localInstanceMap[newRef] = obj;
			ref = newRef;
		}
		
		return ref;		
	}


/*------------------------------------------------------------------------------------
// function management
/*----------------------------------------------------------------------------------*/

	/** resolves a function ID passed from JS to a local function previously cached for representation in JS */
	private function resolveFunctionID(funcID:Number):Function
	{
		return localFunctionMap[funcID];
	}
	
	/** associates a unique ID with a local function suitable for passing across the bridge to proxy in Javascript */
	public function getFunctionID(f:Function,createIfNecessary:Boolean):Number
	{
		var ref:Number;
		
		if(createIfNecessary)
		{
			var newID:Number = nextID++;
			localFunctionMap[newID] = f;
			ref = newID;
		}
		
		return ref;		
	}

	/** returns a proxy function that represents a function defined in javascript. This function can be called syncrhonously, and will
	 * return any values returned by the JS function */
	public function getRemoteFunctionProxy(functionID:Number,createIfNecessary:Boolean):Function
	{
		if (remoteFunctionCache[functionID] == null)
		{
			remoteFunctionCache[functionID] = function(...args):*
			{
				var externalArgs:Array = args.concat();
				externalArgs.unshift(functionID);
				ExternalInterface.call("FABridge__invokeJSFunction",serialize(externalArgs));
			}
		}
		return remoteFunctionCache[functionID];
	}


	
	
/*------------------------------------------------------------------------------------
// callbacks exposed to JS
/*----------------------------------------------------------------------------------*/

	/** called to fetch a named property off the instanced assicated with objID */
	public function js_getPropFromAS(objID:Number,propName:String):*
	{
		var obj:Object = resolveRef(objID);
		return serialize(obj[propName]);
	}

	/** called to set a named property on the instance associated with objID */
	private function js_setPropertyInAS(objID:Number,propRef:String,value:*):void
	{
		var obj:Object = resolveRef(objID);
		obj[propRef] = deserialize(value);
	}

	/** accessor for retrieveing a proxy to the root object from JS */
	private function js_getRoot():*
	{
		return serialize(baseObject);
	}

	/** called to invoke a function or closure associated with funcID */
	private function js_invokeFunction(funcID:Number,args:Object):*
	{
		var result:*;
		
		var func:Function = resolveFunctionID(funcID);
		if(func != null)
			result = func.apply(null,deserialize(args));
		return serialize(result);
	}

	/** called ot invoke a named method on the object associated with objID */
	private function js_invokeMethod(objID:Number,methodName:String,args:Object):*
	{
		var obj:Object = resolveRef(objID);
		var result:*;

		return serialize( obj[methodName].apply(null,deserialize(args)) );
	}
	
	private function js_releaseASObjects():void
	{
		localTypeMap = new Dictionary();
		localInstanceMap = new Dictionary();
		localFunctionMap = new Dictionary();
	}
	private function js_create(className:String):*
	{
		var c:Class = Class(ApplicationDomain.currentDomain.getDefinition(className));
		var instance:Object = new c();
		return serialize(instance);		
	}
	
}
}