Casting a loaded SWF as an interface

问题

I'm trying to load in a remote SWF and access it's methods and properties, using an interface. (There's a similar question here that got as far as "that's weird!" but didn't resolve it: Loading swf and using it through interface)

My remote SWF looks like this:

package 
{   
    import flash.display.Sprite;
    import flash.events.Event;
    import flash.system.Security;

    import IMultiplayer;

    [SWF(width="238", height="60", frameRate="60", backgroundColor="#FFFFFF")]
    public class Main extends Sprite implements IMultiplayer
    {
        public function init(e:Event):void
        {

        }

        public function TEST():void
        {
            trace("TEST()");
        }   
    }
}

I then have an interface that looks like this:

package
{
    import flash.events.*;
    import flash.display.*;

    public interface IMultiplayer
    {
        function init(e:Event):void;
        function TEST():void;
    }
}

And finally, I've got a loader class that pulls down the SWF and tries to cast it as the same interface that the remote SWF implements. EDIT - apologies for length, was asked to post the full source:

package uk.co.MyDomain
{
    import flash.display.DisplayObject;
    import flash.display.Loader;
    import flash.display.LoaderInfo;
    import flash.display.MovieClip;
    import flash.display.Sprite;
    import flash.events.ErrorEvent;
    import flash.events.Event;
    import flash.events.EventDispatcher;
    import flash.events.IEventDispatcher;
    import flash.events.IOErrorEvent;
    import flash.events.TimerEvent;
    import flash.net.URLRequest;
    import flash.system.ApplicationDomain;
    import flash.system.LoaderContext;
    import flash.system.Security;
    import flash.system.SecurityDomain;
    import flash.utils.Timer;

    import uk.co.MyDomain.*;

    import utils.Console;

    public class MultiplayerLoader extends Sprite
    {
        private var ld:Loader;
        private var _environment:String;
        public var _mpInstance:IMultiplayer;

        private const SANDBOX_SWF:String = "http://static.sandbox.dev.MyDomain.co.uk/smartfoxtest/dev/swf/MP.swf";

        public function MultiplayerLoader(environment:String)
        {
            _environment = environment;
        }

        public function loadMultiplayer():void
        {
            ld = new Loader();

            var context:LoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain);

            ld.contentLoaderInfo.addEventListener(Event.COMPLETE, multiplayerLoaded);
            ld.contentLoaderInfo.addEventListener(ErrorEvent.ERROR, onLoadError);
            ld.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR, onIOLoadError);
            ld.contentLoaderInfo.addEventListener(IOErrorEvent.DISK_ERROR, onDiskError);
            ld.contentLoaderInfo.addEventListener(IOErrorEvent.NETWORK_ERROR, onNetworkError);
            ld.contentLoaderInfo.addEventListener(IOErrorEvent.VERIFY_ERROR, onVerifyError);

            if(Security.sandboxType == Security.REMOTE)
            {
                trace('[MP Loader] Loading with context');
                ld.load(new URLRequest(SANDBOX_SWF), context);      
            }
            else
            {
                trace('[MP Loader] Loading with NO context');
                ld.load(new URLRequest(SANDBOX_SWF));   
            }
        }

        private function onIOLoadError(e:IOErrorEvent):void
        {
            notifyFailure('IOLoadError');
        }

        private function onDiskError(e:IOErrorEvent):void
        {
            notifyFailure('IOLoadError');
        }

        private function onNetworkError(e:IOErrorEvent):void
        {
            notifyFailure('IOLoadError');
        }

        private function onVerifyError(e:IOErrorEvent):void
        {
            notifyFailure('IOLoadError');
        }

        private function onLoadError(e:ErrorEvent):void
        {
            notifyFailure('IOLoadError');
        }

        private function multiplayerLoaded(e:Event):void
        {   
            var tester:IMultiplayer = e.currentTarget.content as IMultiplayer;          
            Console.log('Loaded: ' + tester);

            dispatchEvent(new MultiplayerEvent(MultiplayerEvent.SWF_LOAD_SUCCESS)); 
        }

        private function notifyFailure(reason:String):void
        {
            var failEvent:MultiplayerEvent = new MultiplayerEvent(MultiplayerEvent.SWF_LOAD_FAILURE);
            failEvent.params = {'reason':reason}

            dispatchEvent(failEvent);
        }
    }
}

Now, if I DON'T cast it to use the interface, I can trace it out successfully and call functions (so e.target.content.TEST() will fire). However, as soon as I cast it to the interface, it fails.

Any ideas?

EDIT

OK, I'm getting the same issue with a custom event class that's shared between both applications. Flash errors, saying it cannot convert from one class to the other - even though they're identical they're in different projects, and so I imagine different namespaces. I assumed that loading into the same applicationDomain would fix this, but it hasn't. Is there any other way I can get around this without resorting to a common library/SWC or similar?

回答1:

I think this might be an issue of the application domain. The loaded SWF resides in its own application domain so it does not share the exact same interface. Try to load the swf into the »current application domain«, using the applicationDomainproperty of the Loader's LoaderInfo Object.

look here

good luck…

EDIT::

it has to be done in the loaders load method

var context:LoaderContext = new LoaderContext(false, ApplicationDomain.currentDomain);
var loader:Loader = new Loader();
loader.load(new URLRequest("myButtons.swf"), context);

from here

EDIT 2::

Once I ran into an even more strange error, it was caused by the fact that i created an interface, compiled the »to load files« and »file that loaded«, changed the interface through adding a method and forgot to compile the »to load files« (there were a lot). Perhaps happened something like this…

EDIT 3::

If I remember right than one has to wait for the Event.INIT event of loaded swf's, first after this event the constructor of the loaded swf ran.

EDIT 4::

found this, perhaps you need to do:

var YourInterfaceClass:Class = ApplicationDomain.currentDomain.getDefinition( "YourInterface" ) as Class; 
var myInstance:YourINterface = event.target.content as YourInterface; 

来源：https://stackoverflow.com/questions/13343996/casting-a-loaded-swf-as-an-interface