home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / AbstractProducer.as < prev    next >
Encoding:
Text File  |  2009-05-06  |  10.3 KB  |  329 lines
  1. package mx.messaging
  2. {
  3.    import flash.events.TimerEvent;
  4.    import flash.utils.Timer;
  5.    import mx.core.mx_internal;
  6.    import mx.events.PropertyChangeEvent;
  7.    import mx.logging.Log;
  8.    import mx.messaging.events.ChannelEvent;
  9.    import mx.messaging.events.ChannelFaultEvent;
  10.    import mx.messaging.messages.AcknowledgeMessage;
  11.    import mx.messaging.messages.CommandMessage;
  12.    import mx.messaging.messages.ErrorMessage;
  13.    import mx.messaging.messages.IMessage;
  14.    import mx.resources.IResourceManager;
  15.    import mx.resources.ResourceManager;
  16.    
  17.    use namespace mx_internal;
  18.    
  19.    public class AbstractProducer extends MessageAgent
  20.    {
  21.       private var _currentAttempt:int;
  22.       
  23.       private var _autoConnect:Boolean = true;
  24.       
  25.       private var _reconnectTimer:Timer;
  26.       
  27.       protected var _shouldBeConnected:Boolean;
  28.       
  29.       private var _connectMsg:CommandMessage;
  30.       
  31.       private var _defaultHeaders:Object;
  32.       
  33.       private var _reconnectInterval:int;
  34.       
  35.       private var _reconnectAttempts:int;
  36.       
  37.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  38.       
  39.       public function AbstractProducer()
  40.       {
  41.          super();
  42.       }
  43.       
  44.       [Bindable(event="propertyChange")]
  45.       public function get reconnectAttempts() : int
  46.       {
  47.          return _reconnectAttempts;
  48.       }
  49.       
  50.       [Bindable(event="propertyChange")]
  51.       public function get defaultHeaders() : Object
  52.       {
  53.          return _defaultHeaders;
  54.       }
  55.       
  56.       public function set reconnectInterval(param1:int) : void
  57.       {
  58.          var _loc2_:PropertyChangeEvent = null;
  59.          var _loc3_:String = null;
  60.          if(_reconnectInterval != param1)
  61.          {
  62.             if(param1 < 0)
  63.             {
  64.                _loc3_ = resourceManager.getString("messaging","reconnectIntervalNegative");
  65.                throw new ArgumentError(_loc3_);
  66.             }
  67.             if(param1 == 0)
  68.             {
  69.                stopReconnectTimer();
  70.             }
  71.             else if(_reconnectTimer != null)
  72.             {
  73.                _reconnectTimer.delay = param1;
  74.             }
  75.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"reconnectInterval",_reconnectInterval,param1);
  76.             _reconnectInterval = param1;
  77.             dispatchEvent(_loc2_);
  78.          }
  79.       }
  80.       
  81.       public function set defaultHeaders(param1:Object) : void
  82.       {
  83.          var _loc2_:PropertyChangeEvent = null;
  84.          if(_defaultHeaders != param1)
  85.          {
  86.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"defaultHeaders",_defaultHeaders,param1);
  87.             _defaultHeaders = param1;
  88.             dispatchEvent(_loc2_);
  89.          }
  90.       }
  91.       
  92.       [Bindable(event="propertyChange")]
  93.       public function get reconnectInterval() : int
  94.       {
  95.          return _reconnectInterval;
  96.       }
  97.       
  98.       public function send(param1:IMessage) : void
  99.       {
  100.          var _loc2_:String = null;
  101.          var _loc3_:ErrorMessage = null;
  102.          if(!connected && autoConnect)
  103.          {
  104.             _shouldBeConnected = true;
  105.          }
  106.          if(defaultHeaders != null)
  107.          {
  108.             for(_loc2_ in defaultHeaders)
  109.             {
  110.                if(!param1.headers.hasOwnProperty(_loc2_))
  111.                {
  112.                   param1.headers[_loc2_] = defaultHeaders[_loc2_];
  113.                }
  114.             }
  115.          }
  116.          if(!connected && !autoConnect)
  117.          {
  118.             _shouldBeConnected = false;
  119.             _loc3_ = new ErrorMessage();
  120.             _loc3_.faultCode = "Client.Error.MessageSend";
  121.             _loc3_.faultString = resourceManager.getString("messaging","producerSendError");
  122.             _loc3_.faultDetail = resourceManager.getString("messaging","producerSendErrorDetails");
  123.             _loc3_.correlationId = param1.messageId;
  124.             mx_internal::internalFault(_loc3_,param1,false,true);
  125.          }
  126.          else
  127.          {
  128.             if(Log.isInfo())
  129.             {
  130.                _log.info("\'{0}\' {1} sending message \'{2}\'",id,_agentType,param1.messageId);
  131.             }
  132.             internalSend(param1);
  133.          }
  134.       }
  135.       
  136.       protected function stopReconnectTimer() : void
  137.       {
  138.          if(_reconnectTimer != null)
  139.          {
  140.             if(Log.isDebug())
  141.             {
  142.                _log.debug("\'{0}\' {1} stopping reconnect timer.",id,_agentType);
  143.             }
  144.             _reconnectTimer.removeEventListener(TimerEvent.TIMER,reconnect);
  145.             _reconnectTimer.reset();
  146.             _reconnectTimer = null;
  147.          }
  148.       }
  149.       
  150.       override public function channelDisconnectHandler(param1:ChannelEvent) : void
  151.       {
  152.          super.channelDisconnectHandler(param1);
  153.          if(_shouldBeConnected && !param1.rejected)
  154.          {
  155.             startReconnectTimer();
  156.          }
  157.       }
  158.       
  159.       protected function reconnect(param1:TimerEvent) : void
  160.       {
  161.          if(_reconnectAttempts != -1 && _currentAttempt >= _reconnectAttempts)
  162.          {
  163.             stopReconnectTimer();
  164.             _shouldBeConnected = false;
  165.             fault(buildConnectErrorMessage(),_connectMsg);
  166.             return;
  167.          }
  168.          if(Log.isDebug())
  169.          {
  170.             _log.debug("\'{0}\' {1} trying to reconnect.",id,_agentType);
  171.          }
  172.          _reconnectTimer.delay = _reconnectInterval;
  173.          ++_currentAttempt;
  174.          if(_connectMsg == null)
  175.          {
  176.             _connectMsg = buildConnectMessage();
  177.          }
  178.          internalSend(_connectMsg,false);
  179.       }
  180.       
  181.       private function buildConnectErrorMessage() : ErrorMessage
  182.       {
  183.          var _loc1_:ErrorMessage = new ErrorMessage();
  184.          _loc1_.faultCode = "Client.Error.Connect";
  185.          _loc1_.faultString = resourceManager.getString("messaging","producerConnectError");
  186.          _loc1_.faultDetail = resourceManager.getString("messaging","failedToConnect");
  187.          _loc1_.correlationId = _connectMsg.messageId;
  188.          return _loc1_;
  189.       }
  190.       
  191.       override public function acknowledge(param1:AcknowledgeMessage, param2:IMessage) : void
  192.       {
  193.          if(_disconnectBarrier)
  194.          {
  195.             return;
  196.          }
  197.          super.acknowledge(param1,param2);
  198.          if(param2 is CommandMessage && CommandMessage(param2).operation == CommandMessage.TRIGGER_CONNECT_OPERATION)
  199.          {
  200.             stopReconnectTimer();
  201.          }
  202.       }
  203.       
  204.       override public function fault(param1:ErrorMessage, param2:IMessage) : void
  205.       {
  206.          mx_internal::internalFault(param1,param2);
  207.       }
  208.       
  209.       override public function disconnect() : void
  210.       {
  211.          _shouldBeConnected = false;
  212.          stopReconnectTimer();
  213.          super.disconnect();
  214.       }
  215.       
  216.       mx_internal function internalFault(param1:ErrorMessage, param2:IMessage, param3:Boolean = true, param4:Boolean = false) : void
  217.       {
  218.          var _loc5_:ErrorMessage = null;
  219.          if(_disconnectBarrier && !param4)
  220.          {
  221.             return;
  222.          }
  223.          if(param2 is CommandMessage && CommandMessage(param2).operation == CommandMessage.TRIGGER_CONNECT_OPERATION)
  224.          {
  225.             if(_reconnectTimer == null)
  226.             {
  227.                if(_connectMsg != null && param1.correlationId == _connectMsg.messageId)
  228.                {
  229.                   _shouldBeConnected = false;
  230.                   _loc5_ = buildConnectErrorMessage();
  231.                   _loc5_.rootCause = param1.rootCause;
  232.                   super.fault(_loc5_,param2);
  233.                }
  234.                else
  235.                {
  236.                   super.fault(param1,param2);
  237.                }
  238.             }
  239.          }
  240.          else
  241.          {
  242.             super.fault(param1,param2);
  243.          }
  244.       }
  245.       
  246.       public function connect() : void
  247.       {
  248.          if(!connected)
  249.          {
  250.             _shouldBeConnected = true;
  251.             if(_connectMsg == null)
  252.             {
  253.                _connectMsg = buildConnectMessage();
  254.             }
  255.             internalSend(_connectMsg,false);
  256.          }
  257.       }
  258.       
  259.       override public function channelFaultHandler(param1:ChannelFaultEvent) : void
  260.       {
  261.          super.channelFaultHandler(param1);
  262.          if(_shouldBeConnected && !param1.rejected && !param1.channel.connected)
  263.          {
  264.             startReconnectTimer();
  265.          }
  266.       }
  267.       
  268.       private function buildConnectMessage() : CommandMessage
  269.       {
  270.          var _loc1_:CommandMessage = new CommandMessage();
  271.          _loc1_.operation = CommandMessage.TRIGGER_CONNECT_OPERATION;
  272.          _loc1_.clientId = clientId;
  273.          _loc1_.destination = destination;
  274.          return _loc1_;
  275.       }
  276.       
  277.       protected function startReconnectTimer() : void
  278.       {
  279.          if(_shouldBeConnected && _reconnectTimer == null)
  280.          {
  281.             if(_reconnectAttempts != 0 && _reconnectInterval > 0)
  282.             {
  283.                if(Log.isDebug())
  284.                {
  285.                   _log.debug("\'{0}\' {1} starting reconnect timer.",id,_agentType);
  286.                }
  287.                _reconnectTimer = new Timer(1);
  288.                _reconnectTimer.addEventListener(TimerEvent.TIMER,reconnect);
  289.                _reconnectTimer.start();
  290.                _currentAttempt = 0;
  291.             }
  292.          }
  293.       }
  294.       
  295.       public function set autoConnect(param1:Boolean) : void
  296.       {
  297.          var _loc2_:PropertyChangeEvent = null;
  298.          if(_autoConnect != param1)
  299.          {
  300.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"autoConnect",_autoConnect,param1);
  301.             _autoConnect = param1;
  302.             dispatchEvent(_loc2_);
  303.          }
  304.       }
  305.       
  306.       public function set reconnectAttempts(param1:int) : void
  307.       {
  308.          var _loc2_:PropertyChangeEvent = null;
  309.          if(_reconnectAttempts != param1)
  310.          {
  311.             if(param1 == 0)
  312.             {
  313.                stopReconnectTimer();
  314.             }
  315.             _loc2_ = PropertyChangeEvent.createUpdateEvent(this,"reconnectAttempts",_reconnectAttempts,param1);
  316.             _reconnectAttempts = param1;
  317.             dispatchEvent(_loc2_);
  318.          }
  319.       }
  320.       
  321.       [Bindable(event="propertyChange")]
  322.       public function get autoConnect() : Boolean
  323.       {
  324.          return _autoConnect;
  325.       }
  326.    }
  327. }
  328.  
  329.