home *** CD-ROM | disk | FTP | other *** search
/ 404 Jogos / CLJG.iso / Aventura / sinta.swf / scripts / mochi / MochiServices.as < prev   
Encoding:
Text File  |  2008-08-08  |  15.6 KB  |  537 lines
  1. package mochi
  2. {
  3.    import flash.display.*;
  4.    import flash.events.*;
  5.    import flash.net.*;
  6.    import flash.system.*;
  7.    import flash.utils.*;
  8.    
  9.    public class MochiServices
  10.    {
  11.       
  12.       private static var _container:Object;
  13.       
  14.       private static var _connected:Boolean = false;
  15.       
  16.       private static var _swfVersion:String;
  17.       
  18.       private static var _sendChannel:LocalConnection;
  19.       
  20.       private static var _rcvChannelName:String;
  21.       
  22.       private static var _gatewayURL:String = "http://www.mochiads.com/static/lib/services/services.swf";
  23.       
  24.       private static var _clip:MovieClip;
  25.       
  26.       private static var _loader:Loader;
  27.       
  28.       private static var _id:String;
  29.       
  30.       private static var _listenChannel:LocalConnection;
  31.       
  32.       private static var _timer:Timer;
  33.       
  34.       private static var _sendChannelName:String;
  35.       
  36.       private static var _startTime:Number;
  37.       
  38.       private static var _connecting:Boolean = false;
  39.       
  40.       public static var onError:Object;
  41.       
  42.       private static var _listenChannelName:String = "__mochiservices";
  43.       
  44.       private static var _rcvChannel:LocalConnection;
  45.        
  46.       
  47.       public function MochiServices()
  48.       {
  49.          super();
  50.       }
  51.       
  52.       public static function isNetworkAvailable() : Boolean
  53.       {
  54.          return Security.sandboxType != "localWithFile";
  55.       }
  56.       
  57.       public static function send(param1:String, param2:Object = null, param3:Object = null, param4:Object = null) : void
  58.       {
  59.          if(_connected)
  60.          {
  61.             _sendChannel.send(_sendChannelName,"onReceive",{
  62.                "methodName":param1,
  63.                "args":param2,
  64.                "callbackID":_clip._nextcallbackID
  65.             });
  66.          }
  67.          else
  68.          {
  69.             if(_clip == null || !_connecting)
  70.             {
  71.                onError("NotConnected");
  72.                handleError(param2,param3,param4);
  73.                flush(true);
  74.                return;
  75.             }
  76.             _clip._queue.push({
  77.                "methodName":param1,
  78.                "args":param2,
  79.                "callbackID":_clip._nextcallbackID
  80.             });
  81.          }
  82.          if(_clip != null)
  83.          {
  84.             if(_clip._callbacks != null && _clip._nextcallbackID != null)
  85.             {
  86.                _clip._callbacks[_clip._nextcallbackID] = {
  87.                   "callbackObject":param3,
  88.                   "callbackMethod":param4
  89.                };
  90.                ++_clip._nextcallbackID;
  91.             }
  92.          }
  93.       }
  94.       
  95.       public static function get connected() : Boolean
  96.       {
  97.          return _connected;
  98.       }
  99.       
  100.       private static function flush(param1:Boolean) : void
  101.       {
  102.          var _loc2_:Object = null;
  103.          var _loc3_:Object = null;
  104.          if(_clip != null)
  105.          {
  106.             if(_clip._queue != null)
  107.             {
  108.                while(_clip._queue.length > 0)
  109.                {
  110.                   _loc2_ = _clip._queue.shift();
  111.                   _loc3_ = null;
  112.                   if(_loc2_ != null)
  113.                   {
  114.                      if(_loc2_.callbackID != null)
  115.                      {
  116.                         _loc3_ = _clip._callbacks[_loc2_.callbackID];
  117.                      }
  118.                      delete _clip._callbacks[_loc2_.callbackID];
  119.                      if(param1 && _loc3_ != null)
  120.                      {
  121.                         handleError(_loc2_.args,_loc3_.callbackObject,_loc3_.callbackMethod);
  122.                      }
  123.                   }
  124.                }
  125.             }
  126.          }
  127.       }
  128.       
  129.       private static function init(param1:String, param2:Object) : void
  130.       {
  131.          _id = param1;
  132.          if(param2 != null)
  133.          {
  134.             _container = param2;
  135.             loadCommunicator(param1,_container);
  136.          }
  137.       }
  138.       
  139.       public static function get childClip() : Object
  140.       {
  141.          return _clip;
  142.       }
  143.       
  144.       public static function get id() : String
  145.       {
  146.          return _id;
  147.       }
  148.       
  149.       public static function stayOnTop() : void
  150.       {
  151.          _container.addEventListener(Event.ENTER_FRAME,MochiServices.bringToTop,false,0,true);
  152.          if(_clip != null)
  153.          {
  154.             _clip.visible = true;
  155.          }
  156.       }
  157.       
  158.       public static function getVersion() : String
  159.       {
  160.          return "1.31";
  161.       }
  162.       
  163.       public static function disconnect() : void
  164.       {
  165.          if(Boolean(_connected) || Boolean(_connecting))
  166.          {
  167.             if(_clip != null)
  168.             {
  169.                if(_clip.parent != null)
  170.                {
  171.                   if(_clip.parent is Sprite)
  172.                   {
  173.                      Sprite(_clip.parent).removeChild(_clip);
  174.                      _clip = null;
  175.                   }
  176.                }
  177.             }
  178.             _connecting = _connected = false;
  179.             flush(true);
  180.             try
  181.             {
  182.                _listenChannel.close();
  183.                _rcvChannel.close();
  184.             }
  185.             catch(error:Error)
  186.             {
  187.             }
  188.          }
  189.          if(_timer != null)
  190.          {
  191.             try
  192.             {
  193.                _timer.stop();
  194.             }
  195.             catch(error:Error)
  196.             {
  197.             }
  198.          }
  199.       }
  200.       
  201.       public static function allowDomains(param1:String) : String
  202.       {
  203.          var _loc2_:String = null;
  204.          Security.allowDomain("*");
  205.          Security.allowInsecureDomain("*");
  206.          if(param1.indexOf("http://") != -1)
  207.          {
  208.             _loc2_ = String(param1.split("/")[2].split(":")[0]);
  209.             Security.allowDomain(_loc2_);
  210.             Security.allowInsecureDomain(_loc2_);
  211.          }
  212.          return _loc2_;
  213.       }
  214.       
  215.       public static function doClose() : void
  216.       {
  217.          _container.removeEventListener(Event.ENTER_FRAME,MochiServices.bringToTop);
  218.          if(_clip.parent != null)
  219.          {
  220.             Sprite(_clip.parent).removeChild(_clip);
  221.          }
  222.       }
  223.       
  224.       public static function setContainer(param1:Object = null, param2:Boolean = true) : void
  225.       {
  226.          if(param1 != null)
  227.          {
  228.             if(param1 is Sprite)
  229.             {
  230.                _container = param1;
  231.             }
  232.          }
  233.          if(param2)
  234.          {
  235.             if(_container is Sprite)
  236.             {
  237.                Sprite(_container).addChild(_clip);
  238.             }
  239.          }
  240.       }
  241.       
  242.       private static function onStatus(param1:StatusEvent) : void
  243.       {
  244.          switch(param1.level)
  245.          {
  246.             case "error":
  247.                _connected = false;
  248.                _listenChannel.connect(_listenChannelName);
  249.          }
  250.       }
  251.       
  252.       private static function initComChannels() : void
  253.       {
  254.          if(!_connected)
  255.          {
  256.             _sendChannel.addEventListener(StatusEvent.STATUS,MochiServices.onStatus);
  257.             _sendChannel.send(_sendChannelName,"onReceive",{"methodName":"handshakeDone"});
  258.             _sendChannel.send(_sendChannelName,"onReceive",{
  259.                "methodName":"registerGame",
  260.                "id":_id,
  261.                "clip":_container,
  262.                "version":getVersion()
  263.             });
  264.             _rcvChannel.addEventListener(StatusEvent.STATUS,MochiServices.onStatus);
  265.             _clip.onReceive = function(param1:Object):void
  266.             {
  267.                var cb:String = null;
  268.                var cblst:Object = null;
  269.                var method:* = undefined;
  270.                var methodName:String = null;
  271.                var obj:Object = null;
  272.                var pkg:Object = param1;
  273.                cb = String(pkg.callbackID);
  274.                cblst = this.client._callbacks[cb];
  275.                if(!cblst)
  276.                {
  277.                   return;
  278.                }
  279.                method = cblst.callbackMethod;
  280.                methodName = "";
  281.                obj = cblst.callbackObject;
  282.                if(Boolean(obj) && typeof method == "string")
  283.                {
  284.                   methodName = method;
  285.                   if(obj[method] != null)
  286.                   {
  287.                      method = obj[method];
  288.                   }
  289.                }
  290.                if(method != undefined)
  291.                {
  292.                   try
  293.                   {
  294.                      method.apply(obj,pkg.args);
  295.                   }
  296.                   catch(error:Error)
  297.                   {
  298.                   }
  299.                }
  300.                else if(obj != null)
  301.                {
  302.                   try
  303.                   {
  304.                      obj(pkg.args);
  305.                   }
  306.                   catch(error:Error)
  307.                   {
  308.                   }
  309.                }
  310.                delete this.client._callbacks[cb];
  311.             };
  312.             _clip.onError = function():void
  313.             {
  314.                MochiServices.onError("IOError");
  315.             };
  316.             _rcvChannel.connect(_rcvChannelName);
  317.             _connecting = false;
  318.             _connected = true;
  319.             _listenChannel.close();
  320.             while(_clip._queue.length > 0)
  321.             {
  322.                _sendChannel.send(_sendChannelName,"onReceive",_clip._queue.shift());
  323.             }
  324.          }
  325.       }
  326.       
  327.       private static function listen() : void
  328.       {
  329.          _listenChannel = new LocalConnection();
  330.          _listenChannel.client = _clip;
  331.          _clip.handshake = function(param1:Object):void
  332.          {
  333.             MochiServices.comChannelName = param1.newChannel;
  334.          };
  335.          _listenChannel.allowDomain("*","localhost");
  336.          _listenChannel.allowInsecureDomain("*","localhost");
  337.          _listenChannel.connect(_listenChannelName);
  338.       }
  339.       
  340.       private static function handleError(param1:Object, param2:Object, param3:Object) : void
  341.       {
  342.          var args:Object = param1;
  343.          var callbackObject:Object = param2;
  344.          var callbackMethod:Object = param3;
  345.          if(args != null)
  346.          {
  347.             if(args.onError != null)
  348.             {
  349.                args.onError.apply(null,["NotConnected"]);
  350.             }
  351.          }
  352.          if(callbackMethod != null)
  353.          {
  354.             args = {};
  355.             args.error = true;
  356.             args.errorCode = "NotConnected";
  357.             if(callbackObject != null && callbackMethod is String)
  358.             {
  359.                try
  360.                {
  361.                   callbackObject[callbackMethod](args);
  362.                }
  363.                catch(error:Error)
  364.                {
  365.                }
  366.             }
  367.             else if(callbackMethod != null)
  368.             {
  369.                try
  370.                {
  371.                   callbackMethod.apply(args);
  372.                }
  373.                catch(error:Error)
  374.                {
  375.                }
  376.             }
  377.          }
  378.       }
  379.       
  380.       public static function get clip() : Object
  381.       {
  382.          return _container;
  383.       }
  384.       
  385.       public static function set comChannelName(param1:String) : void
  386.       {
  387.          if(param1 != null)
  388.          {
  389.             if(param1.length > 3)
  390.             {
  391.                _sendChannelName = param1 + "_fromgame";
  392.                _rcvChannelName = param1;
  393.                initComChannels();
  394.             }
  395.          }
  396.       }
  397.       
  398.       private static function loadCommunicator(param1:String, param2:Object) : MovieClip
  399.       {
  400.          var clipname:String = null;
  401.          var f:Function = null;
  402.          var req:URLRequest = null;
  403.          var id:String = param1;
  404.          var clip:Object = param2;
  405.          clipname = "_mochiservices_com_" + id;
  406.          if(_clip != null)
  407.          {
  408.             return _clip;
  409.          }
  410.          if(!MochiServices.isNetworkAvailable())
  411.          {
  412.             return null;
  413.          }
  414.          MochiServices.allowDomains(_gatewayURL);
  415.          _clip = createEmptyMovieClip(clip,clipname,10336,false);
  416.          _loader = new Loader();
  417.          _timer = new Timer(1000,0);
  418.          _startTime = getTimer();
  419.          _timer.addEventListener(TimerEvent.TIMER,connectWait);
  420.          _timer.start();
  421.          f = function(param1:Object):void
  422.          {
  423.             _clip._mochiad_ctr_failed = true;
  424.             MochiServices.disconnect();
  425.             MochiServices.onError("IOError");
  426.          };
  427.          _loader.contentLoaderInfo.addEventListener(IOErrorEvent.IO_ERROR,f);
  428.          req = new URLRequest(_gatewayURL);
  429.          _loader.load(req);
  430.          _clip.addChild(_loader);
  431.          _clip._mochiservices_com = _loader;
  432.          _sendChannel = new LocalConnection();
  433.          _clip._queue = [];
  434.          _rcvChannel = new LocalConnection();
  435.          _rcvChannel.allowDomain("*","localhost");
  436.          _rcvChannel.allowInsecureDomain("*","localhost");
  437.          _rcvChannel.client = _clip;
  438.          _clip._nextcallbackID = 0;
  439.          _clip._callbacks = {};
  440.          listen();
  441.          return _clip;
  442.       }
  443.       
  444.       public static function bringToTop(param1:Event) : void
  445.       {
  446.          var e:Event = param1;
  447.          if(MochiServices.clip != null)
  448.          {
  449.             if(MochiServices.childClip != null)
  450.             {
  451.                try
  452.                {
  453.                   if(MochiServices.clip.numChildren > 1)
  454.                   {
  455.                      MochiServices.clip.setChildIndex(MochiServices.childClip,MochiServices.clip.numChildren - 1);
  456.                   }
  457.                }
  458.                catch(errorObject:Error)
  459.                {
  460.                   _container.removeEventListener(Event.ENTER_FRAME,MochiServices.bringToTop);
  461.                }
  462.             }
  463.          }
  464.       }
  465.       
  466.       public static function connect(param1:String, param2:Object, param3:Object = null) : void
  467.       {
  468.          var id:String = param1;
  469.          var clip:Object = param2;
  470.          var onError:Object = param3;
  471.          if(clip is DisplayObject)
  472.          {
  473.             if(!_connected && _clip == null)
  474.             {
  475.                _connecting = true;
  476.                init(id,clip);
  477.             }
  478.          }
  479.          if(onError != null)
  480.          {
  481.             MochiServices.onError = onError;
  482.          }
  483.          else if(MochiServices.onError == null)
  484.          {
  485.             MochiServices.onError = function(param1:String):void
  486.             {
  487.             };
  488.          }
  489.       }
  490.       
  491.       public static function createEmptyMovieClip(param1:Object, param2:String, param3:Number, param4:Boolean = true) : MovieClip
  492.       {
  493.          var mc:MovieClip = null;
  494.          var parent:Object = param1;
  495.          var name:String = param2;
  496.          var depth:Number = param3;
  497.          var doAdd:Boolean = param4;
  498.          mc = new MovieClip();
  499.          if(doAdd)
  500.          {
  501.             if(false && Boolean(depth))
  502.             {
  503.                parent.addChildAt(mc,depth);
  504.             }
  505.             else
  506.             {
  507.                parent.addChild(mc);
  508.             }
  509.          }
  510.          try
  511.          {
  512.             parent[name] = mc;
  513.          }
  514.          catch(e:Error)
  515.          {
  516.             throw new Error("MochiServices requires a clip that is an instance of a dynamic class.  If your class extends Sprite or MovieClip, you must make it dynamic.");
  517.          }
  518.          mc["_name"] = name;
  519.          return mc;
  520.       }
  521.       
  522.       public static function connectWait(param1:TimerEvent) : void
  523.       {
  524.          if(getTimer() - _startTime > 10000)
  525.          {
  526.             if(!_connected)
  527.             {
  528.                _clip._mochiad_ctr_failed = true;
  529.                MochiServices.disconnect();
  530.                MochiServices.onError("IOError");
  531.             }
  532.             _timer.stop();
  533.          }
  534.       }
  535.    }
  536. }
  537.