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.

I’ve created 2 small shell (PHP) scripts that will do just that, one using RSYNC/SSH and the other one plain FTP (you need to have ncftp installed). Here’s how to use them:

$> cd dir_to_deploy/
$> deploy now

Or, for the deployment via FTP:

$> cd dir_to_deploy/
$> ftpdeploy

It’s quite simple! Assuming you’ve installed the scripts in your path (with +x permission) you just go to the directory you want deployed and issue the above commands. You will be asked for the required information, such as host, user, pass, remote path, etc… the nice thing is that this information is saved on a per directory basis, so the next time you deploy you don’t have to enter it again, unless you want to change something, of course!

These tools were specially created to deploy applications made with My Framework, but they will work in almost any situation. You also have options to exclude certain files from deployment (like log and temporary files), but to find out how either ask me by posting a comment or read the source code.

Another tool I created that’s also available to download at the end of this post might help you if you want to minify and compress your JS files. It uses a PHP library that you can find here.  It is a very good practice to minify and compress your JS files because you save a lot of bandwidth, especially if you’re web server is configured to serve compressed Javascript for browsers that support this (almost all!).

Suppose you have a JS file named “myjsfile.js”. To minify it, simply use:

$> minifyjs myjsfile.js

The above command will create 2 new files in the same directory as the target file, named “myjsfile.min.js” and “myjsfile.min.js.gz”. You figured out what these are, right?

Download these tools here.

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.