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