home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / channels / NetConnectionChannel.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  13.6 KB  |  389 lines
  1. package mx.messaging.channels
  2. {
  3.    import flash.events.AsyncErrorEvent;
  4.    import flash.events.ErrorEvent;
  5.    import flash.events.IOErrorEvent;
  6.    import flash.events.NetStatusEvent;
  7.    import flash.events.SecurityErrorEvent;
  8.    import flash.events.TimerEvent;
  9.    import flash.net.NetConnection;
  10.    import flash.net.ObjectEncoding;
  11.    import mx.core.mx_internal;
  12.    import mx.logging.Log;
  13.    import mx.messaging.MessageAgent;
  14.    import mx.messaging.MessageResponder;
  15.    import mx.messaging.events.ChannelFaultEvent;
  16.    import mx.messaging.events.MessageEvent;
  17.    import mx.messaging.messages.CommandMessage;
  18.    import mx.messaging.messages.IMessage;
  19.    import mx.messaging.messages.ISmallMessage;
  20.    import mx.messaging.messages.MessagePerformanceInfo;
  21.    import mx.messaging.messages.MessagePerformanceUtils;
  22.    
  23.    use namespace mx_internal;
  24.    
  25.    public class NetConnectionChannel extends PollingChannel
  26.    {
  27.       mx_internal var _appendToURL:String;
  28.       
  29.       protected var _nc:NetConnection;
  30.       
  31.       public function NetConnectionChannel(param1:String = null, param2:String = null)
  32.       {
  33.          super(param1,param2);
  34.          _nc = new NetConnection();
  35.          _nc.objectEncoding = ObjectEncoding.AMF3;
  36.          _nc.client = this;
  37.       }
  38.       
  39.       public function AppendToGatewayUrl(param1:String) : void
  40.       {
  41.          if(param1 != null && param1 != "" && param1 != mx_internal::_appendToURL)
  42.          {
  43.             if(Log.isDebug())
  44.             {
  45.                _log.debug("\'{0}\' channel will disconnect and reconnect with with its session identifier \'{1}\' appended to its endpoint url \n",id,param1);
  46.             }
  47.             mx_internal::_appendToURL = param1;
  48.          }
  49.       }
  50.       
  51.       public function receive(param1:IMessage, ... rest) : void
  52.       {
  53.          var mpiutil:MessagePerformanceUtils = null;
  54.          var msg:IMessage = param1;
  55.          if(Log.isDebug())
  56.          {
  57.             _log.debug("\'{0}\' channel got message\n{1}\n",id,msg.toString());
  58.             if(this.mpiEnabled)
  59.             {
  60.                try
  61.                {
  62.                   mpiutil = new MessagePerformanceUtils(msg);
  63.                   _log.debug(mpiutil.prettyPrint());
  64.                }
  65.                catch(e:Error)
  66.                {
  67.                   _log.debug("Could not get message performance information for: " + msg.toString());
  68.                }
  69.             }
  70.          }
  71.          dispatchEvent(MessageEvent.createEvent(MessageEvent.MESSAGE,msg));
  72.       }
  73.       
  74.       override protected function internalSend(param1:MessageResponder) : void
  75.       {
  76.          var _loc3_:MessagePerformanceInfo = null;
  77.          var _loc4_:IMessage = null;
  78.          setFlexClientIdOnMessage(param1.message);
  79.          if(mpiEnabled)
  80.          {
  81.             _loc3_ = new MessagePerformanceInfo();
  82.             if(recordMessageTimes)
  83.             {
  84.                _loc3_.sendTime = new Date().getTime();
  85.             }
  86.             param1.message.headers[MessagePerformanceUtils.MPI_HEADER_IN] = _loc3_;
  87.          }
  88.          var _loc2_:IMessage = param1.message;
  89.          if(useSmallMessages && _loc2_ is ISmallMessage)
  90.          {
  91.             _loc4_ = ISmallMessage(_loc2_).getSmallMessage();
  92.             if(_loc4_ != null)
  93.             {
  94.                _loc2_ = _loc4_;
  95.             }
  96.          }
  97.          _nc.call(null,param1,_loc2_);
  98.       }
  99.       
  100.       override protected function getDefaultMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  101.       {
  102.          return new NetConnectionMessageResponder(param1,param2,this);
  103.       }
  104.       
  105.       protected function securityErrorHandler(param1:SecurityErrorEvent) : void
  106.       {
  107.          defaultErrorHandler("Channel.Security.Error",param1);
  108.       }
  109.       
  110.       private function defaultErrorHandler(param1:String, param2:ErrorEvent) : void
  111.       {
  112.          var _loc3_:ChannelFaultEvent = ChannelFaultEvent.createEvent(this,false,param1,"error",param2.text + " url: \'" + endpoint + "\'");
  113.          _loc3_.rootCause = param2;
  114.          if(_connecting)
  115.          {
  116.             connectFailed(_loc3_);
  117.          }
  118.          else
  119.          {
  120.             dispatchEvent(_loc3_);
  121.          }
  122.       }
  123.       
  124.       override protected function getPollSyncMessageResponder(param1:MessageAgent, param2:CommandMessage) : MessageResponder
  125.       {
  126.          return new PollSyncMessageResponder(param1,param2,this);
  127.       }
  128.       
  129.       override public function get useSmallMessages() : Boolean
  130.       {
  131.          return super.useSmallMessages && _nc != null && _nc.objectEncoding >= ObjectEncoding.AMF3;
  132.       }
  133.       
  134.       override protected function internalConnect() : void
  135.       {
  136.          var url:String = null;
  137.          var i:int = 0;
  138.          var temp:String = null;
  139.          var j:int = 0;
  140.          super.internalConnect();
  141.          url = endpoint;
  142.          if(mx_internal::_appendToURL != null)
  143.          {
  144.             i = int(url.indexOf("wsrp-url="));
  145.             if(i != -1)
  146.             {
  147.                temp = url.substr(i + 9,url.length);
  148.                j = int(temp.indexOf("&"));
  149.                if(j != -1)
  150.                {
  151.                   temp = temp.substr(0,j);
  152.                }
  153.                url = url.replace(temp,temp + mx_internal::_appendToURL);
  154.             }
  155.             else
  156.             {
  157.                url += mx_internal::_appendToURL;
  158.             }
  159.          }
  160.          if(_nc.uri != null && _nc.uri.length > 0 && _nc.connected)
  161.          {
  162.             _nc.removeEventListener(NetStatusEvent.NET_STATUS,statusHandler);
  163.             _nc.close();
  164.          }
  165.          _nc.addEventListener(NetStatusEvent.NET_STATUS,statusHandler);
  166.          _nc.addEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
  167.          _nc.addEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  168.          _nc.addEventListener(AsyncErrorEvent.ASYNC_ERROR,asyncErrorHandler);
  169.          try
  170.          {
  171.             _nc.connect(url);
  172.          }
  173.          catch(e:Error)
  174.          {
  175.             e.message += "  url: \'" + url + "\'";
  176.             throw e;
  177.          }
  178.       }
  179.       
  180.       protected function ioErrorHandler(param1:IOErrorEvent) : void
  181.       {
  182.          defaultErrorHandler("Channel.IO.Error",param1);
  183.       }
  184.       
  185.       protected function statusHandler(param1:NetStatusEvent) : void
  186.       {
  187.       }
  188.       
  189.       override protected function internalDisconnect(param1:Boolean = false) : void
  190.       {
  191.          super.internalDisconnect(param1);
  192.          shutdownNetConnection();
  193.          disconnectSuccess(param1);
  194.       }
  195.       
  196.       override protected function connectTimeoutHandler(param1:TimerEvent) : void
  197.       {
  198.          shutdownNetConnection();
  199.          super.connectTimeoutHandler(param1);
  200.       }
  201.       
  202.       public function get netConnection() : NetConnection
  203.       {
  204.          return _nc;
  205.       }
  206.       
  207.       protected function shutdownNetConnection() : void
  208.       {
  209.          _nc.removeEventListener(SecurityErrorEvent.SECURITY_ERROR,securityErrorHandler);
  210.          _nc.removeEventListener(IOErrorEvent.IO_ERROR,ioErrorHandler);
  211.          _nc.removeEventListener(NetStatusEvent.NET_STATUS,statusHandler);
  212.          _nc.removeEventListener(AsyncErrorEvent.ASYNC_ERROR,asyncErrorHandler);
  213.          _nc.close();
  214.       }
  215.       
  216.       protected function asyncErrorHandler(param1:AsyncErrorEvent) : void
  217.       {
  218.          defaultErrorHandler("Channel.Async.Error",param1);
  219.       }
  220.    }
  221. }
  222.  
  223. import mx.core.mx_internal;
  224. import mx.messaging.MessageAgent;
  225. import mx.messaging.MessageResponder;
  226. import mx.messaging.events.ChannelEvent;
  227. import mx.messaging.events.ChannelFaultEvent;
  228. import mx.messaging.messages.AcknowledgeMessage;
  229. import mx.messaging.messages.AsyncMessage;
  230. import mx.messaging.messages.CommandMessage;
  231. import mx.messaging.messages.ErrorMessage;
  232. import mx.messaging.messages.IMessage;
  233. import mx.resources.IResourceManager;
  234. import mx.resources.ResourceManager;
  235.  
  236. use namespace mx_internal;
  237.  
  238. class NetConnectionMessageResponder extends MessageResponder
  239. {
  240.    private var resourceManager:IResourceManager = ResourceManager.getInstance();
  241.    
  242.    public function NetConnectionMessageResponder(param1:MessageAgent, param2:IMessage, param3:NetConnectionChannel)
  243.    {
  244.       super(param1,param2,param3);
  245.       param3.addEventListener(ChannelEvent.DISCONNECT,channelDisconnectHandler);
  246.       param3.addEventListener(ChannelFaultEvent.FAULT,channelFaultHandler);
  247.    }
  248.    
  249.    protected function channelFaultHandler(param1:ChannelFaultEvent) : void
  250.    {
  251.       disconnect();
  252.       var _loc2_:ErrorMessage = param1.createErrorMessage();
  253.       _loc2_.correlationId = message.messageId;
  254.       if(!param1.channel.connected)
  255.       {
  256.          _loc2_.faultCode = ErrorMessage.MESSAGE_DELIVERY_IN_DOUBT;
  257.       }
  258.       agent.fault(_loc2_,message);
  259.    }
  260.    
  261.    override protected function requestTimedOut() : void
  262.    {
  263.       disconnect();
  264.       statusHandler(createRequestTimeoutErrorMessage());
  265.    }
  266.    
  267.    override protected function statusHandler(param1:IMessage) : void
  268.    {
  269.       var _loc2_:AcknowledgeMessage = null;
  270.       var _loc3_:ErrorMessage = null;
  271.       disconnect();
  272.       if(param1 is AsyncMessage)
  273.       {
  274.          if(AsyncMessage(param1).correlationId == message.messageId)
  275.          {
  276.             _loc2_ = new AcknowledgeMessage();
  277.             _loc2_.correlationId = AsyncMessage(param1).correlationId;
  278.             _loc2_.headers[AcknowledgeMessage.ERROR_HINT_HEADER] = true;
  279.             agent.acknowledge(_loc2_,message);
  280.             agent.fault(param1 as ErrorMessage,message);
  281.          }
  282.          else if(param1 is ErrorMessage)
  283.          {
  284.             agent.fault(param1 as ErrorMessage,message);
  285.          }
  286.          else
  287.          {
  288.             _loc3_ = new ErrorMessage();
  289.             _loc3_.faultCode = "Server.Acknowledge.Failed";
  290.             _loc3_.faultString = resourceManager.getString("messaging","noErrorForMessage");
  291.             _loc3_.faultDetail = resourceManager.getString("messaging","noErrorForMessage.details",[message.messageId,AsyncMessage(param1).correlationId]);
  292.             _loc3_.correlationId = message.messageId;
  293.             agent.fault(_loc3_,message);
  294.          }
  295.       }
  296.       else
  297.       {
  298.          _loc3_ = new ErrorMessage();
  299.          _loc3_.faultCode = "Server.Acknowledge.Failed";
  300.          _loc3_.faultString = resourceManager.getString("messaging","noAckMessage");
  301.          _loc3_.faultDetail = resourceManager.getString("messaging","noAckMessage.details",[!!param1 ? param1.toString() : "null"]);
  302.          _loc3_.correlationId = message.messageId;
  303.          agent.fault(_loc3_,message);
  304.       }
  305.    }
  306.    
  307.    protected function channelDisconnectHandler(param1:ChannelEvent) : void
  308.    {
  309.       disconnect();
  310.       var _loc2_:ErrorMessage = new ErrorMessage();
  311.       _loc2_.correlationId = message.messageId;
  312.       _loc2_.faultString = resourceManager.getString("messaging","deliveryInDoubt");
  313.       _loc2_.faultDetail = resourceManager.getString("messaging","deliveryInDoubt.details");
  314.       _loc2_.faultCode = ErrorMessage.MESSAGE_DELIVERY_IN_DOUBT;
  315.       agent.fault(_loc2_,message);
  316.    }
  317.    
  318.    private function disconnect() : void
  319.    {
  320.       channel.removeEventListener(ChannelEvent.DISCONNECT,channelDisconnectHandler);
  321.       channel.removeEventListener(ChannelFaultEvent.FAULT,channelFaultHandler);
  322.    }
  323.    
  324.    override protected function resultHandler(param1:IMessage) : void
  325.    {
  326.       var _loc2_:ErrorMessage = null;
  327.       disconnect();
  328.       if(param1 is AsyncMessage)
  329.       {
  330.          if(AsyncMessage(param1).correlationId == message.messageId)
  331.          {
  332.             agent.acknowledge(param1 as AcknowledgeMessage,message);
  333.          }
  334.          else
  335.          {
  336.             _loc2_ = new ErrorMessage();
  337.             _loc2_.faultCode = "Server.Acknowledge.Failed";
  338.             _loc2_.faultString = resourceManager.getString("messaging","ackFailed");
  339.             _loc2_.faultDetail = resourceManager.getString("messaging","ackFailed.details",[message.messageId,AsyncMessage(param1).correlationId]);
  340.             _loc2_.correlationId = message.messageId;
  341.             agent.fault(_loc2_,message);
  342.          }
  343.       }
  344.       else
  345.       {
  346.          _loc2_ = new ErrorMessage();
  347.          _loc2_.faultCode = "Server.Acknowledge.Failed";
  348.          _loc2_.faultString = resourceManager.getString("messaging","noAckMessage");
  349.          _loc2_.faultDetail = resourceManager.getString("messaging","noAckMessage.details",[!!param1 ? param1.toString() : "null"]);
  350.          _loc2_.correlationId = message.messageId;
  351.          agent.fault(_loc2_,message);
  352.       }
  353.    }
  354. }
  355.  
  356. class PollSyncMessageResponder extends NetConnectionMessageResponder
  357. {
  358.    public function PollSyncMessageResponder(param1:MessageAgent, param2:IMessage, param3:NetConnectionChannel)
  359.    {
  360.       super(param1,param2,param3);
  361.    }
  362.    
  363.    override protected function channelFaultHandler(param1:ChannelFaultEvent) : void
  364.    {
  365.    }
  366.    
  367.    override protected function channelDisconnectHandler(param1:ChannelEvent) : void
  368.    {
  369.    }
  370.    
  371.    override protected function resultHandler(param1:IMessage) : void
  372.    {
  373.       var _loc2_:CommandMessage = null;
  374.       super.resultHandler(param1);
  375.       if(param1 is AsyncMessage && AsyncMessage(param1).correlationId == message.messageId)
  376.       {
  377.          _loc2_ = CommandMessage(message);
  378.          switch(_loc2_.operation)
  379.          {
  380.             case CommandMessage.SUBSCRIBE_OPERATION:
  381.                NetConnectionChannel(channel).enablePolling();
  382.                break;
  383.             case CommandMessage.UNSUBSCRIBE_OPERATION:
  384.                NetConnectionChannel(channel).disablePolling();
  385.          }
  386.       }
  387.    }
  388. }
  389.