在AndroidTV的開發過程中,需要對網路的開關狀態進行判斷,現將判斷程式碼歸納如下:

匯入一個jar包,為了支援Pppoe的Api的呼叫

  jar包附在後面的Demo裡面.匯入Demo會出現方法數超過65535的提示,具體的解決方法見:**
  Android中加入依賴庫點選執行後報出,com.android.dex.DexIndexOverflowException: method ID not in [0, 0xffff]: 65536 http://blog.csdn.net/zxc514257857/article/details/66997689

Demo展示圖片:

  沒網路的狀態圖片:

  無線網路連線的狀態圖片

  Pppoe網路連線的狀態圖片:

佈局程式碼如下:

//（layout）activity_main.xml
<RelativeLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/activity_main"
    android:layout_width="match_parent"
    android:layout_height
 
="match_parent"
    tools:context="com.test.tvnetwork.activity.MainActivity">
    <ImageView
        android:layout_margin="10dp"
        android:id="@+id/imageView"
        android:layout_alignParentRight="true"
        android:layout_alignParentBottom="true"
        android:layout_width="40dp"
        android:layout_height
 
="40dp"/>
</RelativeLayout>

工具類程式碼如下:

//（utils）NetUtils
package com.test.tvnetwork.utils;

import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.wifi.WifiManager;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.net.HttpURLConnection;
import java.net.SocketException;
import java.net.SocketTimeoutException;
import java.net.URL;

public class NetUtils {
    //isConnect判斷網路是否連線
    public static boolean isConnect = false;
    //isCheck判斷網路是否檢測
    public static boolean isCheck = false;
    //isPppoeConnect判斷pppoe網路是否檢測
    public static boolean isPppoeConnect = false;
    //檢測pppoe網路，耗時操作不能放在主執行緒
    private static Thread mThread = null;
    //netconfigDetail用於返回的網路圖示值
    //valueEthernet 判斷有線網路是否可用的返回值
    //valueWifi 判斷無線網路是否可用的返回值
    //根據valueEthernet和valueWifi來檢測pppoe
    int netconfigDetail, valueEthernet, valueWifi;
    public int getNetwork(Context mContext) {
        isCheck = true;
        isConnect = false;
        WifiManager mWifiManager;
        ConnectivityManager mConnectivityManager;
        NetworkInfo ethernetNetInfo;
        //獲得WifiManager物件
        mWifiManager = (WifiManager) mContext
                .getSystemService(Context.WIFI_SERVICE);
        //獲得ConnectivityManager物件
        mConnectivityManager = (ConnectivityManager) mContext
                .getSystemService(Context.CONNECTIVITY_SERVICE);
        //獲得NetworkInfo物件
        ethernetNetInfo = mConnectivityManager
                .getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
        if (ethernetNetInfo.isConnected()) {
            //如果有線網連線，值為4
            netconfigDetail = 4;
            valueEthernet = 1;
        } else {
            if (mWifiManager.getWifiState() == WifiManager.WIFI_STATE_ENABLED) {
                if (mWifiManager.getConnectionInfo().getIpAddress() == 0) {
                    //如果無線網可用，值為-1
                    valueWifi = -1;
                    //如果無線網不可用，值為6
                    netconfigDetail = 6;
                } else {
                    //如果無線網可用，值為0-3
                    netconfigDetail = WifiManager.calculateSignalLevel(mWifiManager
                            .getConnectionInfo().getRssi(), 4);
                }
            } else if (mWifiManager.getWifiState() == WifiManager.WIFI_STATE_DISABLED) {
                //如果無線網不可用，值為5
                netconfigDetail = 5;
                //如果無線網不可用，值為-1
                valueEthernet = -1;
            }
        }
        if (valueWifi < 0 && valueEthernet < 0) {
            //滿足判斷的條件則判斷是否可用，判斷網路連通（包含了pppoe的檢測）
            checkPppoe();
        } else {
            isConnect = true;
            isCheck = false;
            isPppoeConnect = false;
        }
        return netconfigDetail;
    }

    public static void checkPppoe() {
        if (mThread != null && !mThread.isInterrupted()) {
            //檢測前將thread置為null
            mThread.interrupt();
            mThread = null;
        }
        if (mThread == null || mThread.isInterrupted()) {
            mThread = new Thread(new Runnable() {
                public void run() {
                    isCheck = true;
                    isConnect = false;
                    isConnect = isConnected();
                    isCheck = false;
                    isPppoeConnect = isConnect;
                }
            });
            mThread.start();
        }
    }

    private static boolean isConnected() {
        //傳送一個請求用來檢測是否已連線網路，並判斷通暢
        //在這裡你也可以ping某個IP，來判斷是否已連線
        try {
            URL url = new URL("http://www.baidu.com");
            HttpURLConnection conn = (HttpURLConnection) url.openConnection();
            conn.setRequestMethod("GET");
            conn.setRequestProperty("connection", "close");
            conn.setConnectTimeout(4000);
            conn.setReadTimeout(4000);
            BufferedReader reader = null;
            try {
                conn.connect();
                try {
                    if (conn.getInputStream() != null)
                        reader = new BufferedReader(new InputStreamReader(
                                conn.getInputStream()), 512);
                } catch (IOException e) {
                    if (conn.getErrorStream() != null)
                        reader = new BufferedReader(new InputStreamReader(
                                conn.getErrorStream()), 512);
                }
                if (reader != null)
                    reader.close();

                if (conn != null)
                    conn.disconnect();
                return true;
            } catch (SocketException e) {
                e.printStackTrace();
                return false;
            } catch (SocketTimeoutException e) {
                e.printStackTrace();
                return false;
            }
        } catch (Exception e) {
            e.printStackTrace();
        }
        return false;
    }
}
----------------------------------------------------------------------------------

//（utils）NetCheckUtils
package com.test.tvnetwork.utils;

import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.net.ConnectivityManager;
import android.net.ethernet.EthernetManager;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.Message;
import static com.test.tvnetwork.constant.ConFigs.NET;

public class NetCheckUtils {
    private Context mContext;
    private BroadcastReceiver mReceiver;
    private Handler mHandler;
    public Boolean isReceiver = false;
    private int netCondition;

    public NetCheckUtils(Context context, Handler handler) {
        mContext = context;
        mHandler = handler;
    }
    //獲得網路的具體返回值
    public void getNetwork() {
        WifiManager wifiManager = (WifiManager) mContext.getSystemService(Context.WIFI_SERVICE);
        ConnectivityManager connectivityManager = (ConnectivityManager) mContext.getSystemService(Context.CONNECTIVITY_SERVICE);
        //廣播的action有四種，包含了有線網路變化，無線網路變化和網路連線變化
        IntentFilter mFilter = new IntentFilter();
        mFilter.addAction(EthernetManager.NETWORK_STATE_CHANGED_ACTION);
        mFilter.addAction(WifiManager.WIFI_STATE_CHANGED_ACTION);
        mFilter.addAction(WifiManager.NETWORK_STATE_CHANGED_ACTION);
        mFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);

        mReceiver = new BroadcastReceiver() {
            public void onReceive(Context context, Intent intent) {
                handleEvent(mContext, intent);
            }
        };

        //註冊廣播
        if (!isReceiver) {
            mContext.registerReceiver(mReceiver, mFilter);
            isReceiver = true;
        }
    }
   //登出廣播
    public void unregisterReceiver() {
        mContext.unregisterReceiver(mReceiver);
    }

    private void handleEvent(Context context, Intent intent) {
        //處理廣播不同action事件
        String action = intent.getAction();
        if (WifiManager.WIFI_STATE_CHANGED_ACTION.equals(action)
                || WifiManager.NETWORK_STATE_CHANGED_ACTION.equals(action)
                || ConnectivityManager.CONNECTIVITY_ACTION.equals(action)
                || EthernetManager.NETWORK_STATE_CHANGED_ACTION.equals(action)) {
            netCondition = new NetUtils().getNetwork(mContext);
            Message msg = new Message();
            msg.obj = netCondition;
            msg.what = NET;
            //傳送訊息，通知主頁面更新UI
            mHandler.sendMessage(msg);
        }
    }
}

常量類程式碼如下:

//(constant)Configs
package com.test.tvnetwork.constant;

public class ConFigs {
    public static final int NET = 100;
}

Activity中的程式碼如下:

//(activity)MainActivity
package com.test.tvnetwork.activity;

import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.support.v7.app.AppCompatActivity;
import android.util.Log;
import android.widget.ImageView;
import com.test.tvnetwork.R;
import com.test.tvnetwork.utils.NetCheckUtils;
import static com.test.tvnetwork.R.id.imageView;
import static com.test.tvnetwork.constant.ConFigs.NET;

public class MainActivity extends AppCompatActivity {
    private ImageView mImageView;
    private NetCheckUtils mNetCheckUtils;

    //網路監聽圖片陣列
    public static int[] mNetLogo = new int[]{R.mipmap.wifi0, R.mipmap.wifi1,
            R.mipmap.wifi2, R.mipmap.wifi3, R.mipmap.connect,
            R.mipmap.etnerror, R.mipmap.wifinotnormal};

    private Handler handler = new Handler() {
        @Override
        public void handleMessage(Message msg) {
            super.handleMessage(msg);
            switch (msg.what) {
                case NET:
                    int obj = (int) msg.obj;
                    Log.e("handleMessage","obj"+obj);
                    mImageView.setImageResource(mNetLogo[obj]);
                    break;
            }
        }
    };

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

    @Override
    protected void onDestroy() {
        super.onDestroy();
        mNetCheckUtils.unregisterReceiver();
    }

    private void initView(){
        mImageView = (ImageView) findViewById(imageView);
    }

    //開啟新執行緒，防止阻塞UI主執行緒
    private void checkNet() {
        Thread thread = new Thread(new Runnable() {
            @Override
            public void run() {
                mNetCheckUtils = new NetCheckUtils(MainActivity.this, handler);//網路
                mNetCheckUtils.getNetwork();
            }
        });
        thread.start();
    }
}

注意事項

  注:本程式碼僅對有Pppoe埠的AndroidTV有效,手機裝置執行可能會報錯.

  注:需要新增許可權:

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