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