From 51d7007fd4bcaaa771d43a745cb6728d4e6d29ae Mon Sep 17 00:00:00 2001
From: mac <user@users-MacBook-Pro.local>
Date: 星期五, 05 一月 2024 18:04:41 +0800
Subject: [PATCH] 2024年01月05日18:04:39
---
app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java | 381 ++++++++++++++++++++++++++++++++++++++++++++++--------
1 files changed, 322 insertions(+), 59 deletions(-)
diff --git a/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java b/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java
index 73d32cd..5e5b85a 100644
--- a/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java
+++ b/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java
@@ -1,83 +1,346 @@
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.wifi.WifiInfo;
-import android.net.wifi.WifiManager;
+import android.net.NetworkRequest;
+import android.os.Build;
+import android.telephony.TelephonyManager;
-import java.net.Inet4Address;
-import java.net.InetAddress;
-import java.net.NetworkInterface;
-import java.net.SocketException;
-import java.util.Enumeration;
+import androidx.annotation.RequiresApi;
+import androidx.annotation.RequiresPermission;
+import com.hdl.photovoltaic.HDLApp;
+import java.lang.ref.WeakReference;
+import java.util.HashSet;
+import java.util.Set;
+import java.util.concurrent.Executors;
+
+/**
+ * Created by Tong on 2022/7/13.
+ */
public class NetworkUtils {
- private static NetworkUtils mNetworkUtils;
-
- public static NetworkUtils getInstance() {
- if (null == mNetworkUtils) {
- synchronized (NetworkUtils.class) {
- if (null == mNetworkUtils) {
- mNetworkUtils = new NetworkUtils();
- }
- }
- }
- return mNetworkUtils;
+ public enum NetworkType {
+ NETWORK_ETHERNET,
+ NETWORK_WIFI,
+ NETWORK_5G,
+ NETWORK_4G,
+ NETWORK_3G,
+ NETWORK_2G,
+ NETWORK_UNKNOWN,
+ NETWORK_NO
}
- /**
- * 鑾峰緱IP鍦板潃锛屽垎涓轰袱绉嶆儏鍐�:
- * 涓�锛氭槸wifi涓嬶紱
- * 浜岋細鏄Щ鍔ㄧ綉缁滀笅锛�
- */
- public 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();
+ 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);
}
}
}
- } catch (SocketException e) {
- e.printStackTrace();
- }
- } else if (info.getType() == ConnectivityManager.TYPE_WIFI) {//褰撳墠浣跨敤鏃犵嚎缃戠粶
- WifiManager wifiManager = (WifiManager) context.getSystemService(Context.WIFI_SERVICE);
- WifiInfo wifiInfo = wifiManager.getConnectionInfo();
- //璋冪敤鏂规硶灏唅nt杞崲涓哄湴鍧�瀛楃涓�
- String ipAddress = intIP2StringIP(wifiInfo.getIpAddress());//寰楀埌IPV4鍦板潃
- return ipAddress;
+ });
}
- } else {
- //褰撳墠鏃犵綉缁滆繛鎺�,璇峰湪璁剧疆涓墦寮�缃戠粶
}
- return null;
+
+
}
- /**
- * 灏嗗緱鍒扮殑int绫诲瀷鐨処P杞崲涓篠tring绫诲瀷
- *
- * @param ip int绫诲瀷
- * @return -
- */
- public static String intIP2StringIP(int ip) {
- return (ip & 0xFF) + "." +
- ((ip >> 8) & 0xFF) + "." +
- ((ip >> 16) & 0xFF) + "." +
- (ip >> 24 & 0xFF);
+ @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();
+ }
+
+
+ @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();
+ }
+ }
+ });
+ }
+
+
}
}
+
--
Gitblit v1.8.0