home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Darbas / kidoz_v1.air / kidoz.swf / scripts / mx / messaging / channels / PollingChannel.as < prev   
Encoding:
Text File  |  2009-05-06  |  15.2 KB  |  473 lines
  1. package mx.messaging.channels
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.TimerEvent;
  5.    import flash.utils.Timer;
  6.    import mx.core.mx_internal;
  7.    import mx.logging.Log;
  8.    import mx.messaging.Channel;
  9.    import mx.messaging.ConsumerMessageDispatcher;
  10.    import mx.messaging.MessageAgent;
  11.    import mx.messaging.MessageResponder;
  12.    import mx.messaging.events.ChannelFaultEvent;
  13.    import mx.messaging.messages.CommandMessage;
  14.    import mx.messaging.messages.IMessage;
  15.    import mx.resources.IResourceManager;
  16.    import mx.resources.ResourceManager;
  17.    
  18.    use namespace mx_internal;
  19.    
  20.    public class PollingChannel extends Channel
  21.    {
  22.       private static const DEFAULT_POLLING_INTERVAL:int = 3000;
  23.       
  24.       mx_internal var _timer:Timer;
  25.       
  26.       private var _pollingEnabled:Boolean;
  27.       
  28.       private var _piggybackingEnabled:Boolean;
  29.       
  30.       mx_internal var _pollingInterval:int;
  31.       
  32.       mx_internal var pollOutstanding:Boolean;
  33.       
  34.       private var _pollingRef:int = -1;
  35.       
  36.       mx_internal var _shouldPoll:Boolean;
  37.       
  38.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  39.       
  40.       public function PollingChannel(param1:String = null, param2:String = null)
  41.       {
  42.          super(param1,param2);
  43.          _pollingEnabled = true;
  44.          mx_internal::_shouldPoll = false;
  45.          if(timerRequired())
  46.          {
  47.             mx_internal::_pollingInterval = DEFAULT_POLLING_INTERVAL;
  48.             mx_internal::_timer = new Timer(mx_internal::_pollingInterval,1);
  49.             mx_internal::_timer.addEventListener(TimerEvent.TIMER,internalPoll);
  50.          }
  51.       }
  52.       
  53.       public function enablePolling() : void
  54.       {
  55.          ++_pollingRef;
  56.          if(_pollingRef == 0)
  57.          {
  58.             startPolling();
  59.          }
  60.       }
  61.       
  62.       protected function timerRequired() : Boolean
  63.       {
  64.          return true;
  65.       }
  66.       
  67.       override protected function connectFailed(param1:ChannelFaultEvent) : void
  68.       {
  69.          mx_internal::stopPolling();
  70.          super.connectFailed(param1);
  71.       }
  72.       
  73.       override public function send(param1:MessageAgent, param2:IMessage) : void
  74.       {
  75.          var consumerDispatcher:ConsumerMessageDispatcher = null;
  76.          var msg:CommandMessage = null;
  77.          var agent:MessageAgent = param1;
  78.          var message:IMessage = param2;
  79.          var piggyback:Boolean = false;
  80.          if(!mx_internal::pollOutstanding && _piggybackingEnabled && !(message is CommandMessage))
  81.          {
  82.             if(mx_internal::_shouldPoll)
  83.             {
  84.                piggyback = true;
  85.             }
  86.             else
  87.             {
  88.                consumerDispatcher = ConsumerMessageDispatcher.getInstance();
  89.                if(consumerDispatcher.isChannelUsedForSubscriptions(this))
  90.                {
  91.                   piggyback = true;
  92.                }
  93.             }
  94.          }
  95.          if(piggyback)
  96.          {
  97.             internalPoll();
  98.          }
  99.          super.send(agent,message);
  100.          if(piggyback)
  101.          {
  102.             msg = new CommandMessage();
  103.             msg.operation = CommandMessage.POLL_OPERATION;
  104.             if(Log.isDebug())
  105.             {
  106.                _log.debug("\'{0}\' channel sending poll message\n{1}\n",id,msg.toString());
  107.             }
  108.             try
  109.             {
  110.                internalSend(new PollCommandMessageResponder(null,msg,this,_log));
  111.             }
  112.             catch(e:Error)
  113.             {
  114.                mx_internal::stopPolling();
  115.                throw e;
  116.             }
  117.          }
  118.       }
  119.       
  120.       protected function getPollSyncMessageResponder(param1:MessageAgent, param2:CommandMessage) : MessageResponder
  121.       {
  122.          return null;
  123.       }
  124.       
  125.       protected function applyPollingSettings(param1:XML) : void
  126.       {
  127.          var _loc2_:XML = null;
  128.          if(param1.properties.length())
  129.          {
  130.             _loc2_ = param1.properties[0];
  131.             if(_loc2_["polling-enabled"].length())
  132.             {
  133.                internalPollingEnabled = _loc2_["polling-enabled"].toString() == "true";
  134.             }
  135.             if(_loc2_["polling-interval-millis"].length())
  136.             {
  137.                mx_internal::internalPollingInterval = parseInt(_loc2_["polling-interval-millis"].toString());
  138.             }
  139.             else if(_loc2_["polling-interval-seconds"].length())
  140.             {
  141.                mx_internal::internalPollingInterval = parseInt(_loc2_["polling-interval-seconds"].toString()) * 1000;
  142.             }
  143.             if(_loc2_["piggybacking-enabled"].length())
  144.             {
  145.                internalPiggybackingEnabled = _loc2_["piggybacking-enabled"].toString() == "true";
  146.             }
  147.             if(_loc2_["login-after-disconnect"].length())
  148.             {
  149.                _loginAfterDisconnect = _loc2_["login-after-disconnect"].toString() == "true";
  150.             }
  151.          }
  152.       }
  153.       
  154.       mx_internal function set internalPollingInterval(param1:Number) : void
  155.       {
  156.          var _loc2_:String = null;
  157.          if(param1 == 0)
  158.          {
  159.             mx_internal::_pollingInterval = param1;
  160.             if(mx_internal::_timer != null)
  161.             {
  162.                mx_internal::_timer.stop();
  163.             }
  164.             if(mx_internal::_shouldPoll)
  165.             {
  166.                startPolling();
  167.             }
  168.          }
  169.          else
  170.          {
  171.             if(param1 <= 0)
  172.             {
  173.                _loc2_ = resourceManager.getString("messaging","pollingIntervalNonPositive");
  174.                throw new ArgumentError(_loc2_);
  175.             }
  176.             if(mx_internal::_timer != null)
  177.             {
  178.                mx_internal::_timer.delay = mx_internal::_pollingInterval = param1;
  179.                if(!mx_internal::timerRunning && mx_internal::_shouldPoll)
  180.                {
  181.                   startPolling();
  182.                }
  183.             }
  184.          }
  185.       }
  186.       
  187.       public function poll() : void
  188.       {
  189.          internalPoll();
  190.       }
  191.       
  192.       protected function set internalPiggybackingEnabled(param1:Boolean) : void
  193.       {
  194.          _piggybackingEnabled = param1;
  195.       }
  196.       
  197.       protected function get internalPollingEnabled() : Boolean
  198.       {
  199.          return _pollingEnabled;
  200.       }
  201.       
  202.       mx_internal function pollFailed(param1:Boolean = false) : void
  203.       {
  204.          internalDisconnect(param1);
  205.       }
  206.       
  207.       mx_internal function stopPolling() : void
  208.       {
  209.          if(Log.isInfo())
  210.          {
  211.             _log.info("\'{0}\' channel polling stopped.",id);
  212.          }
  213.          if(mx_internal::_timer != null)
  214.          {
  215.             mx_internal::_timer.stop();
  216.          }
  217.          _pollingRef = -1;
  218.          mx_internal::_shouldPoll = false;
  219.          mx_internal::pollOutstanding = false;
  220.       }
  221.       
  222.       protected function internalPoll(param1:Event = null) : void
  223.       {
  224.          var msg:CommandMessage = null;
  225.          var event:Event = param1;
  226.          if(!mx_internal::pollOutstanding)
  227.          {
  228.             if(Log.isInfo())
  229.             {
  230.                _log.info("\'{0}\' channel requesting queued messages.",id);
  231.             }
  232.             if(mx_internal::timerRunning)
  233.             {
  234.                mx_internal::_timer.stop();
  235.             }
  236.             msg = new CommandMessage();
  237.             msg.operation = CommandMessage.POLL_OPERATION;
  238.             if(Log.isDebug())
  239.             {
  240.                _log.debug("\'{0}\' channel sending poll message\n{1}\n",id,msg.toString());
  241.             }
  242.             try
  243.             {
  244.                internalSend(new PollCommandMessageResponder(null,msg,this,_log));
  245.                mx_internal::pollOutstanding = true;
  246.             }
  247.             catch(e:Error)
  248.             {
  249.                mx_internal::stopPolling();
  250.                throw e;
  251.             }
  252.          }
  253.          else if(Log.isInfo())
  254.          {
  255.             _log.info("\'{0}\' channel waiting for poll response.",id);
  256.          }
  257.       }
  258.       
  259.       protected function getDefaultMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  260.       {
  261.          return super.getMessageResponder(param1,param2);
  262.       }
  263.       
  264.       mx_internal function get internalPollingInterval() : Number
  265.       {
  266.          return mx_internal::_timer == null ? 0 : mx_internal::_pollingInterval;
  267.       }
  268.       
  269.       protected function startPolling() : void
  270.       {
  271.          if(_pollingEnabled)
  272.          {
  273.             if(Log.isInfo())
  274.             {
  275.                _log.info("\'{0}\' channel polling started.",id);
  276.             }
  277.             mx_internal::_shouldPoll = true;
  278.             poll();
  279.          }
  280.       }
  281.       
  282.       protected function get internalPiggybackingEnabled() : Boolean
  283.       {
  284.          return _piggybackingEnabled;
  285.       }
  286.       
  287.       override mx_internal function get realtime() : Boolean
  288.       {
  289.          return _pollingEnabled;
  290.       }
  291.       
  292.       final override protected function getMessageResponder(param1:MessageAgent, param2:IMessage) : MessageResponder
  293.       {
  294.          var _loc4_:CommandMessage = null;
  295.          var _loc3_:MessageResponder = null;
  296.          if(param2 is CommandMessage)
  297.          {
  298.             _loc4_ = CommandMessage(param2);
  299.             if(_loc4_.operation == CommandMessage.SUBSCRIBE_OPERATION || _loc4_.operation == CommandMessage.UNSUBSCRIBE_OPERATION)
  300.             {
  301.                _loc3_ = getPollSyncMessageResponder(param1,_loc4_);
  302.             }
  303.             else if(_loc4_.operation == CommandMessage.POLL_OPERATION)
  304.             {
  305.                _loc3_ = new PollCommandMessageResponder(param1,param2,this,_log);
  306.             }
  307.          }
  308.          return _loc3_ == null ? getDefaultMessageResponder(param1,param2) : _loc3_;
  309.       }
  310.       
  311.       override protected function internalDisconnect(param1:Boolean = false) : void
  312.       {
  313.          mx_internal::stopPolling();
  314.          super.internalDisconnect(param1);
  315.       }
  316.       
  317.       mx_internal function get timerRunning() : Boolean
  318.       {
  319.          return mx_internal::_timer != null && mx_internal::_timer.running;
  320.       }
  321.       
  322.       public function disablePolling() : void
  323.       {
  324.          --_pollingRef;
  325.          if(_pollingRef < 0)
  326.          {
  327.             mx_internal::stopPolling();
  328.          }
  329.       }
  330.       
  331.       protected function set internalPollingEnabled(param1:Boolean) : void
  332.       {
  333.          _pollingEnabled = param1;
  334.          if(!param1 && (mx_internal::timerRunning || !mx_internal::timerRunning && mx_internal::_pollingInterval == 0))
  335.          {
  336.             mx_internal::stopPolling();
  337.          }
  338.          else if(param1 && mx_internal::_shouldPoll && !mx_internal::timerRunning)
  339.          {
  340.             startPolling();
  341.          }
  342.       }
  343.    }
  344. }
  345.  
  346. import mx.core.mx_internal;
  347. import mx.logging.ILogger;
  348. import mx.logging.Log;
  349. import mx.messaging.MessageAgent;
  350. import mx.messaging.MessageResponder;
  351. import mx.messaging.events.ChannelFaultEvent;
  352. import mx.messaging.events.MessageEvent;
  353. import mx.messaging.messages.AcknowledgeMessage;
  354. import mx.messaging.messages.CommandMessage;
  355. import mx.messaging.messages.ErrorMessage;
  356. import mx.messaging.messages.IMessage;
  357. import mx.messaging.messages.MessagePerformanceUtils;
  358. import mx.resources.IResourceManager;
  359. import mx.resources.ResourceManager;
  360.  
  361. use namespace mx_internal;
  362.  
  363. class PollCommandMessageResponder extends MessageResponder
  364. {
  365.    private var _log:ILogger;
  366.    
  367.    private var resourceManager:IResourceManager = ResourceManager.getInstance();
  368.    
  369.    public function PollCommandMessageResponder(param1:MessageAgent, param2:IMessage, param3:PollingChannel, param4:ILogger)
  370.    {
  371.       super(param1,param2,param3);
  372.       _log = param4;
  373.    }
  374.    
  375.    override protected function statusHandler(param1:IMessage) : void
  376.    {
  377.       var _loc2_:PollingChannel = PollingChannel(channel);
  378.       _loc2_.mx_internal::stopPolling();
  379.       var _loc3_:ErrorMessage = param1 as ErrorMessage;
  380.       var _loc4_:String = _loc3_ != null ? _loc3_.faultDetail : "";
  381.       var _loc5_:ChannelFaultEvent = ChannelFaultEvent.createEvent(_loc2_,false,"Channel.Polling.Error","error",_loc4_);
  382.       _loc5_.rootCause = param1;
  383.       _loc2_.dispatchEvent(_loc5_);
  384.       if(_loc3_ != null && _loc3_.faultCode == "Server.PollNotSupported")
  385.       {
  386.          _loc2_.mx_internal::pollFailed(true);
  387.       }
  388.       else
  389.       {
  390.          _loc2_.mx_internal::pollFailed(false);
  391.       }
  392.    }
  393.    
  394.    override protected function resultHandler(param1:IMessage) : void
  395.    {
  396.       var pollingChannel:PollingChannel;
  397.       var messageList:Array = null;
  398.       var message:IMessage = null;
  399.       var mpiutil:MessagePerformanceUtils = null;
  400.       var errMsg:ErrorMessage = null;
  401.       var adaptivePollWait:int = 0;
  402.       var msg:IMessage = param1;
  403.       PollingChannel(channel).mx_internal::pollOutstanding = false;
  404.       if(msg is CommandMessage)
  405.       {
  406.          if(msg.headers[CommandMessage.NO_OP_POLL_HEADER] == true)
  407.          {
  408.             return;
  409.          }
  410.          if(msg.body != null)
  411.          {
  412.             messageList = msg.body as Array;
  413.             var _loc3_:int = 0;
  414.             var _loc4_:* = messageList;
  415.             for(; ┬º┬ºhasnext(_loc4_,_loc3_); channel.dispatchEvent(MessageEvent.createEvent(MessageEvent.MESSAGE,message)))
  416.             {
  417.                message = ┬º┬ºnextvalue(_loc3_,_loc4_);
  418.                if(Log.isDebug())
  419.                {
  420.                   _log.debug("\'{0}\' channel got message\n{1}\n",channel.id,message.toString());
  421.                   if(channel.mpiEnabled)
  422.                   {
  423.                      try
  424.                      {
  425.                         mpiutil = new MessagePerformanceUtils(message);
  426.                         _log.debug(mpiutil.prettyPrint());
  427.                      }
  428.                      catch(e:Error)
  429.                      {
  430.                         _log.debug("Could not get message performance information for: " + msg.toString());
  431.                      }
  432.                      continue;
  433.                   }
  434.                }
  435.             }
  436.          }
  437.       }
  438.       else if(!(msg is AcknowledgeMessage))
  439.       {
  440.          errMsg = new ErrorMessage();
  441.          errMsg.faultDetail = resourceManager.getString("messaging","receivedNull");
  442.          status(errMsg);
  443.          return;
  444.       }
  445.       pollingChannel = PollingChannel(channel);
  446.       if(pollingChannel.connected && pollingChannel.mx_internal::_shouldPoll)
  447.       {
  448.          adaptivePollWait = 0;
  449.          if(msg.headers[CommandMessage.POLL_WAIT_HEADER] != null)
  450.          {
  451.             adaptivePollWait = int(msg.headers[CommandMessage.POLL_WAIT_HEADER]);
  452.          }
  453.          if(adaptivePollWait == 0)
  454.          {
  455.             if(pollingChannel.mx_internal::internalPollingInterval == 0)
  456.             {
  457.                pollingChannel.poll();
  458.             }
  459.             else if(!pollingChannel.mx_internal::timerRunning)
  460.             {
  461.                pollingChannel.mx_internal::_timer.delay = pollingChannel.mx_internal::_pollingInterval;
  462.                pollingChannel.mx_internal::_timer.start();
  463.             }
  464.          }
  465.          else
  466.          {
  467.             pollingChannel.mx_internal::_timer.delay = adaptivePollWait;
  468.             pollingChannel.mx_internal::_timer.start();
  469.          }
  470.       }
  471.    }
  472. }
  473.