From 87cd5df70918e6ba1af849c5f026d3719bfdb1ac Mon Sep 17 00:00:00 2001
From: wjc <1243177876@qq.com>
Date: 星期三, 09 四月 2025 09:06:29 +0800
Subject: [PATCH] Merge branch '1.5.2' into dev
---
app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java | 342 +++++++++++++++++++++++++++++++++++++++++++++++++++++++-
1 files changed, 332 insertions(+), 10 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 ea5a2f4..e640fc2 100644
--- a/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java
+++ b/app/src/main/java/com/hdl/photovoltaic/utils/NetworkUtils.java
@@ -1,32 +1,246 @@
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 {
- private static NetworkUtils mNetworkUtils;
+
+ 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 NetworkUtils getInstance() {
- if (null == mNetworkUtils) {
- synchronized (NetworkUtils.class) {
- if (null == mNetworkUtils) {
- mNetworkUtils = new NetworkUtils();
- }
+ 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());
}
}
- return mNetworkUtils;
+
+ @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();
}
/**
@@ -34,7 +248,7 @@
* 涓�锛氭槸wifi涓嬶紱
* 浜岋細鏄Щ鍔ㄧ綉缁滀笅锛�
*/
- public String getIPAddress(Context context) {
+ public static String getIPAddress(Context context) {
NetworkInfo info = ((ConnectivityManager) context
.getSystemService(Context.CONNECTIVITY_SERVICE)).getActiveNetworkInfo();
if (info != null && info.isConnected()) {
@@ -78,4 +292,112 @@
((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();
+ }
+ }
+ });
+ }
+
+
+ }
+
+
}
+
--
Gitblit v1.8.0