application.onConnect(myclient)
{
this.acceptConnection(myclient);

myclient(“methodToCall”, null, args);

}

on the client side I did have to define the method being called as a method in an external public class and pass it to the client property of the NetConnection object like this:

//external class

package{
public ExternalClass{

public ExternalClass(){
//empty constructor
}

public methodToCall(args)
{
trace(args);
}
}
}

in the main timeline of the client swf

var newPublicObject:ExternalClass = new ExternalClass();

var my_nc:NetConnection = new NetConnection();
my_nc.client = newPublicObject;

my_nc.connect(rtmp://www.domain.com/applicaitonName/AppInstance);

This all works fine, but I cannot get any call to work where the client calls a server method. According to the documentation, you have to define the server side method on the Client Object that is passed to the onConnect Event in the application main.asc. That right there sounds like a name space problem to me, since that is also where you call client side methods right?

It is supposed to go something like this on the server side:

application.onConnect(myclient)
{

this.acceptConnection(myclient);

myclient.methodToCall = function()
{
return “someString”;
}
}

The client swf calls the method using the NetConnection call method:

my_nc.call(“methodToCall”,null, args);

the second parameter is a Responder Class object that you can define. It is used to set up functions to handle return values if the call succeeds or fails like this:

var myResponder:Responder = new Responder(successFunction, failFunction);

so you could change the NetConnection call to

my_nc.call(“methodToCall”,myResponder,args);

If the call fails it sends a return object to the failFunction that has three properties…
level
code
description – This one tells you why it failed

so you can set up the failFunction like this:

function failFunction(e:Object)
{
//Note that the return object is just a generic object not an error object
trace(e.descriptoin);
}

This always traces as Method not found no matter how I try to define the method on the server side

I have tried every method that they show in the server documentation and I can’t get the client to call a server side function. One guess was the AMF encoding so I set that to 0 for the earlier encoding method that is suppported by FMS 2 and that eliminated IO Errors being returned from the NetConnection object, but it did not solve the issue of callling server side functions. This is a big problem. I am going to try creating server side classes that might also solve the scoping issue on the server side the way it did on the client side and see if that works. Let me know if anyone solves this one. Thanks.

So, this:

client.call(this.callPrefix + ‘method’, null);

becomes:

client.call(‘method’, null, this.callPrefix);

You then have your client property, typically a class, handle the routing. See the comments in the previous post.

Thanks for posting this message. I’ve been at it porting an FMS application to Actionscript 3.0 and Flex for a week and couldn’t get the method calls with NetConnection to work. It’s consoling that I’m not the only one having problems.

I’m using Influxis as a hosting, so there’s no easy way to circumvent the object decoration that is used as a namespace mechanism: The standard components use the /-substitution and cannot be overriden, unless I rewrite the whole component framework.

When I use a dynamic class as client for the NetConnection object on the client-side, the debugger never complains when it cannot find a method, so this isn’t very helpful. Next, I tried to use a static class and yes, the debugger signals an exception when a method cannot be found, but only if the server-side call was not decorated with class and instance.

Then, I tried to extend the Proxy class and use it as a client object for NetConnection to see what exactly is happening on the client side. Unfortunately to no avail. It seems like the method calls with slashes in them are just plainly ignored by Flash Player 9.

The experiment with Proxy did reveil something interesting, though. It turns out that Flash Player 9 doesn’t actually ‘call’ the function on the client object. Instead, it ‘get’s the function as a property and then calls it as a method on some different object.

It’s a mistery to me how Flash Player decides what object to call the method on, but it looks like it has to do with the last created instance of the class that the method belongs to.

Well, I hope this gives some avenues of inquiry for other readers and that some of you may shed some light on this.

Preface As part of my Flash & Flex speech I’ve been giving throughout the year, I wanted to create a real-world app where you would want utilize Flash & Flex together. Back in late July, I started creating a YouTube…