快捷搜索:
来自 工程材料 2019-11-03 05:22 的文章
当前位置: 亚洲必赢官方登录 > 工程材料 > 正文

android 5.0 以上监听网络生成

正文#

亚洲必赢官方登录,public class MainActivity extends AppCompatActivity {

@Override
protected void onCreate(Bundle savedInstanceState) {
    super.onCreate(savedInstanceState);
    setContentView(R.layout.activity_main);

    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
        ConnectivityManager connectivityManager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
        // 请注意这里会有一个版本适配bug,所以请在这里添加非空判断
        if (connectivityManager != null) {
            connectivityManager.requestNetwork(new NetworkRequest.Builder().build(), new ConnectivityManager.NetworkCallback() {

                /**
                 * 网络可用的回调
                 * */
                @Override
                public void onAvailable(Network network) {
                    super.onAvailable(network);
                    Log.e("lzp", "onAvailable");
                }

                /**
                 * 网络丢失的回调
                 * */
                @Override
                public void onLost(Network network) {
                    super.onLost(network);
                    Log.e("lzp", "onLost");
                }

                /**
                 * 当建立网络连接时,回调连接的属性
                 * */
                @Override
                public void onLinkPropertiesChanged(Network network, LinkProperties linkProperties) {
                    super.onLinkPropertiesChanged(network, linkProperties);
                    Log.e("lzp", "onLinkPropertiesChanged");
                }

                /**
                 *  按照官方的字面意思是,当我们的网络的某个能力发生了变化回调,那么也就是说可能会回调多次
                 *
                 *  之后在仔细的研究
                 * */
                @Override
                public void onCapabilitiesChanged(Network network, NetworkCapabilities networkCapabilities) {
                    super.onCapabilitiesChanged(network, networkCapabilities);
                    Log.e("lzp", "onCapabilitiesChanged");
                }

                /**
                 * 在网络失去连接的时候回调,但是如果是一个生硬的断开,他可能不回调
                 * */
                @Override
                public void onLosing(Network network, int maxMsToLive) {
                    super.onLosing(network, maxMsToLive);
                    Log.e("lzp", "onLosing");
                }

                /**
                 * 按照官方注释的解释,是指如果在超时时间内都没有找到可用的网络时进行回调
                 * */
                @Override
                public void onUnavailable() {
                    super.onUnavailable();
                    Log.e("lzp", "onUnavailable");
                }

            });
        }
    }
}

}

这就是今天的全部代码了,上面已经有了响应的注释,但是还是不够便于我们理解,接下来就仔细的研究一下:

1、首先我们打开app,此时网络是连接的状态:

image

一打开demo,我们立刻就得到了onAvailable的回调,意思就是网络目前可用,这一点比广播强多了,因为我们已启动还要单独处理一次,而通过回调的方式,可以立刻得到当前的状态。

2、然后我们手动关闭网络:

image

哎?没有onLosing的回调,只看到了onLost,说明我们手动关闭网络连接是一个很粗暴的行为,就像官方注释上写的,如果是一个生硬的断开,他可能不回调。

3、最后我们再次连接网络:

image

这次的回调就比较多了,首先是onAvailable,显示网络可用,然后是onCapabilitiesChanged,说此时网络的连接能力发生了第一次变化,估计是连接中把,再然后是onLinkPropertiesChanged,说明连接的属性已经发生了变化,此时应该获得了ip地址等信息,最后又回调了onCapabilitiesChanged,那么应该是网络进度到可用的状态。

拓展工具类

以下工具类参考Android获取网络状态

public class NetStateUtils {

    /**
     * 判断当前网络是否是移动网络
     *
     * @param context
     * @return boolean
     */
    public static boolean is3G(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && activeNetInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前网络是否是wifi网络
     *
     * @param context
     * @return boolean
     */
    public static boolean isWifi(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && activeNetInfo.getType() == ConnectivityManager.TYPE_WIFI) {
            return true;
        }
        return false;
    }

    /**
     * 判断当前网络是否是2G网络
     *
     * @param context
     * @return boolean
     */
    public static boolean is2G(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo activeNetInfo = connectivityManager.getActiveNetworkInfo();
        if (activeNetInfo != null
                && (activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_EDGE
                || activeNetInfo.getSubtype() == TelephonyManager.NETWORK_TYPE_GPRS || activeNetInfo
                .getSubtype() == TelephonyManager.NETWORK_TYPE_CDMA)) {
            return true;
        }
        return false;
    }

    /**
     * wifi是否打开
     */
    public static boolean isWifiEnabled(Context context) {
        ConnectivityManager mgrConn = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        TelephonyManager mgrTel = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        return ((mgrConn.getActiveNetworkInfo() != null && mgrConn
                .getActiveNetworkInfo().getState() == NetworkInfo.State.CONNECTED) || mgrTel
                .getNetworkType() == TelephonyManager.NETWORK_TYPE_UMTS);
    }

    /**
     * 判断是否有网络连接
     *
     * @param context
     * @return
     */
    public static boolean isNetworkConnected(Context context) {
        if (context != null) {
            // 获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            // 获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            //判断NetworkInfo对象是否为空
            if (networkInfo != null)
                return networkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 判断MOBILE网络是否可用
     *
     * @param context
     * @param context
     * @return
     */
    public static boolean isMobileConnected(Context context) {
        if (context != null) {
            //获取手机所有连接管理对象(包括对wi-fi,net等连接的管理)
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            //获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            //判断NetworkInfo对象是否为空 并且类型是否为MOBILE
            if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE)
                return networkInfo.isAvailable();
        }
        return false;
    }

    /**
     * 获取当前网络连接的类型信息
     * 原生
     *
     * @param context
     * @return
     */
    public static int getConnectedType(Context context) {
        if (context != null) {
            //获取手机所有连接管理对象
            ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                    .CONNECTIVITY_SERVICE);
            //获取NetworkInfo对象
            NetworkInfo networkInfo = manager.getActiveNetworkInfo();
            if (networkInfo != null && networkInfo.isAvailable()) {
                //返回NetworkInfo的类型
                return networkInfo.getType();
            }
        }
        return -1;
    }

    /**
     * 获取当前的网络状态 :没有网络-0:WIFI网络1:4G网络-4:3G网络-3:2G网络-2
     * 自定义
     *
     * @param context
     * @return
     */
    public static int getAPNType(Context context) {
        //结果返回值
        int netType = 0;
        //获取手机所有连接管理对象
        ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context
                .CONNECTIVITY_SERVICE);
        //获取NetworkInfo对象
        NetworkInfo networkInfo = manager.getActiveNetworkInfo();
        //NetworkInfo对象为空 则代表没有网络
        if (networkInfo == null) {
            return netType;
        }
        //否则 NetworkInfo对象不为空 则获取该networkInfo的类型
        int nType = networkInfo.getType();
        if (nType == ConnectivityManager.TYPE_WIFI) {
            //WIFI
            netType = 1;
        } else if (nType == ConnectivityManager.TYPE_MOBILE) {
            int nSubType = networkInfo.getSubtype();
            TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService
                    (Context.TELEPHONY_SERVICE);
            //3G   联通的3G为UMTS或HSDPA 电信的3G为EVDO
            if (nSubType == TelephonyManager.NETWORK_TYPE_LTE
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 4;
            } else if (nSubType == TelephonyManager.NETWORK_TYPE_UMTS
                    || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
                    || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 3;
                //2G 移动和联通的2G为GPRS或EGDE,电信的2G为CDMA
            } else if (nSubType == TelephonyManager.NETWORK_TYPE_GPRS
                    || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
                    || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
                    && !telephonyManager.isNetworkRoaming()) {
                netType = 2;
            } else {
                netType = 2;
            }
        }
        return netType;
    }

    /**
     * 判断GPS是否打开
     * ACCESS_FINE_LOCATION权限
     *
     * @param context
     * @return
     */
    public static boolean isGPSEnabled(Context context) {
        //获取手机所有连接LOCATION_SERVICE对象
        LocationManager locationManager = ((LocationManager) context.getSystemService(Context
                .LOCATION_SERVICE));
        return locationManager.isProviderEnabled(LocationManager.GPS_PROVIDER);
    }

    /**
     * 获得本机ip地址
     *
     * @return
     */
    public static String GetHostIp() {
        try {
            for (Enumeration<NetworkInterface> en = NetworkInterface
                    .getNetworkInterfaces(); en.hasMoreElements(); ) {
                NetworkInterface intf = en.nextElement();
                for (Enumeration<InetAddress> ipAddr = intf.getInetAddresses(); ipAddr
                        .hasMoreElements(); ) {
                    InetAddress inetAddress = ipAddr.nextElement();
                    if (!inetAddress.isLoopbackAddress()) {
                        return inetAddress.getHostAddress();
                    }
                }
            }
        } catch (SocketException ex) {
        } catch (Exception e) {
        }
        return null;
    }

    /**
     * 获取本机串号imei
     *
     * @param context
     * @return
     */
    public static String getIMEI(Context context) {
        TelephonyManager telephonyManager = (TelephonyManager) context
                .getSystemService(Context.TELEPHONY_SERVICE);
        return telephonyManager.getDeviceId();
    }

    /***
     * 判断是否有外网连接(普通方法不能判断外网的网络是否连接,比如连接上局域网)
     *
     * @return
     */

    public static final boolean ping() {

        String result = null;
        try {
            String ip = "www.baidu.com";// ping 的地址,可以换成任何一种可靠的外网
            Process p = Runtime.getRuntime().exec("ping -c 3 -w 100 " + ip);// ping网址3次
            // 读取ping的内容,可以不加
            InputStream input = p.getInputStream();
            BufferedReader in = new BufferedReader(new InputStreamReader(input));
            StringBuffer stringBuffer = new StringBuffer();
            String content = "";
            while ((content = in.readLine()) != null) {
                stringBuffer.append(content);
            }
            Log.d("------ping-----", "result content : " + stringBuffer.toString());
            // ping的状态
            int status = p.waitFor();
            if (status == 0) {
                result = "success";
                return true;
            } else {
                result = "failed";
            }
        } catch (IOException e) {
            result = "IOException";
        } catch (InterruptedException e) {
            result = "InterruptedException";
        } finally {
            Log.d("----result---", "result = " + result);
        }
        return false;

    }
}

转载请注明博客地址:http://blog.csdn.net/gdutxiaoxu/article/details/53008266

源码下载地址:https://github.com/gdutxiaoxu/FunAPP.git

补充#

1、记得申请权限:
<uses-permission android:name="android.permission.CHANGE_NETWORK_STATE" /> <uses-permission android:name="android.permission.WRITE_SETTINGS" />
尤其是WRITE_SETTINGS,这个需要手动申请,千万别忘了。

ConnectivityManager主要用来干什么

  • Monitor network connections (Wi-Fi, GPRS, UMTS, etc.) (用来处理网络连接 ,包括Wi-Fi, GPRS, UMTS等)
  • Send broadcast intents when network connectivity changes(用 网络状态发生变化的时候发出 广播 )
  • Attempt to "fail over" to another network when connectivity to a network is lost(但断开网络连接的时候,尝试去;连接另外一个网络
  • Provide an API that allows applications to query the coarse-grained or fine-grained state of the available networks(
  • Provide an API that allows applications to request and select networks for their data traffic

前言#

大家好,大概有一个多月没有更新博客了,我是干什么去了呢?很明显,程序员当然要加班……这一次跟大家分享一下新项目的一些心得。

监听网络变化在开发中是经常用到的,例如我们断网有一些友好的提示,或者根据不同的网络更改一些加载策略,例如wifi看视频,非wifi则会有一个提示,还有极个别更恶心的偷摸的在后台给你下各种安装包,是谁我就不一一列举了。

在5.0以前,我们都是广播BroadcastReceiver,注册跟网络变化相关的广播,然后判断是连接还是断开,这种做法非常方便,但是随着安卓的版本迭代,在权限上越来越谨慎,广播的方式就显得不太优雅。

打个比方,之前就是拿个大喇叭,在大街上各种喊,就好像逛地摊,各种商品的吆喝声混在一起,需要你自己去分辨哪些是你想要的信息,而且又显得很不安全,万一卖的商品比较隐私呢,大家都是很低调的人。

所以在安卓5.0以上终于对网络的监听进行了优化,那就是通过Callback回调的方式,这种开发模式是不是很常用?例如监听下载进度,我只需要三个回调:下载成功,下载失败,下载的进度变化,这种回调方式针对性强,耦合性低,非常方便,和广播相比,就好像我们是一个订购了服务,需要的东西自动上门,very good。

废话铺垫了这么多,下面就是一个实战demo。

获取 NetworkInfo对象

主要有一下 几种方法

  • getNetworkInfo(int networkType),但是这个方法已经过时,官网的解释如下:This method was deprecated in API level 23. This method does not support multiple connected networks of the same type. Use getAllNetworks() and getNetworkInfo(android.net.Network) instead.
  • getNetworkInfo(Network network)
  • getActiveNetwork()
    Returns a Network object corresponding to the currently active default data network.
  • getActiveNetworkInfo(),Returns details about the currently active default data network.
  • www.必赢766,getAllNetworkInfo()这个方法已经过时,Use getAllNetworks() and getNetworkInfo(android.net.Network) instead.

综上所述,我们如果要知道当前Mobile网络或者WiFi网络是否已经连接上,总共有两种方法。

第一种方法,只不过在 API23的时候已经 过时了

State wifiState = null;
State mobileState = null;

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context
        .CONNECTIVITY_SERVICE);
wifiState = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();
mobileState = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();

Log.d(TAG1,
        "wifi状态:" + wifiState + "n mobile状态:" + mobileState);

if (wifiState != null && mobileState != null
        && State.CONNECTED != wifiState
        && State.CONNECTED == mobileState) {// 手机网络连接成功  
    Log.d(TAG1, "手机2g/3g/4g网络连接成功");

    APP.getInstance().setMobile(true);
    APP.getInstance().setWifi(false);
    APP.getInstance().setConnected(true);

} else if (wifiState != null && State.CONNECTED == wifiState) {// 无线网络连接成功  
    Log.d(TAG1, "无线网络连接成功");

    APP.getInstance().setMobile(false);
    APP.getInstance().setWifi(true);
    APP.getInstance().setConnected(true);

} else if (wifiState != null && mobileState != null
        && State.CONNECTED != wifiState
        && State.CONNECTED != mobileState) {// 手机没有任何的网络  
    Log.d(TAG1, "手机没有任何的网络");

    APP.getInstance().setMobile(false);
    APP.getInstance().setWifi(false);
    APP.getInstance().setConnected(false);

}

第二种方法

ConnectivityManager manager = (ConnectivityManager) context
        .getSystemService(Context.CONNECTIVITY_SERVICE);
Log.i(TAG1, "CONNECTIVITY_ACTION");

NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
if (activeNetwork != null) { // connected to the internet
    if (activeNetwork.isConnected()) {
        if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
            // connected to wifi
            APP.getInstance().setWifi(true);
            Log.e(TAG, "当前WiFi连接可用 ");
        } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
            // connected to the mobile provider's data plan
            APP.getInstance().setMobile(true);
            Log.e(TAG, "当前移动网络连接可用 ");
        }
    } else {
        Log.e(TAG, "当前没有网络连接,请确保你已经打开网络 ");
    }
} else {   // not connected to the internet
    Log.e(TAG, "当前没有网络连接,请确保你已经打开网络 ");
    APP.getInstance().setWifi(false);
    APP.getInstance().setMobile(false);
    APP.getInstance().setConnected(false);

}

总结#

我没有模拟出onLosing和onUnavailable的场景,至少说明他俩的出现的概率现在已经不高了,我们已经通过注释简单理解了他俩的场景,这里就不做深入研究了。

通过刚才的实验,我们得出了一下结论:

1、要想监听网络的连接和断开,应该在onAvailable和onLost中,他们一定会成对出现。

2、其他的几个回调使用场景会少一点,并且onCapabilitiesChanged会回调多次,所以使用它时我们要慎重,避免重复的操作,但是可以保证最后一次回调,网络的连接一定是连接成功的。

OK,从这个小小的变化,我们看到了安卓在慢慢变得更好,使用起来更简洁更优雅,这也加大了某些素质低的厂商想尽办法后台干点坏事的行为。

今天就到这里,有什么问题大家一起留言讨论~

使用静态广播还是动态注册广播的方式好呢?

如果你不太清楚的话,我只能说即 基础不扎实。我们的应用之所以要监听网络状态的 变化,主要是为了在错误的情况下方便进行处理,退出我们当前的应用之后当然不需要监听了,所以选择动态注册广播。

  • 动态注册:随着所在的Activity或者应用销毁 以后,不会受到该广播
  • 静态注册:退出应用后,仍然能够收到相应的广播

共同点:都需要在AndroidMainest清单文件里面注册

动态注册

第一步:在AndroidMainest文件里面注册

<receiver android:name=".network.NetworkConnectChangedReceiver">
        </receiver>

第二步:调用 Context registerReceiver(Receiver,IntentFilter) 进行注册

IntentFilter filter = new IntentFilter();
filter.addAction("android.net.conn.CONNECTIVITY_CHANGE");
filter.addAction("android.net.wifi.WIFI_STATE_CHANGED");
filter.addAction("android.net.wifi.STATE_CHANGE");
registerReceiver(mNetworkChangeListener,filter);

网络错误情况的处理

正如前面所提到的,这篇博客吧网络错误主要分为两大类

  • 没有网络情况的错误
  • 在有网络的情况下,我们客户端的错误或者服务器端的错误
    在这里 我们主要处理没有网络情况下的错误,现在 个人了解到 的主要有两种处理方法。

第一种做法:
在APP启动的 时候检查当前是否已经连接上网络,弹出一个对话框没有的话跳转到设置界面或者WiFi设置界面或者打开移动网络界面 。

第二种方法

其实跟第一种做法差不多,只是在每一次 错误的情况下,都会判断当前有没有 网络 ,没有弹出一个对话框,跳转到设置界面或者WiFi设置界面或者打开移动网络界面 , 下面我们我们一起来看一下 怎样弹出一个对话框,并且跳转到相应的设置界面

这里我们采取第一种做法,效果图如下

静态注册

<receiver android:name=".network.NetworkConnectChangedReceiver">
    <intent-filter>
        <action android:name="android.NET.conn.CONNECTIVITY_CHANGE" />
        <action android:name="android.Net.wifi.WIFI_STATE_CHANGED" />
        <action android:name="android.net.wifi.STATE_CHANGE" />
    </intent-filter>
</receiver>

通过广播监听网络状态的两种方法

代码如下

public static void showWifiDlg(final Context context) {
    AlertDialog.Builder builder = new AlertDialog.Builder(context.getApplicationContext());
    if (mWifiDialog == null) {
        mWifiDialog = builder.setIcon(R.drawable.ic_launcher)         //
                .setTitle("wifi设置")            //
                .setMessage("当前无网络").setPositiveButton("设置", new DialogInterface
                        .OnClickListener() {

                    @Override
                    public void onClick(DialogInterface dialog, int which) {
                        // 跳转到系统的网络设置界面
                        Intent intent = null;
                        // 先判断当前系统版本
                        if (android.os.Build.VERSION.SDK_INT > 10) {  // 3.0以上
                            intent = new Intent(android.provider.Settings
                                    .ACTION_WIFI_SETTINGS);
                        } else {
                            intent = new Intent();
                            intent.setClassName("com.android.settings",
                                    Settings.ACTION_WIFI_SETTINGS);
                        }
                        if ((context instanceof Application)) {
                            intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
                        }
                        context.startActivity(intent);

                    }
                }).setNegativeButton("知道了", null).create();
        // 设置为系统的Dialog,这样使用Application的时候不会 报错
        mWifiDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);
    }
    mWifiDialog.show();


}

这里对几个 重要的 Action说一下

  • ACTION_DATA_ROAMING_SETTINGS : 跳转到移动网络设置界面
  • ACTION_WIFI_SETTINGS
    Activity Action: Show settings to allow configuration of Wi-Fi.
  • ACTION_WIRELESS_SETTINGS
    Activity Action: Show settings to allow configuration of wireless controls such as Wi-Fi, Bluetooth and Mobile networks.

关于更多Activity Action,请参考官网地址

需要注意的是

若我们 使用的Context不是Activity 的Context 而是Application的 Context,我们 需要做以下处理 ,否则会报错

// 设置为系统级别的Dialog
mWifiDialog.getWindow().setType(WindowManager.LayoutParams.TYPE_SYSTEM_ALERT);

if ((context instanceof Application)) {                            intent.addFlags(FLAG_ACTIVITY_NEW_TASK);
 }
context.startActivity(intent);


在AndroidMainFest中添加以下权限 。
 <!--允许 弹出系统级别的AlterDialog-->
    <uses-permission android:name="android.permission.SYSTEM_ALERT_WINDOW"/>

效果图如下

我们可以看到在开启智能无图的情况下,若不是连接WiFi ,我们是不会去加载网络图片的。

android 监听网络状态的变化及实战

转载请注明博客地址:http://blog.csdn.net/gdutxiaoxu/article/details/53008266

平时我们在请求错误的情况下,通常会进行处理一下,一般来说,主要分为两方面的错误

  • 没有网络的错误
  • 在有网络的情况下,我们客户端的错误或者服务器端的错误

今天这篇博客主要阐述以下问题

  • 怎样监听网络状态的变化,包括是否打开WiFi,否打开数据网络,当前连接的网络是否可用
  • 网络没有打开情况下的处理,如弹出对话框,跳转到 打开 WiFi设置的界面等
  • 非WiFi情况下是否加载图片,是否播放视频等

怎样获取ConnectivityManager对象呢?

ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context
        .CONNECTIVITY_SERVICE);

智能无图

智能无图,这种浏览模式我们平时 很常见,比如在UC浏览器中,网易新闻中都有看到这种模式,这种模式的实质就是监听网络状态,再根据是否是WiFi去确定是否加载网络图片。

实现的核心代码如下

1)当智能无图模式变化的时候,我们会把标志存进SharePreferences中

mSwitchWifiPic.setOnCheckedChangeListener(new CompoundButton.OnCheckedChangeListener() {
    @Override
    public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {

        SPUtils.put(SPConstants.isIntelligentNoPic,isChecked);

    }
});

同时我们为了进来的时候界面与SharePreferences中的 isIntelligentNoPic的值保持一致,我们需要调用一下代码

boolean isIntelligentNoPic = SPUtils.getBoolean(SPConstants.isIntelligentNoPic);
mSwitchWifiPic.setChecked(isIntelligentNoPic);

2)在NewsListAdapter中

// 是否开启智能无图模式,true表示开启智能无图模式
boolean isIntelligentNoPic = SPUtils.getBoolean(Constants.SPConstants.isIntelligentNoPic);
WriteLogUtil.i("isIntelligentNoPic=" + isIntelligentNoPic);
if (isIntelligentNoPic) {
    if (APP.getInstance().isWifi()) {
        GlideUtils.display(mContext, iv, picUrl);
    } else {
        iv.setImageDrawable(new ColorDrawable(Color.GRAY));
    }

} else {
    GlideUtils.display(mContext, iv, picUrl);
}

至于APP.getInstance().isWifi()表示当前是否连接WiFi,是通过 监听广播实现的 ,前面已经说明了,这里就不再阐述了。


实现思路

在网络错误的情况下获取网络状态进行判断,这种方法是可行的,但你想过了没有,如果每次都要进行这样的判断,岂不是代码量很多?有人会说,那把代码封装到一个类不就好了吗?这样确实能减少代码量,但是每次都要主动去获取,这样是不是挺麻烦的。实际上,google 早就帮我们封装好了,在网络状态变化的情况下会发出广播,我们只需要监听广播就好了 。

ConnectivityManager和NetworkInfo

思路解析

从上面的代码中,我们可以知道我们将我们当前的网络状态保存在我们的 APP 里面,这样当网络状态变化的时候会自动去改变 APP 里面相应的状态量,我们进行网络处理的 时候只需要去获取 APP里面的状态量,便可以判断出是属于哪一种网络错误,是不是很方便呢。

至于广播的Action主要有三种类型:

WifiManager.WIFI_STATE_CHANGED_ACTION

这个监听wifi的打开与关闭,与wifi的连接无关

WifiManager.NETWORK_STATE_CHANGED_ACTION:

这个监听wifi的连接状态即是否连上了一个有效无线路由,当上边广播的状态是WifiManager.WIFI_STATE_DISABLING,和WIFI_STATE_DISABLED的时候,根本不会接到这个广播。

在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播,当然刚打开wifi肯定还没有连接到有效的无线

ConnectivityManager.CONNECTIVITY_ACTION

这个监听网络连接的设置,包括wifi和移动数据的打开和关闭。.
最好用的还是这个监听。wifi如果打开,关闭,以及连接上可用的连接都会接到监听。这个广播的最大弊端是比上边两个广播的反应要慢,如果只是要监听wifi,我觉得还是用上边两个配合比较合适。

至于这个ConnectivityManager,NetworkInfo是什么东西,别急,下面会大概介绍一下。


我们自定义的NetworkChangeListener广播

/**
 * 网络改变监控广播
 * <p>
 * 监听网络的改变状态,只有在用户操作网络连接开关(wifi,mobile)的时候接受广播,
 * 然后对相应的界面进行相应的操作,并将 状态 保存在我们的APP里面
 * <p>
 * <p>
 * Created by xujun
 */
public class NetworkConnectChangedReceiver extends BroadcastReceiver {

    private static final String TAG = "xujun";
    public static final String TAG1 = "xxx";

    @Override
    public void onReceive(Context context, Intent intent) {
        // 这个监听wifi的打开与关闭,与wifi的连接无关
        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(intent.getAction())) {
            int wifiState = intent.getIntExtra(WifiManager.EXTRA_WIFI_STATE, 0);
            Log.e(TAG1, "wifiState" + wifiState);
            switch (wifiState) {
                case WifiManager.WIFI_STATE_DISABLED:
                    APP.getInstance().setEnablaWifi(false);
                    break;
                case WifiManager.WIFI_STATE_DISABLING:

                    break;
                case WifiManager.WIFI_STATE_ENABLING:
                    break;
                case WifiManager.WIFI_STATE_ENABLED:
                    APP.getInstance().setEnablaWifi(true);
                    break;
                case WifiManager.WIFI_STATE_UNKNOWN:
                    break;
                default:
                    break;


            }
        }
        // 这个监听wifi的连接状态即是否连上了一个有效无线路由,当上边广播的状态是WifiManager
        // .WIFI_STATE_DISABLING,和WIFI_STATE_DISABLED的时候,根本不会接到这个广播。
        // 在上边广播接到广播是WifiManager.WIFI_STATE_ENABLED状态的同时也会接到这个广播,
        // 当然刚打开wifi肯定还没有连接到有效的无线
        if (WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(intent.getAction())) {
            Parcelable parcelableExtra = intent
                    .getParcelableExtra(WifiManager.EXTRA_NETWORK_INFO);
            if (null != parcelableExtra) {
                NetworkInfo networkInfo = (NetworkInfo) parcelableExtra;
                State state = networkInfo.getState();
                boolean isConnected = state == State.CONNECTED;// 当然,这边可以更精确的确定状态
                Log.e(TAG1, "isConnected" + isConnected);
                if (isConnected) {
                    APP.getInstance().setWifi(true);
                } else {
                    APP.getInstance().setWifi(false);
                }
            }
        }
        // 这个监听网络连接的设置,包括wifi和移动数据的打开和关闭。.
        // 最好用的还是这个监听。wifi如果打开,关闭,以及连接上可用的连接都会接到监听。见log
        // 这个广播的最大弊端是比上边两个广播的反应要慢,如果只是要监听wifi,我觉得还是用上边两个配合比较合适
        if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
            ConnectivityManager manager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            Log.i(TAG1, "CONNECTIVITY_ACTION");

            NetworkInfo activeNetwork = manager.getActiveNetworkInfo();
            if (activeNetwork != null) { // connected to the internet
                if (activeNetwork.isConnected()) {
                    if (activeNetwork.getType() == ConnectivityManager.TYPE_WIFI) {
                        // connected to wifi
                        APP.getInstance().setWifi(true);
                        Log.e(TAG, "当前WiFi连接可用 ");
                    } else if (activeNetwork.getType() == ConnectivityManager.TYPE_MOBILE) {
                        // connected to the mobile provider's data plan
                        APP.getInstance().setMobile(true);
                        Log.e(TAG, "当前移动网络连接可用 ");
                    }
                } else {
                    Log.e(TAG, "当前没有网络连接,请确保你已经打开网络 ");
                }


                Log.e(TAG1, "info.getTypeName()" + activeNetwork.getTypeName());
                Log.e(TAG1, "getSubtypeName()" + activeNetwork.getSubtypeName());
                Log.e(TAG1, "getState()" + activeNetwork.getState());
                Log.e(TAG1, "getDetailedState()"
                        + activeNetwork.getDetailedState().name());
                Log.e(TAG1, "getDetailedState()" + activeNetwork.getExtraInfo());
                Log.e(TAG1, "getType()" + activeNetwork.getType());
            } else {   // not connected to the internet
                Log.e(TAG, "当前没有网络连接,请确保你已经打开网络 ");
                APP.getInstance().setWifi(false);
                APP.getInstance().setMobile(false);
                APP.getInstance().setConnected(false);

            }


        }
    }


}

最后,别忘记添加一下权限

<uses-permission android:name="android.permission.INTERNET"/>

 <!--允许读取网络状态-->
 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"></uses-permission>
<!--允许读取wifi网络状态-->
 <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>

本文由亚洲必赢官方登录发布于工程材料,转载请注明出处:android 5.0 以上监听网络生成

关键词: