NetWorkUtils HttpUtils

已于 2022-12-16 11:17:55 修改
阅读量215 收藏
点赞数
文章标签： android java 开发语言
于 2020-04-14 21:04:54 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/qq_26331411/article/details/105521120
版权 

package com.iflytek.base.lib_app.utils.system;

import android.annotation.SuppressLint;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.Network;
import android.net.NetworkCapabilities;
import android.net.NetworkInfo;
import android.os.Build;

import com.iflytek.base.lib_app.BaseApplication;
import com.iflytek.collector.common.net.RetransmissionTask;

/**
 * author : dzh .
 * date   : 2018/1/31
 * desc   : 网络
 * @author luoming 最新的代码
 */
public class NetUtil {
    /**
     * 没有连接网络
     */
    public static final int NETWORK_NONE = -1;
    /**
     * 移动网络
     */
    public static final int NETWORK_MOBILE = 0;
    /**
     * 无线网络
     */
    public static final int NETWORK_WIFI = 1;

    public static int getNetWorkState(Context context) {
        // 得到连接管理器对象
        ConnectivityManager connectivityManager = (ConnectivityManager) context
                .getSystemService(Context.CONNECTIVITY_SERVICE);

        NetworkInfo activeNetworkInfo = connectivityManager
                .getActiveNetworkInfo();
        if (activeNetworkInfo != null && activeNetworkInfo.isConnected()) {

            if (activeNetworkInfo.getType() == (ConnectivityManager.TYPE_WIFI)) {
                return NETWORK_WIFI;
            } else if (activeNetworkInfo.getType() == (ConnectivityManager.TYPE_MOBILE)) {
                return NETWORK_MOBILE;
            }
        } else {
            return NETWORK_NONE;
        }
        return NETWORK_NONE;
    }

    /** 判断手机是否连接网络 */
    public static boolean isNetWorking() {
        ConnectivityManager cwjManager = (ConnectivityManager) BaseApplication.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
        if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.M) {
            Network activeNetwork = cwjManager.getActiveNetwork();
            if (activeNetwork == null){
                return false;
            }
            NetworkCapabilities networkCapabilities =
                    cwjManager.getNetworkCapabilities(activeNetwork);
            if (networkCapabilities != null) {
                return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
            }
        }
        //[type: WIFI[], state: CONNECTED/CONNECTED, reason: (unspecified), extra: , failover: false, available: true, roaming: false]
        //info.isRoaming()  是否漫游
        NetworkInfo info = cwjManager.getActiveNetworkInfo();
        return info != null && info.isAvailable();
    }

    /**
     * 判断wifi 是否可用
     * @param context
     * @return
     * @throws Exception
     */
    public static boolean isWifiDataEnable(Context context){
        ConnectivityManager manager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        boolean isWifiDataEnable = false;
        isWifiDataEnable = manager.getNetworkInfo(ConnectivityManager.TYPE_WIFI).isConnectedOrConnecting();
        return isWifiDataEnable;
    }

    /**
     * 当前网络类型是否是wifi
     *
     * @return
     */
    public static boolean isWifi() {
        ConnectivityManager connectivityManager = (ConnectivityManager) BaseApplication.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = connectivityManager.getActiveNetworkInfo();
        return info != null && info.getType() == ConnectivityManager.TYPE_WIFI;
    }

    public static boolean is4G(){
        ConnectivityManager connectivityManager = (ConnectivityManager) BaseApplication.getContext().getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo info = connectivityManager.getActiveNetworkInfo();
        return info != null && info.getType() == ConnectivityManager.TYPE_MOBILE;

    }



    @SuppressLint("MissingPermission")
    public static int getNetWorkStateNew(Context context) {
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo mobileNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            NetworkInfo wifiNetInfo = connectivityManager.getNetworkInfo(ConnectivityManager.TYPE_WIFI);
            if (mobileNetInfo != null && mobileNetInfo.isAvailable()) {
                //手机
                return NETWORK_MOBILE;
            } else if (wifiNetInfo != null && wifiNetInfo.isAvailable()) {
                //WIFI
                return NETWORK_WIFI;
            } else {
                //WIFI和移动网络均未连接
                return NETWORK_NONE;
            }
        } else {
            if (isMobileConnected(context)) {
                return NETWORK_MOBILE;
            } else if (isWifiConnected(context)) {
                return NETWORK_WIFI;
            } else {
                return NETWORK_NONE;
            }
        }

//            //获取所有网络连接的信息
//            Network[] networks = connMgr.getAllNetworks();
//            //通过循环将网络信息逐个取出来
//            for (int i = 0; i < networks.length; i++) {
//                //获取ConnectivityManager对象对应的NetworkInfo对象
//                NetworkInfo networkInfo = connMgr.getNetworkInfo(networks[i]);
//                if (networkInfo.isConnected()) {
//                    if (networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
//                        return NetwordStatus.WIFI;
//                    } else if (networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
//                        return NetwordStatus.MOBILE;
//                    }
//                }
//            }
    }

    /**
     * 判断网络是否连接
     *
     * @param context
     * @return
     */
//    @SuppressLint("MissingPermission")
//    public static boolean isOnline(Context context) {
//        if (context == null) {
//            return false;
//        }
//        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
//            ConnectivityManager connMgr = (ConnectivityManager)
//                    context.getSystemService(Context.CONNECTIVITY_SERVICE);
//            NetworkInfo networkInfo = connMgr.getActiveNetworkInfo();
//            return (networkInfo != null && networkInfo.isAvailable());
//        } else {
//            ConnectivityManager connectivityManager = (ConnectivityManager) context
//                    .getSystemService(Context.CONNECTIVITY_SERVICE);
//            Network activeNetwork = connectivityManager.getActiveNetwork();
//            if (activeNetwork == null) {
//                return false;
//            }
//            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork);
//            if (networkCapabilities != null) {
//                return networkCapabilities.hasCapability(NetworkCapabilities.NET_CAPABILITY_VALIDATED);
//            }
//        }
//        return false;
//    }

    @SuppressLint("MissingPermission")
    public static boolean isWifiConnected(Context context) {
        if (context == null) {
            return false;
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectivityManager
                    .getNetworkInfo(ConnectivityManager.TYPE_WIFI);
            if (networkInfo != null) {
                return networkInfo.isAvailable();
            }
        } else {
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            Network activeNetwork = connectivityManager.getActiveNetwork();
            if (activeNetwork == null) {
                return false;
            }
            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork);
            if (networkCapabilities != null) {
                return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
            }
        }
        return false;
    }

    @SuppressLint("MissingPermission")
    public static boolean isMobileConnected(Context context) {
        if (context == null) {
            return false;
        }
        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.M) {
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            NetworkInfo networkInfo = connectivityManager
                    .getNetworkInfo(ConnectivityManager.TYPE_MOBILE);
            if (networkInfo != null) {
                return networkInfo.isAvailable();
            }
        } else {
            ConnectivityManager connectivityManager = (ConnectivityManager) context
                    .getSystemService(Context.CONNECTIVITY_SERVICE);
            Network activeNetwork = connectivityManager.getActiveNetwork();
            if (activeNetwork == null) {
                return false;
            }
            NetworkCapabilities networkCapabilities = connectivityManager.getNetworkCapabilities(activeNetwork);
            if (networkCapabilities != null) {
                return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_CELLULAR);
            }
        }
        return false;
    }
}






















package com.tal.jxtteacher.http;

import android.content.Context;
import android.content.Intent;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.os.Build;
import android.telephony.TelephonyManager;

public class NetWorkUtil {


    /**
     * 网络连接是否可用
     */
    public static boolean isNetworkAvailable(Context ctx) {
        ConnectivityManager connectivity = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (connectivity == null) {
            return false;
        } else {
            NetworkInfo[] info = connectivity.getAllNetworkInfo();
            if (info != null) {
                for (int i = 0; i < info.length; i++) {
                    if (info[i].getState() == NetworkInfo.State.CONNECTED || info[i].getState() == NetworkInfo.State.CONNECTING) {
                        return true;
                    }
                }
            }
        }
        return false;
    }


    /**
     * 检查网络类型
     *
     * @return
     */
    public static boolean checkNetworkType(Context ctx) {
        ConnectivityManager cm = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
            return false;
        }
        NetworkInfo.State mobile = cm.getNetworkInfo(ConnectivityManager.TYPE_MOBILE).getState();
        NetworkInfo.State wifi = cm.getNetworkInfo(ConnectivityManager.TYPE_WIFI).getState();

        if (mobile == NetworkInfo.State.CONNECTED || mobile == NetworkInfo.State.CONNECTING) {
            System.out.println("手机网络");
            return true;
        }
        if (wifi == NetworkInfo.State.CONNECTED || wifi == NetworkInfo.State.CONNECTING) {
            System.out.println("WIFI");
            return true;
        }
        return false;
    }

    /**
     * 手机网络
     */
    public static boolean isMobileNetwork(Context ctx) {
        ConnectivityManager cm = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
            return false;
        }
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_MOBILE) {
            return true;
        }
        return false;
    }

    /**
     * wifi网络
     */
    public static boolean isWifiNetwork(Context ctx) {
        ConnectivityManager cm = (ConnectivityManager) ctx.getSystemService(Context.CONNECTIVITY_SERVICE);
        if (cm == null) {
            return false;
        }
        NetworkInfo networkInfo = cm.getActiveNetworkInfo();
        if (networkInfo != null && networkInfo.getType() == ConnectivityManager.TYPE_WIFI) {
            return true;
        }
        return false;
    }

    /**
     * 跳转去网络设置页面
     */
    public static void startNetworkSettingActivity(Context ctx) {
        Intent intent = new Intent();
        int sdkVersion = Build.VERSION.SDK_INT;
        if (sdkVersion >= 14) {
            intent = new Intent(android.provider.Settings.ACTION_SETTINGS);
        } else {
            // android4.0系统找不到此Activity
            intent.setClassName("com.android.settings", "com.android.settings.WirelessSettings");
        }
        intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
        ctx.startActivity(intent);
    }


    /**
     * 检测当前打开的网络类型是否WIFI
     *
     * @param context 上下文
     * @return 是否是Wifi上网
     */
    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;
    }

    /**
     * 是否有网
     */
    public static boolean isConnected(Context context) {
        return netSatus(context) != NetState.NET_NO;
    }

    /**
     * 枚举网络状态 NET_NO：没有网络 NET_2G:2g网络 NET_3G：3g网络 NET_4G：4g网络 NET_WIFI：wifi
     * NET_UNKNOWN：未知网络
     */
    public static enum NetState {
        NET_NO, NET_2G, NET_3G, NET_4G, NET_WIFI, NET_UNKNOWN
    }

    /**
     * 判断当前是否网络连接
     *
     * @param context 上下文
     * @return 状态码
     */
    public static NetState netSatus(Context context) {
        NetState stateCode = NetState.NET_NO;
        ConnectivityManager cm = (ConnectivityManager) context.getSystemService(Context.CONNECTIVITY_SERVICE);
        NetworkInfo ni = cm.getActiveNetworkInfo();
        if (ni != null && ni.isConnectedOrConnecting()) {
            switch (ni.getType()) {
                case ConnectivityManager.TYPE_WIFI:
                    stateCode = NetState.NET_WIFI;
                    break;
                case ConnectivityManager.TYPE_MOBILE:
                    switch (ni.getSubtype()) {
                        case TelephonyManager.NETWORK_TYPE_GPRS: // 联通2g
                        case TelephonyManager.NETWORK_TYPE_CDMA: // 电信2g
                        case TelephonyManager.NETWORK_TYPE_EDGE: // 移动2g
                        case TelephonyManager.NETWORK_TYPE_1xRTT:
                        case TelephonyManager.NETWORK_TYPE_IDEN:
                            stateCode = NetState.NET_2G;
                            break;
                        case TelephonyManager.NETWORK_TYPE_EVDO_A: // 电信3g
                        case TelephonyManager.NETWORK_TYPE_UMTS:
                        case TelephonyManager.NETWORK_TYPE_EVDO_0:
                        case TelephonyManager.NETWORK_TYPE_HSDPA:
                        case TelephonyManager.NETWORK_TYPE_HSUPA:
                        case TelephonyManager.NETWORK_TYPE_HSPA:
                        case TelephonyManager.NETWORK_TYPE_EVDO_B:
                        case TelephonyManager.NETWORK_TYPE_EHRPD:
                        case TelephonyManager.NETWORK_TYPE_HSPAP:
                            stateCode = NetState.NET_3G;
                            break;
                        case TelephonyManager.NETWORK_TYPE_LTE:
                            stateCode = NetState.NET_4G;
                            break;
                        default:
                            stateCode = NetState.NET_UNKNOWN;
                    }
                    break;
                default:
                    stateCode = NetState.NET_UNKNOWN;
            }

        }
        return stateCode;
    }

}

时光仍在是我们飞逝
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 1
    评论
Android-通过制作HttpUtil工具类来便于进行Http通信
chitoseyono的博客
04-23 3385
个人是在看郭神的第一行代码时知道的可以自己做一个HttpUtil类来方便Http的通信，只需要直接用工具类里的方法进行获得Response即可了。 这里写出我自己在制作HttpUtil类时用到的不同的方法（布局的话都是一个EditText，一个按钮一个文本框，没什么特别的就不贴出来了），本文偏向于使用AsyncTask进行异步调用，先放一下效果吧。 这里也因为速度太快了ProgressBa...
Android 网络工具类NetworkUtils使用
dhl_1986的博客
12-13 5402
NetworkUtils工具类里封装了以下方法： openWirelessSettings : 打开网络设置界面 isConnected : 判断网络是否连接 isAvailableByPing : 判断网络是否可用 getDataEnabled : 判断移动数据是否打开 setDataEnabled : 打开或关闭移动数据 i
Android 获取网络连接状态新方法
u012514113的专栏
08-03 7021
Android12上，有的app模块判断当前网络的类型和连接状态时，还是使用的旧的API，导致返回的结果不准确，影响代码逻辑判断，本篇文章就这一问题，整理一下判断网络类型和连接状态的新方法。
Android封装的http请求实用工具类
01-05
代码如下:import java.io.BufferedReader;import java.io.InputStreamReader;import java.net.URLEncoder;import java.security.KeyStore;import java.util.Iterator;import java.util.List;import java.util.Map;import java.util.Map.Entry; import org.apache.http.HttpResponse;import org.apache.http.HttpVersion;import
Android打造一个通用的网络请求引擎HttpUtils
jsonnan的博客
05-30 2263
打造一个通用的网络请求引擎HttpUtils 为什么要打造这个引擎 Xutils的引擎 Okhttp的引擎 使用 为什么要打造这个引擎 自Android 6.0之后，HttpClient被废，好多APP是不是出现蛋疼的事，赶紧换掉网络请求框架。兼容6.0版本。但是想换网络请求不是一件容易的事。你会发现有多好地方调用了此网络请求。想彻底换掉得折腾一番。再者，好多时候。因为网上的网络框架很多。xut
HttpUtils.zip
04-07
`HttpUtils.zip`文件提供了一种便捷的方式来使用这两种工具，旨在简化开发过程，提升开发效率。下面我们将详细探讨HttpClient、OkHttp以及HttpUtils的相关知识点。 1. **HttpClient**：HttpClient是Apache基金会...
HttpUtils.java
05-18
接口访问
XUtils-HttpUtils
09-18
HttpUtils httpUtils = new HttpUtils(); ``` 3. **发送GET请求**：要发送GET请求，调用`send`方法并传入请求URL和回调。 ```java httpUtils.send(HttpMethod.GET, "http://example.com", new HttpCallback() { @...
HttpUtils
04-18
HttpUtils
android的httpUtils
weixin_34221276的博客
07-08 74
一个android的httpUtils类 package com.kblw.client04.http; import java.io.ByteArrayOutputStream; import java.io.IOException; import java.io.InputStream; import java.net.HttpURLConnection; import j...
Android-实时监测网络状态及当前网络类型
08-13
实时监测网络状态及当前网络类型，NetworkUtils工具类中提供了检测网络状态的方法
Android网络工具类NetworkUtils详解
08-27
主要为大家详细介绍了Android网络工具类NetworkUtils，具有一定的参考价值，感兴趣的小伙伴们可以参考一下
使用HTTP协议访问网络（Android）
cnmeimei的博客
10-02 373
在做项目的过程中需要连接服务器访问数据，还没有接触过Android网络编程方面，参考了《Android第一行代码》，在做的过程中遇到了很多的问题，这里就此记录一下。 先给出访问网络的代码： 首先：在AndroidManifest.xml文件中进行声明，添加如下代码： <uses-permission android:name="android.permission.INTERNET" /> 编写网络操作类： public class HttpUtil...
android Xutils Http模块分析
H291850336的专栏
01-26 8647
XUtils下载地址 http://www.oschina.net/p/xutils 官方介绍： xUtils 包含了很多实用的android工具.xUtils 支持超大文件(超过2G)上传，更全面的http请求协议支持(11种谓词)，拥有更加灵活的ORM，更多的事件注解支持且不受混淆影响...xUtils 最低兼容Android 4.0 (api level 14). (An
Wiki_Android_网络工具类NetworkUtils
GitHubClub
09-19 1039
网络工具类NetworkUtils 提供的方法： 打开网络设置界面 openWirelessSettings 判断网络是否可用 isAvailable 判断网络是否连接 isConnected 判断网络是否是4G is4G 判断wifi是否连接状态 isWifiConnected 获取移动网络运营商名称 getNetworkOperatorName 获取移动终端类型 getPhon
Android中好用的请求httputils工具类
劝酒曲的博客
12-04 633
public class HttpUtils { private static String TAG = "HttpUtils"; private static OkHttpClient mHttpClient; private static ApiService apiService; private static HttpUtils httpUtils; ...
Android的HttpUtils的网络请求OkHttp
Logitech12的博客
11-03 355
package com.bw.utils; import android.content.Context; import android.widget.Toast; import java.util.Map; import okhttp3.Callback; import okhttp3.FormBody; import okhttp3.OkHttpClient; import okhttp
安卓okhttpUtils下载文件(安装包)并打开(安装)实例
Sol的博客
02-03 2958
okhttpUtils是okhttp的一个工具包，首先在app的build.gradle中添加以下内容： implementation 'com.squareup.okhttp3:okhttp:4.3.0' implementation 'com.squareup.okio:okio:2.4.3' implementation 'com.zhy:okhttputils:2....
展开说说：Android之View基础知识解析
最新发布
Hidanchaofan的博客
07-13 895
View虽不属于Android四代组件，但应用程度却非常非常广泛。在Android客户端，君所见之处皆是View。我们看到的Button、ImageView、TextView等等可视化的控件都是View，ViewGroup是View的子类因此它也是View。但是现在我们把View和ViewGroup当成两个类来看待，ViewGroup可以容纳View和ViewGroup，但View不可以再容纳其他View或ViewGroup，这种容纳的关系可以一直延伸仿佛一棵大树，从内而外有了父子关系，因此有个概念叫做Vi
httpUtils代码
06-03
JnHttpUtils httpUtils = new JnHttpUtils(); // 发送GET请求 String url = "http://www.example.com/api/data"; httpUtils.get(url, new JnHttpCallback() { @Override public void onSuccess(String response) ...

“相关推荐”对你有帮助么？

  • 非常没帮助
  • 没帮助
  • 一般
  • 有帮助
  • 非常有帮助
提交
评论 1
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值