Computer Active 2010 August/CA08.iso/Darbas/kidoz_v1.air/kidoz.swf/scripts/air/net/ServiceMonitor.as

Text File | 2009-05-06 | 5.5 KB | 202 lines

package air.net
{
   import flash.desktop.NativeApplication;
   import flash.events.Event;
   import flash.events.EventDispatcher;
   import flash.events.StatusEvent;
   import flash.events.TimerEvent;
   import flash.utils.Timer;

   public dynamic class ServiceMonitor extends EventDispatcher
   {
      private static const kInvalidParamError:uint = 2004;

      private static const kDelayRangeError:uint = 2066;

      private var _running:Boolean = false;

      private var _delay:Number = 0;

      private var _timer:Timer = new Timer(_delay);

      private var _available:Boolean = false;

      private var _specializer:Object = null;

      private var _notifyRegardless:Boolean = false;

      private var _statusTime:Date = new Date();

      public function ServiceMonitor()
      {
         super();
         _timer.addEventListener(TimerEvent.TIMER,onTimer);
      }

      private static function makeForwarder(param1:String) : Function
      {
         var name:String = param1;
         return function forwarder(... rest):*
         {
            return this.__monitor__[name].apply(this.__monitor__,rest);
         };
      }

      public static function makeJavascriptSubclass(param1:Object) : void
      {
         var name:String = null;
         var constructorFunction:Object = param1;
         var proto:Object = constructorFunction.prototype;
         var names:Array = ["start","stop","willTrigger","removeEventListener","addEventListener","dispatchEvent","hasEventListener"];
         for each(name in names)
         {
            proto[name] = makeForwarder(name);
         }
         proto.setAvailable = function(param1:Boolean):void
         {
            this.__monitor__.available = param1;
         };
         proto.getAvailable = function():Boolean
         {
            return this.__monitor__.available;
         };
         proto.toString = makeForwarder("_toString");
         proto.initServiceMonitor = function():*
         {
            return _initServiceMonitor(this);
         };
      }

      private static function _initServiceMonitor(param1:Object) : ServiceMonitor
      {
         var _loc2_:ServiceMonitor = new ServiceMonitor();
         param1.__monitor__ = _loc2_;
         _loc2_._specializer = param1;
         return _loc2_;
      }

      public function stop() : void
      {
         if(!_running)
         {
            return;
         }
         _running = false;
         _timer.stop();
         NativeApplication.nativeApplication.removeEventListener(Event.NETWORK_CHANGE,onNetworkChange);
      }

      public function set pollInterval(param1:Number) : void
      {
         if(param1 < 0 || !isFinite(param1))
         {
            Error.throwError(RangeError,kDelayRangeError);
         }
         _delay = param1;
         _timer.stop();
         if(_delay > 0)
         {
            _timer.delay = _delay;
            if(_running)
            {
               _timer.start();
            }
         }
      }

      public function get available() : Boolean
      {
         return _available;
      }

      private function _toString() : String
      {
         return "[ServiceMonitor available=\"" + available + "\"]";
      }

      public function get lastStatusUpdate() : Date
      {
         return new Date(_statusTime.time);
      }

      public function set available(param1:Boolean) : void
      {
         var _loc3_:String = null;
         var _loc4_:String = null;
         var _loc2_:Boolean = _available;
         _available = param1;
         _statusTime = new Date();
         if(_loc2_ != _available || _notifyRegardless)
         {
            _loc3_ = _available ? "Service.available" : "Service.unavailable";
            _loc4_ = "status";
            dispatchEvent(new StatusEvent(StatusEvent.STATUS,false,false,_loc3_,_loc4_));
         }
         _notifyRegardless = false;
      }

      protected function checkStatus() : void
      {
         if(Boolean(_specializer) && Boolean(_specializer.checkStatus))
         {
            _specializer.checkStatus();
         }
      }

      private function onNetworkChange(param1:Event) : void
      {
         if(!_running)
         {
            return;
         }
         if(_delay > 0)
         {
            _timer.stop();
            _timer.start();
         }
         checkStatus();
      }

      public function start() : void
      {
         if(_running)
         {
            return;
         }
         _running = true;
         _notifyRegardless = true;
         if(_delay > 0)
         {
            _timer.start();
         }
         NativeApplication.nativeApplication.addEventListener(Event.NETWORK_CHANGE,onNetworkChange,false,0,true);
         checkStatus();
      }

      public function get pollInterval() : Number
      {
         return _delay;
      }

      private function onTimer(param1:TimerEvent) : void
      {
         checkStatus();
      }

      override public function toString() : String
      {
         if(Boolean(_specializer) && Boolean(_specializer.toString))
         {
            return _specializer.toString();
         }
         return _toString();
      }

      public function get running() : Boolean
      {
         return _running;
      }
   }
}