AIR檢測網絡

    package com.juyou.util.net  
    {  
        import flash.events.StatusEvent;  
        import flash.net.URLRequest;  
          
        import air.net.URLMonitor;  
        /** 
         * 網絡監聽 
         *  
         */  
        public class NetChecker  
        {  
            private static var request:URLRequest = new URLRequest("http://www.baidu.com");  
            private static var monitor:URLMonitor;  
            /**檢測間隔時間*/  
            public static var _interval:Number = 10000;  
            private static var available:Boolean = true;  
            private static var observerList:Vector.<INetObserver> = new Vector.<INetObserver>();  
            public function NetChecker()  
            {  
                  
            }  
            /** 
             * 註冊觀察者對象 
             * @param obj    觀察者對象 
             */  
            public static function attach(obj:INetObserver):void  
            {  
                if(observerList.indexOf(obj) == -1)  
                {  
                    observerList.push(obj);  
                }  
            }  
              
            /** 
             * 刪除觀察者對象 
             * @param obj    觀察者對象 
             */  
            public static function detach(obj:INetObserver):void{  
                var index:int = observerList.indexOf(obj);  
                if(index == -1)  
                    return;  
                observerList.splice(index,1);  
            }  
              
            /** 
             * 通知全部註冊的觀察者對象 
             */  
            private static function nodifyObservers():void{  
                for each(var obj:INetObserver in observerList)  
                {  
                    obj.updateNetAvailable(available);  
                }  
            }  
              
            /** 
             * 開始監聽網絡情況  
             *  
             */  
            public static function monitorNetwork():void  
            {  
                if(!monitor)  
                    monitor = new URLMonitor(request);  
                monitor.pollInterval = _interval;  
                monitor.addEventListener(StatusEvent.STATUS,onStatusHandler);  
                monitor.start();  
            }  
              
            /** 
             * 設置監聽網絡間隔  
             * @param val 
             *  
             */  
            public static function set interval(val:Number):void  
            {  
                if(_interval == val)return;  
                _interval = val;  
                if(monitor && monitor.running)  
                {  
                    monitor.stop();  
                    monitor.pollInterval = _interval;  
                    monitor.start();  
                }  
            }  
              
            public static function get interval():Number  
            {  
                return _interval;  
            }  
              
            /** 
             * 中止監聽網絡狀態  
             *  
             */  
            public static function stopMonitor():void  
            {  
                if(monitor)  
                    monitor.stop();  
            }  
              
            /** 
             * 判斷當前網絡是否可用  
             * @return  
             *  
             */  
            public static function get networkAvailable():Boolean  
            {  
                return available;  
            }  
              
            private static function onStatusHandler(e:StatusEvent):void  
            {  
    //          trace( ">>onStatusEvent::evt.code=" + e );  
                if(e.level == "status")  
                {  
                    var flag:Boolean = false;  
                    if(monitor.available && !available)  
                    {  
                        trace("網絡已鏈接");  
                        available = true;  
                        flag = true;  
                    }  
                    else if(!monitor.available && available)  
                    {  
                        available = false;  
                        trace("沒有檢測到網絡");  
                        flag = true;  
                    }  
                      
                    if(flag)  
                    {  
                        nodifyObservers();  
                    }  
                }  
                      
            }  
              
        }  
    }  

    package  
    {  
        public interface INetObserver  
        {  
            function updateNetAvailable(ava:Boolean):void;  
        }  
    }