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;  
        }  
    }