package com.hdl.photovoltaic.utils;
|
|
import static android.Manifest.permission.ACCESS_NETWORK_STATE;
|
|
import android.content.BroadcastReceiver;
|
import android.content.Context;
|
import android.content.Intent;
|
import android.content.IntentFilter;
|
import android.net.ConnectivityManager;
|
import android.net.Network;
|
import android.net.NetworkInfo;
|
import android.net.NetworkRequest;
|
import android.net.wifi.WifiInfo;
|
import android.net.wifi.WifiManager;
|
import android.os.Build;
|
import android.telephony.TelephonyManager;
|
|
import androidx.annotation.RequiresApi;
|
import androidx.annotation.RequiresPermission;
|
|
import com.hdl.photovoltaic.HDLApp;
|
|
import java.lang.ref.WeakReference;
|
import java.net.Inet4Address;
|
import java.net.InetAddress;
|
import java.net.NetworkInterface;
|
import java.net.SocketException;
|
import java.util.Enumeration;
|
import java.util.HashSet;
|
import java.util.Set;
|
import java.util.concurrent.Executors;
|
|
/**
|
* Created by Tong on 2022/7/13.
|
*/
|
public class NetworkUtils {
|
|
|
public enum NetworkType {
|
NETWORK_ETHERNET,
|
NETWORK_WIFI,
|
NETWORK_5G,
|
NETWORK_4G,
|
NETWORK_3G,
|
NETWORK_2G,
|
NETWORK_UNKNOWN,
|
NETWORK_NO
|
}
|
|
public interface OnNetworkStatusChangedListener {
|
void onDisconnected();
|
|
void onConnected(NetworkType networkType);
|
}
|
|
public static void init(Context context) {
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
NetworkCallbackImpl.getInstance().init(context);
|
} else {
|
NetworkChangedReceiver.getInstance().init(context);
|
}
|
}
|
|
|
public static void registerNetworkStatusChangedListener(final OnNetworkStatusChangedListener listener) {
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
NetworkCallbackImpl.getInstance().registerListener(listener);
|
} else {
|
NetworkChangedReceiver.getInstance().registerListener(listener);
|
}
|
|
|
}
|
|
public static void unregisterListener(final OnNetworkStatusChangedListener listener) {
|
|
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
|
NetworkCallbackImpl.getInstance().unregisterListener(listener);
|
} else {
|
NetworkChangedReceiver.getInstance().unregisterListener(listener);
|
}
|
}
|
|
public static final class NetworkChangedReceiver extends BroadcastReceiver {
|
|
private WeakReference<Context> mContext;
|
|
private NetworkChangedReceiver() {
|
}
|
|
private static class SingletonInstance {
|
private static final NetworkChangedReceiver INSTANCE = new NetworkChangedReceiver();
|
}
|
|
public static NetworkChangedReceiver getInstance() {
|
return SingletonInstance.INSTANCE;
|
}
|
|
private NetworkType mType;
|
private final Set<OnNetworkStatusChangedListener> mListeners = new HashSet<>();
|
|
public void init(Context context) {
|
if (mContext == null) {
|
getInstance().mContext = new WeakReference<>(context.getApplicationContext());
|
}
|
}
|
|
@RequiresPermission(ACCESS_NETWORK_STATE)
|
public void registerListener(final OnNetworkStatusChangedListener listener) {
|
if (listener == null) return;
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
int preSize = mListeners.size();
|
mListeners.add(listener);
|
if (preSize == 0 && mListeners.size() == 1 && null != mContext.get()) {
|
mType = getNetworkType();
|
IntentFilter intentFilter = new IntentFilter(ConnectivityManager.CONNECTIVITY_ACTION);
|
mContext.get().registerReceiver(NetworkChangedReceiver.getInstance(), intentFilter);
|
}
|
|
}
|
});
|
|
}
|
|
public boolean isRegistered(final OnNetworkStatusChangedListener listener) {
|
if (listener == null) return false;
|
return mListeners.contains(listener);
|
}
|
|
public void unregisterListener(final OnNetworkStatusChangedListener listener) {
|
if (listener == null) return;
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
int preSize = mListeners.size();
|
mListeners.remove(listener);
|
if (preSize == 1 && mListeners.size() == 0 && mContext.get() != null) {
|
mContext.get().unregisterReceiver(NetworkChangedReceiver.getInstance());
|
}
|
}
|
});
|
}
|
|
@Override
|
public void onReceive(Context context, Intent intent) {
|
if (ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) {
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
NetworkType networkType = NetworkUtils.getNetworkType();
|
if (mType == networkType) return;
|
mType = networkType;
|
if (networkType == NetworkType.NETWORK_NO) {
|
for (OnNetworkStatusChangedListener listener : mListeners) {
|
listener.onDisconnected();
|
}
|
} else {
|
for (OnNetworkStatusChangedListener listener : mListeners) {
|
listener.onConnected(networkType);
|
}
|
}
|
}
|
});
|
}
|
}
|
|
|
}
|
|
@RequiresPermission(ACCESS_NETWORK_STATE)
|
private static boolean isEthernet() {
|
final ConnectivityManager cm =
|
(ConnectivityManager) HDLApp.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
|
if (cm == null) return false;
|
final NetworkInfo info = cm.getNetworkInfo(ConnectivityManager.TYPE_ETHERNET);
|
if (info == null) return false;
|
NetworkInfo.State state = info.getState();
|
if (null == state) return false;
|
return state == NetworkInfo.State.CONNECTED || state == NetworkInfo.State.CONNECTING;
|
}
|
|
@RequiresPermission(ACCESS_NETWORK_STATE)
|
public static NetworkType getNetworkType() {
|
if (isEthernet()) {
|
return NetworkType.NETWORK_ETHERNET;
|
}
|
NetworkInfo info = getActiveNetworkInfo();
|
if (info != null && info.isAvailable()) {
|
if (info.getType() == ConnectivityManager.TYPE_WIFI) {
|
return NetworkType.NETWORK_WIFI;
|
} else if (info.getType() == ConnectivityManager.TYPE_MOBILE) {
|
switch (info.getSubtype()) {
|
case TelephonyManager.NETWORK_TYPE_GSM:
|
case TelephonyManager.NETWORK_TYPE_GPRS:
|
case TelephonyManager.NETWORK_TYPE_CDMA:
|
case TelephonyManager.NETWORK_TYPE_EDGE:
|
case TelephonyManager.NETWORK_TYPE_1xRTT:
|
case TelephonyManager.NETWORK_TYPE_IDEN:
|
return NetworkType.NETWORK_2G;
|
|
case TelephonyManager.NETWORK_TYPE_TD_SCDMA:
|
case TelephonyManager.NETWORK_TYPE_EVDO_A:
|
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:
|
return NetworkType.NETWORK_3G;
|
|
case TelephonyManager.NETWORK_TYPE_IWLAN:
|
case TelephonyManager.NETWORK_TYPE_LTE:
|
return NetworkType.NETWORK_4G;
|
case 20:
|
return NetworkType.NETWORK_5G;
|
default:
|
String subtypeName = info.getSubtypeName();
|
if (subtypeName.equalsIgnoreCase("TD-SCDMA")
|
|| subtypeName.equalsIgnoreCase("WCDMA")
|
|| subtypeName.equalsIgnoreCase("CDMA2000")) {
|
return NetworkType.NETWORK_3G;
|
} else {
|
return NetworkType.NETWORK_UNKNOWN;
|
}
|
}
|
} else {
|
return NetworkType.NETWORK_UNKNOWN;
|
}
|
}
|
return NetworkType.NETWORK_NO;
|
}
|
|
|
@RequiresPermission(ACCESS_NETWORK_STATE)
|
private static NetworkInfo getActiveNetworkInfo() {
|
ConnectivityManager cm =
|
(ConnectivityManager) HDLApp.getInstance().getSystemService(Context.CONNECTIVITY_SERVICE);
|
if (cm == null) return null;
|
return cm.getActiveNetworkInfo();
|
}
|
|
/**
|
* 获得IP地址，分为两种情况:
|
* 一：是wifi下；
|
* 二：是移动网络下；
|
*/
|
public static String getIPAddress(Context context) {
|
NetworkInfo info = ((ConnectivityManager) context
|
.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
|
if (info != null && info.isConnected()) {
|
if (info.getType() == ConnectivityManager.TYPE_MOBILE) {//当前使用2G/3G/4G网络
|
try {
|
//Enumeration<NetworkInterface> en=NetworkInterface.getNetworkInterfaces();
|
for (Enumeration<NetworkInterface> en = NetworkInterface.getNetworkInterfaces(); en.hasMoreElements(); ) {
|
NetworkInterface intf = en.nextElement();
|
for (Enumeration<InetAddress> enumIpAddr = intf.getInetAddresses(); enumIpAddr.hasMoreElements(); ) {
|
InetAddress inetAddress = enumIpAddr.nextElement();
|
if (!inetAddress.isLoopbackAddress() && inetAddress instanceof Inet4Address) {
|
return inetAddress.getHostAddress();
|
}
|
}
|
}
|
} catch (SocketException e) {
|
e.printStackTrace();
|
}
|
} else if (info.getType() == ConnectivityManager.TYPE_WIFI) {//当前使用无线网络
|
WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
|
WifiInfo wifiInfo = wifiManager.getConnectionInfo();
|
//调用方法将int转换为地址字符串
|
String ipAddress = intIP2StringIP(wifiInfo.getIpAddress());//得到IPV4地址
|
return ipAddress;
|
}
|
} else {
|
//当前无网络连接,请在设置中打开网络
|
}
|
return null;
|
}
|
|
/**
|
* 将得到的int类型的IP转换为String类型
|
*
|
* @param ip int类型
|
* @return -
|
*/
|
public static String intIP2StringIP(int ip) {
|
return (ip & 0xFF) + "." +
|
((ip >> 8) & 0xFF) + "." +
|
((ip >> 16) & 0xFF) + "." +
|
(ip >> 24 & 0xFF);
|
}
|
|
|
@RequiresApi(api = Build.VERSION_CODES.LOLLIPOP)
|
private static class NetworkCallbackImpl extends ConnectivityManager.NetworkCallback {
|
|
|
private final Set<OnNetworkStatusChangedListener> mListeners = new HashSet<>();
|
private ConnectivityManager mConnectivityManager;
|
|
private WeakReference<Context> mContext;
|
|
public NetworkCallbackImpl() {
|
}
|
|
private static class SingletonInstance {
|
private static final NetworkCallbackImpl INSTANCE = new NetworkCallbackImpl();
|
}
|
|
public static NetworkCallbackImpl getInstance() {
|
return SingletonInstance.INSTANCE;
|
}
|
|
|
public void init(Context context) {
|
if (mContext == null) {
|
getInstance().mContext = new WeakReference<>(context.getApplicationContext());
|
}
|
}
|
|
|
@RequiresPermission(ACCESS_NETWORK_STATE)
|
public void registerListener(final OnNetworkStatusChangedListener listener) {
|
if (listener == null || mContext == null || mContext.get() == null) return;
|
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
|
@Override
|
public void run() {
|
if (mContext.get() == null) return;
|
int preSize = mListeners.size();
|
mListeners.add(listener);
|
if (preSize == 0 && mListeners.size() == 1) {
|
NetworkRequest.Builder builder = new NetworkRequest.Builder();
|
NetworkRequest request = builder.build();
|
mConnectivityManager = (ConnectivityManager) mContext.get().getSystemService(Context.CONNECTIVITY_SERVICE);
|
mConnectivityManager.requestNetwork(request, getInstance());
|
}
|
|
}
|
});
|
|
}
|
|
|
public void unregisterListener(final OnNetworkStatusChangedListener listener) {
|
if (listener == null) return;
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
int preSize = mListeners.size();
|
mListeners.remove(listener);
|
if (preSize == 1 && mListeners.size() == 0 && mConnectivityManager != null) {
|
mConnectivityManager.unregisterNetworkCallback(getInstance());
|
}
|
}
|
});
|
}
|
|
@Override
|
public void onAvailable(Network network) {
|
super.onAvailable(network);
|
|
//网络连接
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
NetworkInfo networkInfo = mConnectivityManager.getNetworkInfo(network);
|
if (networkInfo != null) {
|
NetworkType networkType = getNetworkType();
|
for (OnNetworkStatusChangedListener listener : mListeners) {
|
listener.onConnected(networkType);
|
}
|
}
|
|
}
|
});
|
|
}
|
|
@Override
|
public void onLost(Network network) {
|
super.onLost(network);
|
//网络已断开
|
Executors.newSingleThreadExecutor().execute(new Runnable() {
|
@Override
|
public void run() {
|
for (OnNetworkStatusChangedListener listener : mListeners) {
|
listener.onDisconnected();
|
}
|
}
|
});
|
}
|
|
|
}
|
|
|
}
|
