Because I needed this quite a lot in one of the applications I’m working on, I’ve decided to create a class (AS2Loader) that will simplify the process of loading and communicating with ActionScript 2 SWFs from ActionScript 3. Here’s what you can do with it:

Suppose you have an AS3 SWF in which you want to load (and then communicate with) an AS2 SWF named “as2movieclip.swf”. Using the AS2Loader class you will do something like this:

import com.onsysol.as3.AS2Loader.*;

var as2ldr:AS2Loader = new AS2Loader();
as2ldr.addEventListener('AS2LoadInit', onAS2LoadInit);
as2ldr.load(new URLRequest('as2movieclip.swf'));

// this is triggered when the 1st frame of "as2movieclip.swf"
// is loaded and initialized:
function onAS2LoadInit(e:AS2LoaderEvent) {
    addChild(AS2Loader(e.target));
}

The above code will load the AS2 SWF and once loaded it will add it to the display list. Next, you can register event listeners or make function calls on the AS2 SWF. The nice thing about this is that you can also request to receive back the return value of the function calls you make (since under the hood this is using Local Connection objects the return value of the function calls you make will be delivered through AS2LoaderEvents). So let’s proceed.

Suppose our AS2 SWF dispatches an “ABC” event. The following piece of code will register an event listener for this event:

as2ldr.addEventListenerOnAS2('ABC', onABCEvent);
...
function onABCEvent(e:AS2LoaderEvent) {
    // the original AS2 event object is accessible through
    // e.data.eventObj:
    trace(e.data.eventObj.type + ' event dispatched from AS2.');
}

If you want to call a function on the AS2 SWF (eg: gotoAndPlay() or stop() or anything else that’s public) you’ll do it like this (the following code assumes there’s a function say(s:String) defined on the AS2 SWF):

as2ldr.callAS2Method('say', 'hello from AS3');

In case you need to call a function on the AS2 SWF and also get the return value there’s no problem. Assuming there’s a function sum(a, b) that returns the sum of a and b, the following code will call sum() on the AS2 and also request and process the return value.

as2ldr.getAS2MethodResult('sum', 2, 5);

// to get the return value from sum, we need to register an event
// listener on the AS2Loader object:
as2ldr.addEventListener('onAS2sumResult', onAS2SumResult);

function onAS2SumResult(e:AS2LoaderEvent) {
    trace('The result of 2 + 5 is ' + e.data.result);
}

As you can see from the above example, if you call a function and also request its return value, the AS2Loader object will dispatch an event named “onAS2[function name]Result” when the return value is available.

I’ve created a test/demo page here. You can also download the AS2Loader class and the example page.

Specifically, I wanted the ability to specify a time limit for remoting calls and have multiple ways of getting the result back (since it’s an asynchronous call). Here are some examples.

Connect the the remote service:

import com.onsysol.remoting.*;

var service:RemoteService = new RemoteService('http://myserver.com/gateway.php', 'MyService');
service.connect();

Make a remote call to MyMethod() and receive the result via event listeners:

service.addEventListener('onMyMethodResult', onMyMethodResult);
service.addEventListener('onMyMethodFault', onMyMethodFault);
service.MyMethod('param1', 'param2', 'etc...');

function onMyMethodResult(e:ResultEvent) {
    trace(e.result);
}

function onMyMethodFault(e:FaultEvent) {
    trace(e.fault);
}

In case you don’t want to use an event listener for every remoting call you make you can simply listen for a “default” event triggered after every remoting call that doesn’t have a specific event listener registered for it. So, instead of the above, you could have:

service.addEventListener(ResultEvent.RESULT, onResult);
service.addEventListener(FaultEvent.FAULT, onFault);
service.MyMethod();

function onResult(e:ResultEvent) {
    trace('Result event received from ' + e.prop['methodName']);
    trace(e.result);
}

function onFault(e:FaultEvent) {
    trace('Fault event received from ' + e.prop['methodName']);
    trace(e.fault);
}

And finally, if you don’t want to use events at all to get the response, you could use callback/anonymous functions, like this:

var prop:Object = {
    onResultCallback: function(result:Object, prop:Object) {
        trace('do something in your function...');
    },
    onFaultCallback: function(fault:Object, prop:Object) {
    }
};
service.call('MyMethod', prop, 'param1', 'param2', 'etc...');

The default timeout is 2 seconds, but you can specify a new timeout value for all calls or on a per call basis:

// General timeout value, used for all calls that don't have a specific timeout:
RemoteService.TIMEOUT = 5000;   // 5 seconds

// Make a remoting call with timeout set to 20 seconds:
service.call('MyMethod', {timeout: 20000}, 'param1', '...');

You can handle timeouts by either registering specific event listeners (onMyMethodTimeout), using the generic event (onTimeout) or using callback/anonymous function (onTimeoutCallback) in a similar way to how a result or a fault is handled.

Download the library here.