Maybe just changing the code to var callObject : Object = event.call; would help clarify a bit.

Thanks again,
Ben

It would be clearer if we could reverse the order of the two lines of code above, but there is no way to do that because the first line is the one that generates the call object.

As it turns out, there is no way that the return can arrive before the var is added, because all ActionScript code executes in a single thread.

For example, let’s suppose that you make an HTTP request in response to someone clicking on a button. All the lines of code for my click handler are guaranteed to execute before my result handler is called.

public function onClick(event: Event) : void
{
    myService.addEventListener(”result”, onResult);
    myService.send();

    callFunctionOne();
    callFunctionTwo();

    // …

    callFunctionOneMillion();

    // At this point, my click handler is done, and
    // control goes back to the event loop. The next
    // thing that will happen is that my result
    // handler will be called.
}

As for the handler.call(xxx), this is an example of confusing naming.

1. When the result handler of an RPC service is called, it gets a result event which has a field called “call”. This is the object that was returned to you when the original call was made.
2. In our own code, we are putting a handler on the call object which is a function object.
3. There are two ways to call any function object. The first way is just to use parentheses like this: myFunctionObject(arg1, arg2).
4. The second way is to use a method called “call” which every function object has. You use it like this: myFunctionObject.call(thisObject, arg1, arg2).
5. The benefit of using the second way is that you get to manually specify what object should be used for the “this” object when making the call.

*whew* This is all a bit confusing (which is why I wrote the post in the first place). I think I may need to clarify a bit more in a followup post.

call = myService.send();
call.handler = getAlbumInfoResult;

Shouldn’t you assign the vars to the call object before sending? Even though its probably unlikely (impossible?) that the return would arrive before the var was added, it reminds me of the practice of defining your onLoad method before calling load() back in the LoadVars days.

I am also hazy on handler.call(null, event); Is that the call object or a method named call? Could you clarify a bit?

Thanks!