The Space For App Developers

// eventDispatcher.as script file
 
package 
{
	import flash.events.IEventDispatcher;
 
	public function get eventDispatcher():IEventDispatcher
	{
		return _eventDispatcher;
	}
}
 
import flash.events.EventDispatcher;
import flash.events.IEventDispatcher;
 
var _eventDispatcher:IEventDispatcher = new EventDispatcher();

public class MyViewPM
{
    public function btn_clickHandler():void
    {
        eventDispatcher.dispatchEvent(new MyEvent(MyEvent.EVENT_TYPE));
    }
}

// remoteService.as script file
 
package
{
	import com.riaspace.un.IRemoteService;
 
	public function get remoteService():IRemoteService
	{
		return _remoteService;
	}
}
 
var _remoteService:IRemoteService = new RemoteService();
 
import com.riaspace.un.IRemoteService;
 
import mx.rpc.AsyncToken;
import mx.rpc.Responder;
import mx.rpc.remoting.Operation;
import mx.rpc.remoting.RemoteObject;
 
internal class RemoteService implements IRemoteService
{
	private var configObj:Object;
 
	public function set config(value:Class):void
	{
		configObj = new value();
	}
 
	public function getRemoteObject(remoteObjectId:String):RemoteObject
	{
		if (configObj)
			return configObj[remoteObjectId];
		return null;
	}
 
	public function callDirectly(token:AsyncToken, resultHandler:Function, faultHandler:Function):void
	{
		token.addResponder(new Responder(resultHandler, faultHandler));
	}
 
	public function call(remoteObjectId:String, methodName:String, args:Array = null, resultHandler:Function = null, faultHandler:Function = null):void
	{
		var remoteObject:RemoteObject = getRemoteObject(remoteObjectId);
		if (!remoteObject)
			throw new Error(remoteObjectId + " not configured!");
 
		var method:Operation = remoteObject[methodName];
		method.arguments = args;
		callDirectly(method.send(), resultHandler, faultHandler);
	}
}

// some AS3 class
 
...
remoteService.callDirectly(myRemoteObject.remoteMethod(param), remoteMethod_resultHandler, 
    remoteMethod_faultHandler);
...
 
private function remoteMethod_resultHandler(event:ResultEvent):void
{
    // Handle remote method call result
}
 
private function remoteMethod_faultHandler(event:ResultEvent):void
{
    // Handle remote method call fault
}

// RemoteServiceConfig.mxml file
 
<?xml version="1.0" encoding="utf-8"?>
<fx:Object xmlns:fx="http://ns.adobe.com/mxml/2009" xmlns:s="library://ns.adobe.com/flex/spark">
 
	<fx:Declarations>
 
		<s:ChannelSet id="channels">
			<s:AMFChannel url="http://yourhost.tld/services/amf" />
		</s:ChannelSet>
 
		<s:RemoteObject id="myRemoteObject" destination="someDestination" channelSet="{channels}" />
 
	</fx:Declarations>
 
</fx:Object>

// Main.mxml file
...
 
protected function mobileapplication_creationCompleteHandler(event:FlexEvent):void
{
    remoteService.config = RemoteServiceConfig;
}
 
...

// some AS3 class
 
...
remoteService.call("myRemoteObject", "remoteMethod", [param], remoteMethod_resultHandler, 
    remoteMethod_faultHandler);
...
 
private function remoteMethod_resultHandler(event:ResultEvent):void
{
    // Handle remote method call result
}
 
private function remoteMethod_faultHandler(event:ResultEvent):void
{
    // Handle remote method call fault
}

// applicationContext.as file
 
package
{
	public function get applicationContext():ApplicationContext
	{
		return _applicationContext;
	}
}
 
var _applicationContext:ApplicationContext = new ApplicationContext();
 
import flash.events.Event;
import flash.events.EventDispatcher;
import flash.events.IEventDispatcher;
import flash.utils.Proxy;
import flash.utils.flash_proxy;
 
import mx.events.PropertyChangeEvent;
import mx.events.PropertyChangeEventKind;
 
use namespace flash_proxy;
 
internal dynamic class ApplicationContext extends Proxy implements IEventDispatcher
{
 
	private var values:Object;
 
	private var contextEventHandler:IEventDispatcher;
 
	public function ApplicationContext()
	{
		contextEventHandler = new EventDispatcher(this);
		values = new Object();
	}
 
	flash_proxy override function getProperty(name:*):*
	{
		return values[name];
	}
 
	flash_proxy override function setProperty(name:*, value:*):void
	{
		var oldValue:* = values[name];
		values[name] = value;
		var kind:String = PropertyChangeEventKind.UPDATE;
		dispatchEvent(new PropertyChangeEvent(PropertyChangeEvent.PROPERTY_CHANGE, false, false, kind, name, oldValue, value, this));
	}
 
	public function hasEventListener(type:String):Boolean
	{
		return contextEventHandler.hasEventListener(type);
	}
 
	public function willTrigger(type:String):Boolean
	{
		return contextEventHandler.willTrigger(type);
	}
 
	public function addEventListener(type:String, listener:Function, useCapture:Boolean=false, priority:int=0.0, useWeakReference:Boolean=false):void
	{
		contextEventHandler.addEventListener(type, listener, useCapture, priority, useWeakReference);
	}
 
	public function removeEventListener(type:String, listener:Function, useCapture:Boolean=false):void
	{
		contextEventHandler.removeEventListener(type, listener, useCapture);
	}
 
	public function dispatchEvent(event:Event):Boolean
	{
		return contextEventHandler.dispatchEvent(event);
	}
}

// some AS3 class
...
applicationContext.myObject = new MyObject();
...
 
 
// another AS3 class
...
var myObject:MyObject = applicationContext.myObject;
...

// some AS3 class
...
IEventDispatcher(applicationContext).addEventListener(
    PropertyChangeEvent.PROPERTY_CHANGE, applicationContext_changeHandler);
...