判断手机是否连接网络

深碍√TFBOYSˉ_ 2023-08-17 17:09 95阅读 0赞

附上一张效果图（网络状态为true代表联网成功，false则联网失败）

![1264306-20190924141758213-1360993518.gif][]

1.添加一些需要的权限

1  <uses-permission android:name="android.permission.INTERNET"/>
    2 
    3 <uses-permission android:name="android.permission.ACCESS_NETWORK_STATE"/>
    4 
    5 <uses-permission android:name="android.permission.ACCESS_WIFI_STATE"/>
    6 
    7 <uses-permission android:name="android.permission.CHANGE_NETWORK_STATE"/>
    8 
    9 <uses-permission android:name="android.permission.WRITE_SETTINGS"/>

2.判断手机是否联网（这里返回的是boolean型）

//判断手机是否有网络
        public static boolean isOnline() {
            URL url;
            try {
                url = new URL("https://www.baidu.com");
                URLConnection conn = url.openConnection();
                conn.setConnectTimeout(500);
                InputStream inputStream = conn.getInputStream();
                return true;
            } catch (MalformedURLException e) {
                e.printStackTrace();
            } catch (Exception a){
                a.printStackTrace();
            }
            return false;
        }

3.判断当前网络的类型（返回的值是int型的）

1 /*
     2     * 获取当前网络的类型
     3     * 0 没有网络
     4     * 1 WIFI网络
     5     * 2 2G网络
     6     * 3 3G网络
     7     * 4 4G网络
     8     */
     9     public static int getAPNType(Context context){
    10         //结果返回值
    11         int netType = 0;
    12         //获取手机所有连接管理对象
    13         ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
    14         //获取NetWorkinfo对象
    15         NetworkInfo info = manager.getActiveNetworkInfo();
    16         //NetworkInfo对象为空，则代表没有网络
    17         if(info == null){
    18             return netType;
    19         }
    20         //否则NetworkInfo对象不为空，则获取该NetworkInfo的类型
    21         int nType = info.getType();
    22         if(nType == ConnectivityManager.TYPE_WIFI){
    23             netType = 1; //WIFI
    24         }else if(nType == ConnectivityManager.TYPE_MOBILE){
    25             int nSubType = info.getSubtype();
    26             TelephonyManager telephonyManager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
    27 
    28             if(nSubType == TelephonyManager.NETWORK_TYPE_LTE && !telephonyManager.isNetworkRoaming()){
    29                 netType = 4; //4G网络
    30             }else if(nSubType == TelephonyManager.NETWORK_TYPE_UMTS
    31                     || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
    32                     || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
    33                     && !telephonyManager.isNetworkRoaming()){
    34 
    35                 netType = 3; //联通的3G为UMTS或HSDPA 电信的3G为EVDO
    36 
    37             }else if(nSubType == TelephonyManager.NETWORK_TYPE_GPRS
    38                     || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
    39                     || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
    40                     && !telephonyManager.isNetworkRoaming()){
    41 
    42                 netType = 2; //2G
    43 
    44             }else{
    45                 netType = 2;
    46             }
    47         }
    48         return netType;
    49     }

我把它们写成封装类，方便以后调用

1 public class Connections {
      2 
      3     /*
      4     * 判断网络类型
      5     * 值为1 -- WIFI
      6     * 值为0 -- 手机数据网络
      7     * 值为-1 - 断开网络（不包含以上两者）
      8     */
      9     public static int getConnectedType(Context context){
     10         if(context != null){
     11             ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
     12             NetworkInfo info = manager.getActiveNetworkInfo();
     13             if(info != null && info.isAvailable()){
     14                 return info.getType();
     15             }
     16         }
     17         return  -1;
     18     }
     19 
     20     /*
     21     * 判断网络状态
     22     * 有网 - true
     23     * 没网 - false
     24     */
     25     public static boolean isConnectInternet(Context context){
     26         if(context != null){
     27             //获取手机所有连接管理对象（包括WIFI，NET等连接的管理）
     28             ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
     29             //获取NetworkInfo对象
     30             NetworkInfo info = manager.getActiveNetworkInfo();
     31             //判断NetworkInfo对象是否为空，并且类型是否为MOBILE
     32             if(info != null){
     33                 return info.isAvailable();
     34             }
     35         }
     36         return false;
     37     }
     38 
     39     /*
     40      * 判断MOBIL网络是否可用
     41      */
     42     public static boolean isMobileConnected(Context context){
     43         if(context != null){
     44             //获取手机所有连接管理对象（包括WIFI，NET等连接的管理）
     45             ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
     46             //获取NetworkInfo对象
     47             NetworkInfo info = manager.getActiveNetworkInfo();
     48             //判断NetworkInfo对象是否为空，并且类型是否为MOBILE
     49             if(info != null && info.getType() == manager.TYPE_MOBILE){
     50                 return info.isAvailable();
     51             }
     52         }
     53         return false;
     54     }
     55 
     56     /*
     57     * 获取当前网络的类型
     58     * 0 没有网络
     59     * 1 WIFI网络
     60     * 2 2G网络
     61     * 3 3G网络
     62     * 4 4G网络
     63     */
     64     public static int getAPNType(Context context){
     65         //结果返回值
     66         int netType = 0;
     67         //获取手机所有连接管理对象
     68         ConnectivityManager manager = (ConnectivityManager)context.getSystemService(Context.CONNECTIVITY_SERVICE);
     69         //获取NetWorkinfo对象
     70         NetworkInfo info = manager.getActiveNetworkInfo();
     71         //NetworkInfo对象为空，则代表没有网络
     72         if(info == null){
     73             return netType;
     74         }
     75         //否则NetworkInfo对象不为空，则获取该NetworkInfo的类型
     76         int nType = info.getType();
     77         if(nType == ConnectivityManager.TYPE_WIFI){
     78             netType = 1; //WIFI
     79         }else if(nType == ConnectivityManager.TYPE_MOBILE){
     80             int nSubType = info.getSubtype();
     81             TelephonyManager telephonyManager = (TelephonyManager)context.getSystemService(Context.TELEPHONY_SERVICE);
     82 
     83             if(nSubType == TelephonyManager.NETWORK_TYPE_LTE && !telephonyManager.isNetworkRoaming()){
     84                 netType = 4; //4G网络
     85             }else if(nSubType == TelephonyManager.NETWORK_TYPE_UMTS
     86                     || nSubType == TelephonyManager.NETWORK_TYPE_HSDPA
     87                     || nSubType == TelephonyManager.NETWORK_TYPE_EVDO_0
     88                     && !telephonyManager.isNetworkRoaming()){
     89 
     90                 netType = 3; //联通的3G为UMTS或HSDPA 电信的3G为EVDO
     91 
     92             }else if(nSubType == TelephonyManager.NETWORK_TYPE_GPRS
     93                     || nSubType == TelephonyManager.NETWORK_TYPE_EDGE
     94                     || nSubType == TelephonyManager.NETWORK_TYPE_CDMA
     95                     && !telephonyManager.isNetworkRoaming()){
     96 
     97                 netType = 2; //2G
     98 
     99             }else{
    100                 netType = 2;
    101             }
    102         }
    103         return netType;
    104     }
    105 
    106     //判断手机是否有网络
    107     public static boolean isOnline() {
    108         URL url;
    109         try {
    110             url = new URL("https://www.baidu.com");
    111             URLConnection conn = url.openConnection();
    112             conn.setConnectTimeout(500);
    113             InputStream inputStream = conn.getInputStream();
    114             return true;
    115         } catch (MalformedURLException e) {
    116             e.printStackTrace();
    117         } catch (Exception a){
    118             a.printStackTrace();
    119         }
    120         return false;
    121     }
    122 
    123 
    124 }

然后附上效果图的MainActivity类，布局文件就不加了

1 public class MainActivity extends AppCompatActivity implements View.OnClickListener{
      2     private TextView tv_status,tv_type;
      3     private Button btnTest;
      4     private String TAG = "DEBUG";
      5     private Handler handler = new Handler();
      6     private ProgressDialog dialog;
      7 
      8     @Override
      9     protected void onCreate(Bundle savedInstanceState) {
     10         super.onCreate(savedInstanceState);
     11         setContentView(R.layout.activity_main);
     12         initView();
     13     }
     14 
     15     private void initView(){
     16         btnTest = (Button)findViewById(R.id.btnTest);
     17         tv_type = (TextView)findViewById(R.id.net_type);
     18         tv_status = (TextView)findViewById(R.id.net_status);
     19         btnTest.setOnClickListener(this);
     20         btnTest.setVisibility(View.GONE);
     21         initNetWork();
     22         initDialog();
     23     }
     24 
     25 
     26     @Override
     27     public void onClick(View view) {
     28         dialog.show();
     29         handler.postDelayed(new Runnable() {
     30             @Override
     31             public void run() {
     32                 dialog.dismiss();
     33                 initNetWork();
     34                 initDialog();
     35                 boolean status = Connections.isOnline();
     36                 if(status == true){
     37                     Toast.makeText(MainActivity.this, "网络连接成功", Toast.LENGTH_SHORT).show();
     38                 }else{
     39                     Toast.makeText(MainActivity.this, "网络连接失败", Toast.LENGTH_SHORT).show();
     40                 }
     41             }
     42         },2000); //耗时2秒
     43     }
     44 
     45     /*
     46      * 0 没有网络
     47      * 1 WIFI网络
     48      * 2 2G网络
     49      * 3 3G网络
     50      * 4 4G网络
     51      */
     52    private void initNetType(){
     53        final int type = Connections.getAPNType(this);
     54        runOnUiThread(new Runnable() {
     55            @Override
     56            public void run() {
     57                switch (type){
     58                    case 0:
     59                        tv_type.setText("没有网络");
     60                        break;
     61                    case 1:
     62                        tv_type.setText("WIFI网络");
     63                        break;
     64                    case 2:
     65                        tv_type.setText("2G网络");
     66                        break;
     67                    case 3:
     68                        tv_type.setText("3G网络");
     69                        break;
     70                    case 4:
     71                        tv_type.setText("4G网络");
     72                        break;
     73                    default:
     74                        tv_type.setText("其他网络");
     75                        break;
     76                }
     77            }
     78        });
     79    }
     80 
     81    private void initNetWork(){
     82        ConnectivityManager manager = (ConnectivityManager) getSystemService(Context.CONNECTIVITY_SERVICE);
     83        manager.requestNetwork(new NetworkRequest.Builder().build(), new ConnectivityManager.NetworkCallback(){
     84            @Override
     85            public void onLost(@NonNull Network network) {
     86                super.onLost(network);
     87                //网络不可用
     88                Log.d(TAG, "网络不可用" + Connections.isOnline());
     89                runUi(Connections.isOnline());
     90            }
     91 
     92            @Override
     93            public void onAvailable(@NonNull Network network) {
     94                super.onAvailable(network);
     95                //网络可用
     96                Log.d(TAG, "网络可用" + Connections.isOnline());
     97                runUi(Connections.isOnline());
     98            }
     99        });
    100    }
    101 
    102    private void runUi(final boolean status){
    103         runOnUiThread(new Runnable() {
    104             @Override
    105             public void run() {
    106                 tv_status.setText(String.valueOf(status));
    107                 if(status == false){
    108                     btnTest.setVisibility(View.VISIBLE);
    109                 }else{
    110                     btnTest.setVisibility(View.GONE);
    111                 }
    112                 Log.d(TAG, "状态：" + status);
    113             }
    114         });
    115        initNetType();
    116    }
    117 
    118    //加载Dialog
    119     private void initDialog(){
    120         dialog = new ProgressDialog(this);
    121         dialog.setIndeterminate(false); //循环滚动
    122         dialog.setProgressStyle(ProgressDialog.STYLE_SPINNER);
    123         dialog.setMessage("网络重新连接中...");
    124         dialog.setCancelable(false); //false不能取消显示，true可以取消显示
    125     }
    126 }

转载于:https://www.cnblogs.com/Mr-Deng/p/11578025.html

[1264306-20190924141758213-1360993518.gif]: /images/20230808/3a42adcda0cb43b5be5cb516ce542c10.png