Flash Dynamic Runtime Class'

I’ve been re-looking at how to do runtime class sharing rather then the typical compile-time sharing. This started when i was implementing a proxy for class’ that you want to runtime share. So you can call methods on a class right away, even if it isn’t loaded yet.

There are several hurdles to overcome to make this work, the biggest, for me, was figuring out how to dynamically instance a class, from a string representation, at runtime.

The method that worked for me was to use the following code




function makeClass(klass:String):Function{
    var ka = klass.split(".");
    var f = _global;
    while(ka.length){
        f = f[ka.shift()];
    }
    return f;
}

After i had figured this out, i was searching for some more info, and found that this is the way most people do it. I tried to use eval, but didn’t have any luck. Also, as2lib has a lot of great reflection functionality, but i was just trying to learn how to do it myself.

Here is the wrapper class, which is a proof of concept example of the runtime proxy.




import Deferred;

class wrapper {


    public var loaded:Boolean = false;

    private var _args:Array;
    private var _proxy:String;
    private var _func:Function;
    private var _pickels:Array;
    private var _mc:MovieClip;
    private var _mcl:MovieClipLoader;

    public function wrapper(){
        _pickels = new Array();
        _proxy = String(arguments.shift());

        _args = arguments;

        _mcl = new MovieClipLoader();
        _mcl.addListener(this);
        _load();
    }

    private function _load():Void {
        // Take the this.func string, which should be a dotted path
        // eg: "org.tvo.myclass"
        // We then need to load a file called "org/tvo/myclass.swf"
        // Which will have the 'myclass' code in it, which will then be 
        // used to create an instance of 'myclass' in the onLoaded function.
        _mc = _level0.createEmptyMovieClip(_proxy, _level0.getNextHighestDepth());
        var path = _proxy.split(".");
        path = path.join("/");
        path = path + ".swf";
        _mcl.loadClip(path, _mc);
    }


    private function onLoadInit():Void{
        loaded = true;
        var pa = _proxy.split(".");
        var f = _global;
        while(pa.length){
            f = f[pa.shift()];
        }
        _func = new f();

        _func.init.apply(_func, _args);
        _applyPickels();
    }


    private function _applyPickels():Void{
        var count = _pickels.length;

        var func_name, func_args, func_deferred, ret_val;
        while(count--){     
            func_name = _pickels[count].name;
            func_args = _pickels[count].args;
            func_deferred = _pickels[count].deferred;
            ret_val = this[func_name].apply(this,  func_args);
            if(func_deferred){
                func_deferred.callback(ret_val);
            }
        }   
    }

    public function __resolve(name:String){
        // check to see if the user wants to call this method as a deferred.
        // This is only an issue if the class has not yet been loaded.
        // So, to make a function call asynchronous, you add '_deferred' to the
        // end of it.

        var _this = this;
        var f:Function;

        var na = name.split("_");
        var def = na.pop().toLowerCase();
        var is_deferred = def == "deferred";
        if(is_deferred){
            name = na.join("_");
        }else{
            na.push(def);
            name = na.join("_");
        }

        if(loaded){
            if(is_deferred){
                f = function () {
                    var d = new Deferred(); 
                    d.callback(_this._func[name].apply(_this, arguments));
                    return d;
                }
                return f;
            }
            else{
                return _func[na]; 
            }
        }else{

            f = function(){
                if(is_deferred){
                    var d = new Deferred();
                }else{
                    var d = false;
                }
                var __name = name;
                var __args = arguments;
                _this._pickels.push({name:__name, args:__args, deferred:d});
                return d;
            }
            return f;
        }
    }
}

So, using this, you can do something like x = wrapper("com.loc.myfunc");. Then you can call functions on x as if it were the com.loc.myfunc instance as long as the functions don’t return anything. The wrapper class looks for the com.loc.myfunc runtime file in the com/loc/myfunc.swf file. In real life, the location of your shared assets would be controlled via some kind of config file.

Anyway, it works, so i’ll probably never look at it again. But in case i do, i want to have a copy of it around!

Another way to do this would be to use the Deferred methods which the Python asynchronous network framework Twisted uses. There is an implementation in actionscript (thanks to Bob Ippolito , which came out of the mochikit javascript library (i’m actually not sure which came first). This would allow you to call methods on the wrapper, and register callbacks, which would receive the return values once the class was properly loaded. I leave this as an exercise for the reader. Although i’ll probably try to implement this myself, as it sounds pretty cool.

I should also mention that Ted was the first to really put me on to runtime sharing via his PSDK/FLOW projects.

I do wonder if, now that broadband is so much more prevalent, if runtime sharing still stacks up? I was also thinking about Laszlo and how it could fit in… Creating/Updating the new runtime shared bits as the AS files are changed, but using caching to remove most of the bandwidth usage… I’m sure there is much more to consider… Just not enough time!

UPDATE: I got it working using the aboved mentioned Deferred code. I had to make changes in the __resolve and _applyPickles functions. Basically, adding the deferred to be returned to the caller. This now makes all calls asynchronous, or rather, all calls before the dynamic class is loaded, asyncronous. I’m not sure if its better to have the client code deal with the return type, have it do a instanceof Deferred, and take the appropriate action… Have to think about this some more. This also means that any property access’ that are attempted before the class is loaded are lost, only function calls are saved. Once the class is loaded, property access works as usual. I think.

UPDATE 2: I’ve included the newest version of the wrapper class above. This now lets you set wether you want a function to be asynchronous or not, by appending _deferred to the end of the method name. I’m also including my tester class (org.test.tester), and the code that sits in the .fla to make it all go. Here are the instructions:

Create demo directory.
Add org sub-directory.
Add test sub-directory to org directory.
Copy wrapper (above) and tester (below) code into .as files with same name ie wrapper.as and tester.as. Keep them in the demo directory.
Create a tester.fla in the demo dir and include only org.test.tester; as a script in the first frame (this is to force it to add the code to itself).
Publish tester.fla.
Put tester.swf into the demo/org/test directory.
Create a example.fla file in the demo dir.
Copy the example (below tester) code into a script in frame 1 of the example.fla file.
Publish the example.fla and look at the cool trace statements!

Here is the tester code:




class org.test.tester{

    public var a;
    public var b;
    public var c;

    public function tester(){
    }

    public function init(a,b,c){
        this.a = a;
        this.b = b;
        this.c = c;
    }

    public function output(msg:String):String{
        return msg;
    }

    public function test_with_underscore(msg:String):String{
        return output(msg);
    }
}

Here is the code to go into the example.fla:




import wrapper;

y = new wrapper("org.test.tester", "one", "two", "three");
a = y.output_deferred("Hello world!");
a.addCallback(this.callback);
c = y.output("Direct from wrapper"); // You will never see this output.
c.addCallback(this.callback);

function callback(val){
    trace("callback: " + val);
}

var intervalID = setInterval(calldirect, 500, this);

function calldirect(){
    clearInterval(intervalID);
    var res = y.output("should call direct...");
    if(res instanceof Deferred){
        trace("still loading class");
        res.addCallback(_level0.callback);
    }else{
        trace("class loaded, result: " + res);
    }
    res = y.output_deferred("calling with a deferred, even after loaded");
    res.addCallback(_level0.callback);
}

There is some magic in there now, but i think its pretty cool stuff. Maybe useful to somebody too!

(If you haven't left a comment here before, you may need to be approved by the site owner before your comment will appear. Until then, it won't appear on the entry. Thanks for waiting.)

Flash Dynamic Runtime Class'

Leave a comment

About this Entry

Search