| //////////////////////////////////////////////////////////////////////////////// |
| // |
| // Licensed to the Apache Software Foundation (ASF) under one or more |
| // contributor license agreements. See the NOTICE file distributed with |
| // this work for additional information regarding copyright ownership. |
| // The ASF licenses this file to You under the Apache License, Version 2.0 |
| // (the "License"); you may not use this file except in compliance with |
| // the License. You may obtain a copy of the License at |
| // |
| // http://www.apache.org/licenses/LICENSE-2.0 |
| // |
| // Unless required by applicable law or agreed to in writing, software |
| // distributed under the License is distributed on an "AS IS" BASIS, |
| // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| // See the License for the specific language governing permissions and |
| // limitations under the License. |
| // |
| //////////////////////////////////////////////////////////////////////////////// |
| /* |
| * The Bridge class, responsible for navigating JS instances |
| */ |
| package bridge |
| { |
| |
| /* |
| * imports |
| */ |
| import flash.external.ExternalInterface; |
| import flash.utils.Timer; |
| import flash.events.*; |
| import flash.display.DisplayObject; |
| import flash.system.ApplicationDomain; |
| import flash.utils.Dictionary; |
| import flash.utils.setTimeout; |
| |
| import mx.collections.errors.ItemPendingError; |
| import mx.core.IMXMLObject; |
| |
| import flash.utils.getQualifiedClassName; |
| import flash.utils.describeType; |
| import flash.events.TimerEvent; |
| |
| /** |
| * The FABridge class, responsible for proxying AS objects into javascript |
| */ |
| public class FABridge extends EventDispatcher implements IMXMLObject |
| { |
| |
| //holds a list of stuff to call later, to break the recurrence of the js <> as calls |
| //you must use the full class name, as returned by the getQualifiedClassName() function |
| public static const MethodsToCallLater:Object = new Object(); |
| MethodsToCallLater["mx.collections::ArrayCollection"]="refresh,removeItemAt"; |
| |
| public static const EventsToCallLater:Object = new Object(); |
| EventsToCallLater["mx.data.events::UnresolvedConflictsEvent"]="true"; |
| EventsToCallLater["mx.events::PropertyChangeEvent"]="true"; |
| |
| public static const INITIALIZED:String = "bridgeInitialized"; |
| |
| // constructor |
| public function FABridge() |
| { |
| super(); |
| initializeCallbacks(); |
| } |
| |
| // private vars |
| |
| /** |
| * stores a cache of descriptions of AS types suitable for sending to JS |
| */ |
| private var localTypeMap:Dictionary = new Dictionary(); |
| |
| /** |
| * stores an id-referenced dictionary of objects exported to JS |
| */ |
| private var localInstanceMap:Dictionary = new Dictionary(); |
| |
| /** |
| * stores an id-referenced dictionary of functions exported to JS |
| */ |
| private var localFunctionMap:Dictionary = new Dictionary(); |
| |
| /** |
| * stores an id-referenced dictionary of proxy functions imported from JS |
| */ |
| private var remoteFunctionCache:Dictionary = new Dictionary(); |
| |
| /** |
| * stores a list of custom serialization functions |
| */ |
| private var customSerializersMap:Dictionary = new Dictionary(); |
| |
| /** |
| * stores a map of object ID's and their reference count |
| */ |
| private var refMap:Dictionary = new Dictionary(); |
| /** |
| * a local counter for generating unique IDs |
| */ |
| private var nextID:Number = 0; |
| |
| private var lastRef:int; |
| |
| /* values that can't be serialized natively across the bridge are packed and identified by type. |
| These constants represent different serialization types */ |
| public static const TYPE_ASINSTANCE:uint = 1; |
| public static const TYPE_ASFUNCTION:uint = 2; |
| public static const TYPE_JSFUNCTION:uint = 3; |
| public static const TYPE_ANONYMOUS:uint = 4; |
| |
| private var _initChecked:Boolean = false; |
| |
| // properties |
| |
| //getters and setters for the main component in the swf - the root |
| public function get rootObject():DisplayObject {return _rootObject;} |
| public function set rootObject(value:DisplayObject):void |
| { |
| _rootObject = value; |
| checkInitialized(); |
| } |
| |
| /** |
| * the bridge name |
| */ |
| public var bridgeName:String; |
| private var _registerComplete:Boolean = false; |
| |
| /** |
| * increment the reference count for an object being passed over the bridge |
| */ |
| public function incRef(objId:int):void |
| { |
| if(refMap[objId] == null) { |
| //the object is being created; we now add it to the map and set its refCount = 1 |
| refMap[objId] = 1; |
| } else { |
| refMap[objId] = refMap[objId] +1; |
| } |
| } |
| |
| /** |
| * when an object has been completely passed to JS its reference count is decreased with 1 |
| */ |
| public function releaseRef(objId:int):void |
| { |
| if(refMap[objId] != null) |
| { |
| var newRefVal:int = refMap[objId] - 1; |
| // if the object exists in the referenceMap and its count equals or has dropped under 0 we clean it up |
| if(refMap[objId] != null && newRefVal <= 0) |
| { |
| delete refMap[objId]; |
| delete localInstanceMap[objId]; |
| } |
| else |
| { |
| refMap[objId] = newRefVal; |
| } |
| } |
| } |
| |
| /** |
| * attaches the callbacks to external interface |
| */ |
| public function initializeCallbacks():void |
| { |
| if (ExternalInterface.available == false) |
| { |
| return; |
| } |
| |
| ExternalInterface.addCallback("getRoot", js_getRoot); |
| ExternalInterface.addCallback("getPropFromAS", js_getPropFromAS); |
| ExternalInterface.addCallback("setPropInAS", js_setPropertyInAS); |
| ExternalInterface.addCallback("invokeASMethod", js_invokeMethod); |
| ExternalInterface.addCallback("invokeASFunction", js_invokeFunction); |
| ExternalInterface.addCallback("releaseASObjects", js_releaseASObjects); |
| ExternalInterface.addCallback("create", js_create); |
| ExternalInterface.addCallback("releaseNamedASObject",js_releaseNamedASObject); |
| ExternalInterface.addCallback("incRef", incRef); |
| ExternalInterface.addCallback("releaseRef", releaseRef); |
| } |
| |
| private var _rootObject:DisplayObject; |
| |
| private var _document:DisplayObject; |
| |
| /** |
| * called to check whether the bridge has been initialized for the specified document/id pairs |
| */ |
| public function initialized(document:Object, id:String):void |
| { |
| _document = (document as DisplayObject); |
| |
| if (_document != null) |
| { |
| checkInitialized(); |
| } |
| } |
| |
| private function get baseObject():DisplayObject |
| { |
| return (rootObject == null)? _document:rootObject; |
| } |
| |
| |
| private function checkInitialized():void |
| { |
| if(_initChecked== true) |
| { |
| return; |
| } |
| _initChecked = true; |
| |
| // oops! timing error. Player team is working on it. |
| var t:Timer = new Timer(200,1); |
| t.addEventListener(TimerEvent.TIMER,auxCheckInitialized); |
| t.start(); |
| } |
| |
| /** |
| * auxiliary initialization check that is called after the timing has occurred |
| */ |
| private function auxCheckInitialized(e:Event):void |
| { |
| |
| var bCanGetParams:Boolean = true; |
| |
| try |
| { |
| var params:Object = baseObject.root.loaderInfo.parameters; |
| } |
| catch (e:Error) |
| { |
| bCanGetParams = false; |
| } |
| |
| if (bCanGetParams == false) |
| { |
| var t:Timer = new Timer(100); |
| var timerFunc:Function = function(e:TimerEvent):void |
| { |
| if(baseObject.root != null) |
| { |
| try |
| { |
| bCanGetParams = true; |
| var params:Object = baseObject.root.loaderInfo.parameters; |
| } |
| catch (err:Error) |
| { |
| bCanGetParams = false; |
| } |
| if (bCanGetParams) |
| { |
| t.removeEventListener(TimerEvent.TIMER, timerFunc); |
| t.stop(); |
| dispatchInit(); |
| } |
| } |
| } |
| t.addEventListener(TimerEvent.TIMER, timerFunc); |
| t.start(); |
| } |
| else |
| { |
| dispatchInit(); |
| } |
| } |
| |
| /** |
| * call into JS to annunce that the bridge is ready to be used |
| */ |
| private function dispatchInit(e:Event = null):void |
| { |
| if(_registerComplete == true) |
| { |
| return; |
| } |
| |
| if (ExternalInterface.available == false) |
| { |
| return; |
| } |
| |
| if (bridgeName == null) |
| { |
| bridgeName = baseObject.root.loaderInfo.parameters["bridgeName"]; |
| |
| if(bridgeName == null) |
| { |
| bridgeName = "flash"; |
| } |
| } |
| |
| _registerComplete = ExternalInterface.call("FABridge__bridgeInitialized", [bridgeName]); |
| dispatchEvent(new Event(FABridge.INITIALIZED)); |
| } |
| |
| // serialization/deserialization |
| |
| /** serializes a value for transfer across the bridge. primitive types are left as is. Arrays are left as arrays, but individual |
| * values in the array are serialized according to their type. Functions and class instances are inserted into a hash table and sent |
| * across as keys into the table. |
| * |
| * For class instances, if the instance has been sent before, only its id is passed. If This is the first time the instance has been sent, |
| * a ref descriptor is sent associating the id with a type string. If this is the first time any instance of that type has been sent |
| * across, a descriptor indicating methods, properties, and variables of the type is also sent across |
| */ |
| public function serialize(value:*, keep_refs:Boolean=false):* |
| { |
| var result:* = {}; |
| result.newTypes = []; |
| result.newRefs = {}; |
| |
| if (value is Number || value is Boolean || value is String || value == null || value == undefined || value is int || value is uint) |
| { |
| result = value; |
| } |
| else if (value is Array) |
| { |
| result = []; |
| for(var i:int = 0; i < value.length; i++) |
| { |
| result[i] = serialize(value[i], keep_refs); |
| } |
| } |
| else if (value is Function) |
| { |
| // serialize a class |
| result.type = TYPE_ASFUNCTION; |
| result.value = getFunctionID(value, true); |
| } |
| else if (getQualifiedClassName(value) == "Object") |
| { |
| result.type = TYPE_ANONYMOUS; |
| result.value = value; |
| } |
| else |
| { |
| // serialize a class |
| result.type = TYPE_ASINSTANCE; |
| // make sure the type info is available |
| var className:String = getQualifiedClassName(value); |
| |
| var serializer:Function = customSerializersMap[className]; |
| |
| // try looking up the serializer under an alternate name |
| if (serializer == null) |
| { |
| if (className.indexOf('$') > 0) |
| { |
| var split:int = className.lastIndexOf(':'); |
| if (split > 0) |
| { |
| var alternate:String = className.substring(split+1); |
| serializer = customSerializersMap[alternate]; |
| } |
| } |
| } |
| |
| if (serializer != null) |
| { |
| return serializer.apply(null, [value, keep_refs]); |
| } |
| else |
| { |
| if (retrieveCachedTypeDescription(className, false) == null) |
| { |
| try |
| { |
| result.newTypes.push(retrieveCachedTypeDescription(className, true)); |
| } |
| catch(err:Error) |
| { |
| var interfaceInfo:XMLList = describeType(value).implementsInterface; |
| for each (var interf:XML in interfaceInfo) |
| { |
| className = interf.@type.toString(); |
| if (retrieveCachedTypeDescription(className, false) == null){ |
| result.newTypes.push(retrieveCachedTypeDescription(className, true)); |
| } //end if push new data type |
| |
| } //end for going through interfaces |
| var baseClass:String = describeType(value).@base.toString(); |
| if (retrieveCachedTypeDescription(baseClass, false) == null){ |
| result.newTypes.push(retrieveCachedTypeDescription(baseClass, true)); |
| } //end if push new data type |
| } |
| } |
| |
| // make sure the reference is known |
| var objRef:Number = getRef(value, false); |
| var should_keep_ref:Boolean = false; |
| if (isNaN(objRef)) |
| { |
| //create the reference if necessary |
| objRef = getRef(value, true); |
| should_keep_ref = true; |
| } |
| |
| result.newRefs[objRef] = className; |
| //trace("serializing new reference: " + className + " with value" + value); |
| |
| //the result is a getProperty / invokeMethod call. How can we know how much you will need the object ? |
| if (keep_refs && should_keep_ref) { |
| incRef(objRef); |
| } |
| 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; |
| } |
| |
| public function addCustomSerialization(className:String, serializationFunction:Function):void |
| { |
| customSerializersMap[className] = serializationFunction; |
| } |
| |
| |
| // 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]; |
| } |
| |
| public function addCachedTypeDescription(className:String, desc:Object):Object |
| { |
| if (localTypeMap[className] == null) |
| { |
| localTypeMap[className] = desc; |
| } |
| 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 = xData.@name.toString(); |
| |
| var methods:Array = []; |
| var xMethods:XMLList = xData.factory.method; |
| for (var i:int = 0; i < xMethods.length(); i++) |
| { |
| methods.push(xMethods[i].@name.toString()); |
| } |
| desc.methods = methods; |
| |
| var accessors:Array = []; |
| var xAcc:XMLList = xData.factory.accessor; |
| for (i = 0; i < xAcc.length(); i++) |
| { |
| accessors.push(xAcc[i].@name.toString()); |
| } |
| xAcc = xData.factory.variable; |
| for (i = 0; i < xAcc.length(); i++) |
| { |
| accessors.push(xAcc[i].@name.toString()); |
| } |
| 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 |
| { |
| try |
| { |
| return (objRef == -1)? baseObject : localInstanceMap[objRef]; |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message); |
| } |
| |
| return (objRef == -1)? baseObject : localInstanceMap[objRef]; |
| } |
| |
| /** |
| * returns an id associated with the object provided for passing across the bridge to JS |
| */ |
| public function getRef(obj:Object, createIfNecessary:Boolean):Number |
| { |
| try |
| { |
| var ref:Number; |
| |
| if (createIfNecessary) |
| { |
| var newRef:Number = nextID++; |
| localInstanceMap[newRef] = obj; |
| ref = newRef; |
| } |
| else |
| { |
| for (var key:* in localInstanceMap) |
| { |
| if (localInstanceMap[key] === obj) |
| { |
| ref = key; |
| break; |
| } |
| } |
| } |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message) |
| } |
| |
| 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; |
| } |
| else |
| { |
| for (var key:* in localFunctionMap) |
| { |
| if (localFunctionMap[key] === f) { |
| ref = key; |
| } |
| break; |
| } |
| } |
| |
| 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 |
| { |
| try |
| { |
| if (remoteFunctionCache[functionID] == null) |
| { |
| remoteFunctionCache[functionID] = function(...args):* |
| { |
| var externalArgs:Array = args.concat(); |
| externalArgs.unshift(functionID); |
| var serializedArgs:* = serialize(externalArgs, true); |
| |
| if(checkToThrowLater(serializedArgs[1])) |
| { |
| setTimeout(function a():* { |
| try { |
| var retVal:* = ExternalInterface.call("FABridge__invokeJSFunction", serializedArgs); |
| for(var i:int = 0; i<serializedArgs.length; i++) |
| { |
| if(typeof(serializedArgs[i]) == "object" && serializedArgs[i]!=null) |
| { |
| releaseRef(serializedArgs[i].value); |
| } |
| } |
| return retVal; |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message); |
| } |
| },1); |
| } |
| else |
| { |
| var retVal:* = ExternalInterface.call("FABridge__invokeJSFunction", serializedArgs); |
| for(var i:int = 0; i<serializedArgs.length; i++) |
| { |
| if(typeof(serializedArgs[i]) == "object" && serializedArgs[i]!=null) |
| { |
| releaseRef(serializedArgs[i].value); |
| } |
| } |
| return retVal; |
| } |
| } |
| } |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message); |
| } |
| |
| return remoteFunctionCache[functionID]; |
| } |
| |
| /** |
| * function that checks if the object on which we are working demands that it should be called at a later time, breaking the call chain |
| * we check the actual object, as well as the bsae class and interfaces |
| */ |
| private function checkToThrowLater(obj:Object):Boolean |
| { |
| obj = resolveRef(obj.value); |
| var className:String = getQualifiedClassName(obj); |
| var classInfo:XML = describeType(obj); |
| |
| if (FABridge.EventsToCallLater[className] != null) { |
| return true; |
| } |
| |
| //check if this class doesn't inherit from one of the entries in the table |
| var inheritanceInfo:XMLList = describeType(obj).extendsClass; |
| for each (var inherit:XML in inheritanceInfo) |
| { |
| className = inherit.@type.toString(); |
| if (FABridge.EventsToCallLater[className] != null) { |
| return true; |
| } |
| } //end for going through inheritance tree |
| |
| //if we're still here, check the interfaces as well |
| |
| var interfaceInfo:XMLList = describeType(obj).implementsInterface; |
| for each (var interf:XML in interfaceInfo) |
| { |
| className = interf.@type.toString(); |
| if (FABridge.EventsToCallLater[className] != null) { |
| return true; |
| } |
| } //end for going through inheritance tree |
| |
| //if nothing was found, return false, so the function gets executed |
| return false; |
| } |
| |
| // callbacks exposed to JS |
| |
| /** |
| * called to fetch a named property off the instanced associated with objID |
| */ |
| public function js_getPropFromAS(objID:Number, propName:String):* |
| { |
| incRef(objID); |
| try |
| { |
| var obj:Object = resolveRef(objID); |
| var ret:* = serialize(obj[propName], true); |
| releaseRef(objID); |
| return ret; |
| } |
| catch (e:ItemPendingError) |
| { |
| releaseRef(objID); |
| //ItemPendingError |
| //return serialize("an error occcured with" + obj[propName]); |
| } |
| catch(e:Error) |
| { |
| releaseRef(objID); |
| return serialize("__FLASHERROR__" + "||" + e.message); |
| } |
| } |
| |
| /** |
| * called to set a named property on the instance associated with objID |
| */ |
| private function js_setPropertyInAS(objID:Number, propRef:String, value:*):* |
| { |
| incRef(objID); |
| try { |
| var obj:Object = resolveRef(objID); |
| obj[propRef] = deserialize(value); |
| releaseRef(objID); |
| } |
| catch(e:Error) |
| { |
| releaseRef(objID); |
| return serialize("__FLASHERROR__" + "||" + e.message); |
| } |
| } |
| |
| /** |
| * accessor for retrieveing a proxy to the root object from JS |
| */ |
| private function js_getRoot():* |
| { |
| try |
| { |
| //always get the root; this is the same as the get property, only it is the root object |
| var objRef:Number = getRef(baseObject, false); |
| if (isNaN(objRef)) |
| { |
| //create the reference if necessary |
| objRef = getRef(baseObject, true); |
| incRef(objRef); |
| } |
| return serialize(baseObject); |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message); |
| } |
| } |
| |
| /** |
| * called to invoke a function or closure associated with funcID |
| */ |
| private function js_invokeFunction(funcID:Number, args:Object):* |
| { |
| var result:*; |
| try |
| { |
| var func:Function = resolveFunctionID(funcID); |
| if(func != null) |
| result = func.apply(null, deserialize(args)); |
| |
| return serialize(result, true); |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__"+"||"+e.message); |
| } |
| } |
| |
| /** |
| * called to invoke a named method on the object associated with objID |
| */ |
| private function js_invokeMethod(objID:Number, methodName:String, args:Object):* |
| { |
| incRef(objID); |
| try |
| { |
| var obj:Object = resolveRef(objID); |
| var result:*; |
| |
| //check if the method is callable right now, or later |
| var callLater:Boolean = checkToExecuteLater(obj, methodName); |
| |
| if (callLater) { |
| var t:Timer = new Timer(200, 1); |
| t.addEventListener(TimerEvent.TIMER, function():void { |
| var ret_inner:* = serialize(obj[methodName].apply(null, deserialize(args)), true); |
| releaseRef(objID); |
| }); |
| t.start(); |
| } else { |
| var ret:* = serialize(obj[methodName].apply(null, deserialize(args)), true); |
| releaseRef(objID); |
| return ret; |
| } |
| } |
| catch (e:ItemPendingError) |
| { |
| releaseRef(objID); |
| // ignore ItemPendingError |
| } |
| catch(e:Error) |
| { |
| releaseRef(objID); |
| return serialize("__FLASHERROR__" + "||" + e.message); |
| } |
| } |
| |
| /** |
| * method that performs a check on the specified object and method to see if their execution should be delayed or not |
| * it checks the object, its base class and implemented interfaces |
| */ |
| private function checkToExecuteLater(obj:Object, methodName:String):Boolean |
| { |
| var methods:String; |
| var className:String = getQualifiedClassName(obj); |
| var classInfo:XML = describeType(obj); |
| |
| if (FABridge.MethodsToCallLater[className] != null) { |
| methods = FABridge.MethodsToCallLater[className]; |
| //must call later |
| if(methods.match(methodName)) |
| { |
| return true; |
| } |
| } |
| |
| //check if this class doesn't inherit from one of the entries in the table |
| var inheritanceInfo:XMLList = describeType(obj).extendsClass; |
| for each (var inherit:XML in inheritanceInfo) |
| { |
| className = inherit.@type.toString(); |
| if (FABridge.MethodsToCallLater[className] != null) { |
| methods = FABridge.MethodsToCallLater[className]; |
| //must call later |
| if(methods.match(methodName)) |
| { |
| return true; |
| } |
| } |
| } //end for going through inheritance tree |
| |
| //if we're still here, check the interfaces as well |
| |
| var interfaceInfo:XMLList = describeType(obj).implementsInterface; |
| for each (var interf:XML in interfaceInfo) |
| { |
| className = interf.@type.toString(); |
| if (FABridge.MethodsToCallLater[className] != null) { |
| methods = FABridge.MethodsToCallLater[className]; |
| //must call later |
| if(methods.match(methodName)) |
| { |
| return true; |
| } |
| } |
| } //end for going through inheritance tree |
| |
| //if nothing was found, return false, so the function gets executed |
| return false; |
| } |
| |
| /** |
| * callback from JS to release all AS Objects from the local cache maps |
| */ |
| private function js_releaseASObjects():void |
| { |
| localTypeMap = new Dictionary(); |
| localInstanceMap = new Dictionary(); |
| localFunctionMap = new Dictionary(); |
| } |
| |
| /** |
| * callback from JS to release a specific object, identified by its ID |
| */ |
| private function js_releaseNamedASObject(objId:int):Boolean |
| { |
| var retVal:Boolean = false; |
| if (localInstanceMap[objId] != null) |
| { |
| delete refMap[objId]; |
| delete localInstanceMap[objId]; |
| retVal = true; |
| } |
| return retVal; |
| } |
| |
| /** |
| * callback for js to create a new class instance. |
| */ |
| |
| private function js_create(className:String):* |
| { |
| try |
| { |
| var c:Class = Class(ApplicationDomain.currentDomain.getDefinition(className)); |
| var instance:Object = new c(); |
| } |
| catch(e:Error) |
| { |
| return serialize("__FLASHERROR__" + "||" + e.message); |
| } |
| |
| // make sure the reference is known |
| var objRef:Number = getRef(instance, true); |
| incRef(objRef); |
| return serialize(instance); |
| } |
| |
| } |
| } |
