home *** CD-ROM | disk | FTP | other *** search
/ Computer Active 2010 August / CA08.iso / Multimedija / shufflr.air / ShufflrClient.swf / scripts / mx / controls / videoClasses / NCManager.as < prev    next >
Encoding:
Text File  |  2010-06-23  |  21.5 KB  |  720 lines
  1. package mx.controls.videoClasses
  2. {
  3.    import flash.events.Event;
  4.    import flash.events.NetStatusEvent;
  5.    import flash.events.TimerEvent;
  6.    import flash.net.NetConnection;
  7.    import flash.net.ObjectEncoding;
  8.    import flash.net.Responder;
  9.    import flash.utils.Timer;
  10.    import mx.core.mx_internal;
  11.    import mx.resources.IResourceManager;
  12.    import mx.resources.ResourceManager;
  13.    
  14.    use namespace mx_internal;
  15.    
  16.    public class NCManager implements INCManager
  17.    {
  18.       mx_internal static const VERSION:String = "3.5.0.12683";
  19.       
  20.       public static const DEFAULT_TIMEOUT:Number = 60000;
  21.       
  22.       private static const DEFAULT_NC_TIMEOUT:uint = 1500;
  23.       
  24.       private static var RTMP_CONN:Array = [{
  25.          "protocol":"rtmp:/",
  26.          "port":"1935"
  27.       },{
  28.          "protocol":"rtmp:/",
  29.          "port":"443"
  30.       },{
  31.          "protocol":"rtmpt:/",
  32.          "port":"80"
  33.       },{
  34.          "protocol":"rtmps:/",
  35.          "port":"443"
  36.       }];
  37.       
  38.       private var connectionTimer:Timer;
  39.       
  40.       private var _timeout:uint;
  41.       
  42.       private var portNumber:String;
  43.       
  44.       private var _bitrate:Number;
  45.       
  46.       private var contentPath:String;
  47.       
  48.       private var appName:String;
  49.       
  50.       private var _netConnection:NetConnection;
  51.       
  52.       private var _streamLength:Number;
  53.       
  54.       private var _streamWidth:Number;
  55.       
  56.       private var serverName:String;
  57.       
  58.       private var tryNCTimer:Timer;
  59.       
  60.       private var ncURI:String;
  61.       
  62.       public var payload:uint;
  63.       
  64.       private var connTypeCounter:uint;
  65.       
  66.       private var protocol:String;
  67.       
  68.       private var _streamHeight:Number;
  69.       
  70.       private var wrappedURL:String;
  71.       
  72.       private var _isRTMP:int = -1;
  73.       
  74.       public var tryNC:Array;
  75.       
  76.       private var owner:VideoPlayer;
  77.       
  78.       private var resourceManager:IResourceManager = ResourceManager.getInstance();
  79.       
  80.       private var _streamName:String;
  81.       
  82.       private var autoSenseBW:Boolean;
  83.       
  84.       private var ncConnected:Boolean;
  85.       
  86.       public var fallbackServerName:String;
  87.       
  88.       private var streams:Array;
  89.       
  90.       public function NCManager()
  91.       {
  92.          super();
  93.          initNCInfo();
  94.          initOtherInfo();
  95.          owner = null;
  96.          _netConnection = null;
  97.          ncConnected = false;
  98.          timeout = DEFAULT_TIMEOUT;
  99.       }
  100.       
  101.       private function getStreamLengthStatus(param1:Object) : void
  102.       {
  103.       }
  104.       
  105.       private function initNCInfo() : void
  106.       {
  107.          _isRTMP = -1;
  108.          serverName = null;
  109.          wrappedURL = null;
  110.          portNumber = null;
  111.          appName = null;
  112.       }
  113.       
  114.       public function get streamWidth() : Number
  115.       {
  116.          return _streamWidth;
  117.       }
  118.       
  119.       public function reconnectOnStatus(param1:NetStatusEvent) : void
  120.       {
  121.          if(param1.info.code == "NetConnection.Connect.Failed" || param1.info.code == "NetConnection.Connect.Rejected")
  122.          {
  123.             _netConnection = null;
  124.             ncConnected = false;
  125.             owner.ncReconnected();
  126.          }
  127.       }
  128.       
  129.       public function get streamName() : String
  130.       {
  131.          return _streamName;
  132.       }
  133.       
  134.       public function connectToURL(param1:String) : Boolean
  135.       {
  136.          var _loc3_:Boolean = false;
  137.          var _loc4_:Boolean = false;
  138.          initOtherInfo();
  139.          contentPath = param1;
  140.          if(!contentPath || contentPath == "")
  141.          {
  142.             throw new VideoError(VideoError.INVALID_CONTENT_PATH);
  143.          }
  144.          var _loc2_:Object = parseURL(contentPath);
  145.          if(!_loc2_.streamName || _loc2_.streamName == "")
  146.          {
  147.             throw new VideoError(VideoError.INVALID_CONTENT_PATH,param1);
  148.          }
  149.          if(_loc2_.isRTMP)
  150.          {
  151.             _loc3_ = canReuseOldConnection(_loc2_);
  152.             _isRTMP = 1;
  153.             protocol = _loc2_.protocol;
  154.             _streamName = _loc2_.streamName;
  155.             serverName = _loc2_.serverName;
  156.             wrappedURL = _loc2_.wrappedURL;
  157.             portNumber = _loc2_.portNumber;
  158.             appName = _loc2_.appName;
  159.             if(!appName || appName == "" || !_streamName || _streamName == "")
  160.             {
  161.                throw new VideoError(VideoError.INVALID_CONTENT_PATH,param1);
  162.             }
  163.             autoSenseBW = _streamName.indexOf(",") >= 0;
  164.             return _loc3_ || connectRTMP();
  165.          }
  166.          _loc4_ = canReuseOldConnection(_loc2_);
  167.          _isRTMP = 0;
  168.          _streamName = _loc2_.streamName;
  169.          return _loc4_ || connectHTTP();
  170.       }
  171.       
  172.       private function getStreamLengthResult(param1:Number) : void
  173.       {
  174.          if(param1 > 0)
  175.          {
  176.             _streamLength = param1;
  177.          }
  178.          owner.ncConnected();
  179.       }
  180.       
  181.       public function get videoPlayer() : VideoPlayer
  182.       {
  183.          return owner;
  184.       }
  185.       
  186.       private function canReuseOldConnection(param1:Object) : Boolean
  187.       {
  188.          if(_netConnection == null || !ncConnected)
  189.          {
  190.             return false;
  191.          }
  192.          if(!param1.isRTMP)
  193.          {
  194.             if(!_isRTMP)
  195.             {
  196.                return true;
  197.             }
  198.             owner.close();
  199.             _netConnection = null;
  200.             ncConnected = false;
  201.             initNCInfo();
  202.             return false;
  203.          }
  204.          if(_isRTMP)
  205.          {
  206.             if(param1.serverName == serverName && param1.appName == appName && param1.protocol == protocol && param1.portNumber == portNumber && param1.wrappedURL == wrappedURL)
  207.             {
  208.                return true;
  209.             }
  210.             owner.close();
  211.             _netConnection = null;
  212.             ncConnected = false;
  213.          }
  214.          initNCInfo();
  215.          return false;
  216.       }
  217.       
  218.       private function connectRTMP() : Boolean
  219.       {
  220.          connectionTimer.reset();
  221.          connectionTimer.start();
  222.          tryNC = [];
  223.          tryNCTimer = new Timer(DEFAULT_NC_TIMEOUT);
  224.          tryNCTimer.addEventListener(TimerEvent.TIMER,nextConnect);
  225.          var _loc1_:uint = 0;
  226.          while(_loc1_ < RTMP_CONN.length)
  227.          {
  228.             tryNC[_loc1_] = new NetConnection();
  229.             tryNC[_loc1_].objectEncoding = ObjectEncoding.AMF0;
  230.             tryNC[_loc1_].client = new NCManagerConnectClient(tryNC[_loc1_],this,_loc1_);
  231.             tryNC[_loc1_].addEventListener(NetStatusEvent.NET_STATUS,connectOnStatus);
  232.             _loc1_++;
  233.          }
  234.          nextConnect(null);
  235.          return false;
  236.       }
  237.       
  238.       public function reconnect() : void
  239.       {
  240.          var _loc1_:String = null;
  241.          if(!_isRTMP)
  242.          {
  243.             _loc1_ = resourceManager.getString("controls","invalidCall");
  244.             throw new Error(_loc1_);
  245.          }
  246.          _netConnection.addEventListener(NetStatusEvent.NET_STATUS,reconnectOnStatus);
  247.          _netConnection.client = new NCManagerReconnectClient(this);
  248.          _netConnection.connect(ncURI,false);
  249.       }
  250.       
  251.       private function bitrateMatch() : void
  252.       {
  253.          var _loc1_:Number = NaN;
  254.          var _loc2_:Number = _bitrate;
  255.          if(isNaN(_loc2_))
  256.          {
  257.             _loc2_ = 0;
  258.          }
  259.          var _loc3_:uint = 0;
  260.          while(_loc3_ < streams.length)
  261.          {
  262.             if(isNaN(streams[_loc3_].bitrate) || _loc2_ >= streams[_loc3_].bitrate)
  263.             {
  264.                _loc1_ = _loc3_;
  265.                break;
  266.             }
  267.             _loc3_++;
  268.          }
  269.          if(isNaN(_loc1_))
  270.          {
  271.             throw new VideoError(VideoError.NO_BITRATE_MATCH);
  272.          }
  273.          if(_streamName)
  274.          {
  275.             _streamName += streams[_loc1_].src;
  276.          }
  277.          else
  278.          {
  279.             _streamName = streams[_loc1_].src;
  280.          }
  281.          _streamLength = streams[_loc1_].dur;
  282.       }
  283.       
  284.       public function get netConnection() : NetConnection
  285.       {
  286.          return _netConnection;
  287.       }
  288.       
  289.       public function get timeout() : uint
  290.       {
  291.          return _timeout;
  292.       }
  293.       
  294.       public function disconnectOnStatus(param1:NetStatusEvent) : void
  295.       {
  296.          if(param1.info.code == "NetConnection.Connect.Success")
  297.          {
  298.             param1.target.removeEventListener(NetStatusEvent.NET_STATUS,disconnectOnStatus);
  299.             NetConnection(param1.target).close();
  300.          }
  301.       }
  302.       
  303.       private function connectHTTP() : Boolean
  304.       {
  305.          _netConnection = new NetConnection();
  306.          _netConnection.objectEncoding = ObjectEncoding.AMF0;
  307.          _netConnection.connect(null);
  308.          ncConnected = true;
  309.          return true;
  310.       }
  311.       
  312.       private function nextConnect(param1:Event) : void
  313.       {
  314.          var _loc2_:String = null;
  315.          var _loc3_:String = null;
  316.          var _loc5_:Number = NaN;
  317.          tryNCTimer.reset();
  318.          if(connTypeCounter == 0)
  319.          {
  320.             _loc2_ = protocol;
  321.             if(portNumber)
  322.             {
  323.                _loc3_ = portNumber;
  324.             }
  325.             else
  326.             {
  327.                _loc5_ = 0;
  328.                while(_loc5_ < RTMP_CONN.length)
  329.                {
  330.                   if(protocol == RTMP_CONN[_loc5_].protocol)
  331.                   {
  332.                      _loc3_ = RTMP_CONN[_loc5_].port;
  333.                      break;
  334.                   }
  335.                   _loc5_++;
  336.                }
  337.             }
  338.          }
  339.          else
  340.          {
  341.             _loc2_ = RTMP_CONN[connTypeCounter].protocol;
  342.             _loc3_ = RTMP_CONN[connTypeCounter].port;
  343.          }
  344.          var _loc4_:String = _loc2_ + (!serverName ? "" : "/" + serverName + ":" + _loc3_ + "/") + (!wrappedURL ? "" : wrappedURL + "/") + appName;
  345.          tryNC[connTypeCounter].client.pending = true;
  346.          tryNC[connTypeCounter].connect(_loc4_,autoSenseBW);
  347.          if(connTypeCounter < RTMP_CONN.length - 1)
  348.          {
  349.             ++connTypeCounter;
  350.             tryNCTimer.start();
  351.          }
  352.       }
  353.       
  354.       public function set videoPlayer(param1:VideoPlayer) : void
  355.       {
  356.          owner = param1;
  357.       }
  358.       
  359.       public function get bitrate() : Number
  360.       {
  361.          return _bitrate;
  362.       }
  363.       
  364.       public function get streamLength() : Number
  365.       {
  366.          return _streamLength;
  367.       }
  368.       
  369.       public function isRTMP() : Boolean
  370.       {
  371.          return _isRTMP != 0;
  372.       }
  373.       
  374.       public function connectAgain() : Boolean
  375.       {
  376.          var _loc1_:Number = Number(appName.indexOf("/"));
  377.          if(_loc1_ < 0)
  378.          {
  379.             _loc1_ = Number(_streamName.indexOf("/"));
  380.             if(_loc1_ >= 0)
  381.             {
  382.                appName += "/";
  383.                appName += _streamName.slice(0,_loc1_);
  384.                _streamName = _streamName.slice(_loc1_ + 1);
  385.             }
  386.             return false;
  387.          }
  388.          var _loc2_:* = appName.slice(_loc1_ + 1);
  389.          _loc2_ += "/";
  390.          _loc2_ += _streamName;
  391.          _streamName = _loc2_;
  392.          appName = appName.slice(0,_loc1_);
  393.          close();
  394.          payload = 0;
  395.          connTypeCounter = 0;
  396.          cleanConns();
  397.          connectRTMP();
  398.          return true;
  399.       }
  400.       
  401.       private function initOtherInfo() : void
  402.       {
  403.          contentPath = null;
  404.          _streamName = null;
  405.          _streamLength = -1;
  406.          _streamWidth = -1;
  407.          _streamHeight = -1;
  408.          streams = null;
  409.          autoSenseBW = false;
  410.          payload = 0;
  411.          connTypeCounter = 0;
  412.          cleanConns();
  413.       }
  414.       
  415.       public function connectOnStatus(param1:NetStatusEvent) : void
  416.       {
  417.          var _loc2_:Object = null;
  418.          var _loc3_:NetConnection = NetConnection(param1.target);
  419.          _loc3_.client.pending = false;
  420.          if(param1.info.code == "NetConnection.Connect.Success")
  421.          {
  422.             _netConnection = tryNC[_loc3_.client.connIndex];
  423.             if(!owner.autoBandWidthDetection)
  424.             {
  425.                onConnected(_netConnection,0);
  426.             }
  427.             tryNC[_loc3_.client.connIndex] = null;
  428.             cleanConns();
  429.          }
  430.          else if((param1.info.code == "NetConnection.Connect.Failed" || param1.info.code == "NetConnection.Connect.Rejected") && _loc3_.client.connIndex == RTMP_CONN.length - 1)
  431.          {
  432.             if(!connectAgain())
  433.             {
  434.                tryFallBack();
  435.             }
  436.          }
  437.       }
  438.       
  439.       private function parseURL(param1:String) : Object
  440.       {
  441.          var _loc5_:Number = NaN;
  442.          var _loc6_:Number = NaN;
  443.          var _loc7_:String = null;
  444.          var _loc8_:Object = null;
  445.          var _loc2_:Object = {};
  446.          var _loc3_:uint = 0;
  447.          var _loc4_:int = int(param1.indexOf(":/",_loc3_));
  448.          if(_loc4_ >= 0)
  449.          {
  450.             _loc4_ += 2;
  451.             _loc2_.protocol = param1.slice(_loc3_,_loc4_);
  452.             _loc2_.isRelative = false;
  453.          }
  454.          else
  455.          {
  456.             _loc2_.isRelative = true;
  457.          }
  458.          if(_loc2_.protocol != null && (_loc2_.protocol == "rtmp:/" || _loc2_.protocol == "rtmpt:/" || _loc2_.protocol == "rtmps:/" || _loc2_.protocol == "rtmpe:/" || _loc2_.protocol == "rmpte:/"))
  459.          {
  460.             _loc2_.isRTMP = true;
  461.             _loc3_ = uint(_loc4_);
  462.             if(param1.charAt(_loc3_) == "/")
  463.             {
  464.                _loc3_++;
  465.                _loc5_ = Number(param1.indexOf(":",_loc3_));
  466.                _loc6_ = Number(param1.indexOf("/",_loc3_));
  467.                if(_loc6_ < 0)
  468.                {
  469.                   if(_loc5_ < 0)
  470.                   {
  471.                      _loc2_.serverName = param1.slice(_loc3_);
  472.                   }
  473.                   else
  474.                   {
  475.                      _loc4_ = _loc5_;
  476.                      _loc2_.portNumber = param1.slice(_loc3_,_loc4_);
  477.                      _loc3_ = uint(_loc4_ + 1);
  478.                      _loc2_.serverName = param1.slice(_loc3_);
  479.                   }
  480.                   return _loc2_;
  481.                }
  482.                if(_loc5_ >= 0 && _loc5_ < _loc6_)
  483.                {
  484.                   _loc4_ = _loc5_;
  485.                   _loc2_.serverName = param1.slice(_loc3_,_loc4_);
  486.                   _loc3_ = uint(_loc4_ + 1);
  487.                   _loc4_ = _loc6_;
  488.                   _loc2_.portNumber = param1.slice(_loc3_,_loc4_);
  489.                }
  490.                else
  491.                {
  492.                   _loc4_ = _loc6_;
  493.                   _loc2_.serverName = param1.slice(_loc3_,_loc4_);
  494.                }
  495.                _loc3_ = uint(_loc4_ + 1);
  496.             }
  497.             if(param1.charAt(_loc3_) == "?")
  498.             {
  499.                _loc7_ = param1.slice(_loc3_ + 1);
  500.                _loc8_ = parseURL(_loc7_);
  501.                if(!_loc8_.protocol || !_loc8_.isRTMP)
  502.                {
  503.                   throw new VideoError(VideoError.INVALID_CONTENT_PATH,param1);
  504.                }
  505.                _loc2_.wrappedURL = "?";
  506.                _loc2_.wrappedURL += _loc8_.protocol;
  507.                if(_loc8_.serverName != null)
  508.                {
  509.                   _loc2_.wrappedURL += "/";
  510.                   _loc2_.wrappedURL += _loc8_.server;
  511.                }
  512.                if(_loc8_.wrappedURL != null)
  513.                {
  514.                   _loc2_.wrappedURL += "/?";
  515.                   _loc2_.wrappedURL += _loc8_.wrappedURL;
  516.                }
  517.                _loc2_.appName = _loc8_.appName;
  518.                _loc2_.streamName = _loc8_.streamName;
  519.                return _loc2_;
  520.             }
  521.             _loc4_ = int(param1.indexOf("/",_loc3_));
  522.             if(_loc4_ < 0)
  523.             {
  524.                _loc2_.appName = param1.slice(_loc3_);
  525.                return _loc2_;
  526.             }
  527.             _loc2_.appName = param1.slice(_loc3_,_loc4_);
  528.             _loc3_ = uint(_loc4_ + 1);
  529.             _loc4_ = int(param1.indexOf("/",_loc3_));
  530.             if(_loc4_ < 0)
  531.             {
  532.                _loc2_.streamName = param1.slice(_loc3_);
  533.                if(_loc2_.streamName.slice(-5).toLowerCase() == ".flv2")
  534.                {
  535.                   _loc2_.streamName = _loc2_.streamName.slice(0,-5);
  536.                }
  537.                else if(_loc2_.streamName.slice(-4).toLowerCase() == ".flv")
  538.                {
  539.                   _loc2_.streamName = _loc2_.streamName.slice(0,-4);
  540.                }
  541.                return _loc2_;
  542.             }
  543.             _loc2_.appName += "/";
  544.             _loc2_.appName += param1.slice(_loc3_,_loc4_);
  545.             _loc3_ = uint(_loc4_ + 1);
  546.             _loc2_.streamName = param1.slice(_loc3_);
  547.             if(_loc2_.streamName.slice(-5).toLowerCase() == ".flv2")
  548.             {
  549.                _loc2_.streamName = _loc2_.streamName.slice(0,-5);
  550.             }
  551.             else if(_loc2_.streamName.slice(-4).toLowerCase() == ".flv")
  552.             {
  553.                _loc2_.streamName = _loc2_.streamName.slice(0,-4);
  554.             }
  555.          }
  556.          else
  557.          {
  558.             _loc2_.isRTMP = false;
  559.             _loc2_.streamName = param1;
  560.          }
  561.          return _loc2_;
  562.       }
  563.       
  564.       public function set timeout(param1:uint) : void
  565.       {
  566.          _timeout = param1;
  567.          connectionTimer = new Timer(_timeout,1);
  568.          connectionTimer.addEventListener(TimerEvent.TIMER,onFCSConnectTimeOut);
  569.       }
  570.       
  571.       public function get streamHeight() : Number
  572.       {
  573.          return _streamHeight;
  574.       }
  575.       
  576.       private function onFCSConnectTimeOut(param1:Event) : void
  577.       {
  578.          cleanConns();
  579.          _netConnection = null;
  580.          ncConnected = false;
  581.          if(!connectAgain())
  582.          {
  583.             owner.ncConnected();
  584.          }
  585.       }
  586.       
  587.       public function onReconnected() : void
  588.       {
  589.          _netConnection.removeEventListener(NetStatusEvent.NET_STATUS,connectOnStatus);
  590.          ncConnected = true;
  591.          owner.ncReconnected();
  592.       }
  593.       
  594.       public function set bitrate(param1:Number) : void
  595.       {
  596.          if(_isRTMP == 0)
  597.          {
  598.             _bitrate = param1;
  599.          }
  600.       }
  601.       
  602.       private function tryFallBack() : void
  603.       {
  604.          if(serverName == fallbackServerName || !fallbackServerName)
  605.          {
  606.             _netConnection = null;
  607.             ncConnected = false;
  608.             owner.ncConnected();
  609.          }
  610.          else
  611.          {
  612.             connTypeCounter = 0;
  613.             cleanConns();
  614.             serverName = fallbackServerName;
  615.             connectRTMP();
  616.          }
  617.       }
  618.       
  619.       public function onConnected(param1:NetConnection, param2:Number) : void
  620.       {
  621.          var _loc3_:Array = null;
  622.          var _loc4_:uint = 0;
  623.          var _loc5_:String = null;
  624.          var _loc6_:Responder = null;
  625.          connectionTimer.reset();
  626.          param1.removeEventListener(NetStatusEvent.NET_STATUS,connectOnStatus);
  627.          _netConnection = param1;
  628.          ncURI = _netConnection.uri;
  629.          ncConnected = true;
  630.          if(autoSenseBW)
  631.          {
  632.             _bitrate = param2 * 1024;
  633.             if(streams)
  634.             {
  635.                bitrateMatch();
  636.             }
  637.             else
  638.             {
  639.                _loc3_ = _streamName.split(",");
  640.                _loc4_ = 0;
  641.                while(_loc4_ < _loc3_.length)
  642.                {
  643.                   _loc5_ = _loc3_[_loc4_].replace(/^\s*(\S.*\S)\s*$/,"$1");
  644.                   if(_loc4_ + 1 >= _loc3_.length)
  645.                   {
  646.                      _streamName = _loc5_;
  647.                      break;
  648.                   }
  649.                   if(param2 <= Number(_loc3_[_loc4_ + 1]))
  650.                   {
  651.                      _streamName = _loc5_;
  652.                      break;
  653.                   }
  654.                   _loc4_ += 2;
  655.                }
  656.                if(_streamName.slice(-5).toLowerCase() == ".flv2")
  657.                {
  658.                   _streamName = _streamName.slice(0,-5);
  659.                }
  660.                else if(_streamName.slice(-4).toLowerCase() == ".flv")
  661.                {
  662.                   _streamName = _streamName.slice(0,-4);
  663.                }
  664.             }
  665.          }
  666.          if(!owner.isLive && _streamLength == -1 && owner.autoBandWidthDetection)
  667.          {
  668.             _loc6_ = new Responder(getStreamLengthResult,getStreamLengthStatus);
  669.             _netConnection.call("getStreamLength",_loc6_,_streamName);
  670.          }
  671.          else
  672.          {
  673.             owner.ncConnected();
  674.          }
  675.       }
  676.       
  677.       public function close() : void
  678.       {
  679.          if(_netConnection)
  680.          {
  681.             _netConnection.close();
  682.             ncConnected = false;
  683.          }
  684.       }
  685.       
  686.       private function cleanConns() : void
  687.       {
  688.          var _loc1_:uint = 0;
  689.          if(tryNCTimer != null)
  690.          {
  691.             tryNCTimer.reset();
  692.             tryNCTimer = null;
  693.          }
  694.          if(tryNC)
  695.          {
  696.             _loc1_ = 0;
  697.             while(_loc1_ < tryNC.length)
  698.             {
  699.                if(tryNC[_loc1_])
  700.                {
  701.                   tryNC[_loc1_].removeEventListener(NetStatusEvent.NET_STATUS,connectOnStatus);
  702.                   if(tryNC[_loc1_].client.pending)
  703.                   {
  704.                      tryNC[_loc1_].addEventListener(NetStatusEvent.NET_STATUS,disconnectOnStatus);
  705.                   }
  706.                   else
  707.                   {
  708.                      tryNC[_loc1_].close();
  709.                   }
  710.                }
  711.                tryNC[_loc1_] = null;
  712.                _loc1_++;
  713.             }
  714.             tryNC = null;
  715.          }
  716.       }
  717.    }
  718. }
  719.  
  720.