BlueF’z

package {
	import flash.net.NetConnection;
	import flash.net.Responder;
	import flash.events.Event;
	import flash.events.EventDispatcher;
	import flash.events.ErrorEvent;
	import flash.events.DataEvent;
	import flash.events.IOErrorEvent;
	import flash.events.SecurityErrorEvent;
	import flash.events.NetStatusEvent;
 
	public class NetMessenger extends EventDispatcher {	
                public static const CONNECTED:String = "nc_connected";
                public static const GATEWAY:String = "gateway_url";
		public static var connected:Boolean;	
		private var _action:String;
		private var _nc:NetConnection;
		private var _data:Array;
		private var _responder:Responder;
		private var _response:String;
 
		public function NetMessenger(action:String, data:Array = null):void {
			_action = action;
			if (data != null) {
				_data = data.concat();
			} else {
				_data = [];
			}
			_responder = new Responder(onResult, onFault);
 
			_data.unshift(_responder);
			_data.unshift(_action);
			connected = false;
 
			init();
		};
 
		private function init():void {
			_nc = new NetConnection();
 
			_nc.addEventListener(IOErrorEvent.IO_ERROR , ioHandler);
			_nc.addEventListener(NetStatusEvent.NET_STATUS, netStatusHandler);
			_nc.addEventListener(SecurityErrorEvent.SECURITY_ERROR, securityErrorHandler);
 
			if (!connected) {
			     connect();
			}
		};
 
		public function connect():void {
			_nc.connect(GATEWAY);
		};
 
		public function call():void {
			dispatchEvent(new Event(Event.OPEN));
 
			var f:Function = _nc.call;
			f.apply(null, _data);
		};
 
		public function get action():String {
			return _action;
		};
 
		private function onResult(response:Object):void {
			_response = String(response);
			dispatchEvent(new DataEvent(DataEvent.DATA, false, false, String(response))); 
		};
 
		private function onFault(response:Object):void {
			dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, String(response.description))); 		
		};
 
		private function ioHandler(e:IOErrorEvent ):void {
			dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, "Unable to connect the server"));
		};
 
		private function netStatusHandler(e:NetStatusEvent):void {
			trace(">>>", e.info.code);
			switch (e.info.code) {
                              case "NetConnection.Connect.Success" :
			            dispatchEvent(new Event(CONNECTED));
                                    break;
 
                              case "NetConnection.Connect.Closed":
                	            break;
 
                              default :
                	            dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, e.info.code));
                                    break;
                        }
		};
 
		private function securityErrorHandler(e:SecurityErrorEvent):void {
                      dispatchEvent(new ErrorEvent(ErrorEvent.ERROR, false, false, "Security Error"));
                }
	}
}