package com.huawei.hms.framework.common;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.LinkProperties;
import android.net.Network;
import android.net.NetworkInfo;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.os.Build;
import android.os.UserManager;
import android.telephony.CellSignalStrengthLte;
import android.telephony.HwTelephonyManager;
import android.telephony.ServiceState;
import android.telephony.SignalStrength;
import android.telephony.SubscriptionManager;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import com.huawei.android.os.BuildEx;
import com.huawei.android.telephony.ServiceStateEx;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.InetAddress;
import java.net.URI;
import java.net.URISyntaxException;
import java.net.UnknownHostException;
import java.security.AccessController;
import java.security.PrivilegedAction;
import java.util.Arrays;
import java.util.LinkedList;
import java.util.List;
public class NetworkUtil {
private static final int INVALID_RSSI = -127;
private static final String STR_NSA = "5G_NSA";
private static final String STR_SA = "5G_SA";
private static final String TAG = NetworkUtil.class.getSimpleName();
private static final int TYPE_WIFI_P2P = 13;
public static final class NetType {
public static final int TYPE_2G = 2;
public static final int TYPE_3G = 3;
public static final int TYPE_4G = 4;
public static final int TYPE_4G_NSA = 7;
public static final int TYPE_5G = 5;
public static final int TYPE_5G_SA = 8;
public static final int TYPE_MOBILE = 6;
public static final int TYPE_NO_NETWORK = -1;
public static final int TYPE_UNKNOWN = 0;
public static final int TYPE_WIFI = 1;
}
private static int groupNetworkType(int i) {
if (i == -1) {
return -1;
}
if (i != 1) {
return (i == 2 || i == 3 || i == 4 || i == 5) ? 6 : 0;
}
return 1;
}
public static NetworkInfo getNetworkInfo(Context context) {
ConnectivityManager connectivityManager;
if (!ContextCompat.checkSelfPermission(context, "android.permission.ACCESS_NETWORK_STATE") || (connectivityManager = (ConnectivityManager) ContextCompat.getSystemService(context, "connectivity")) == null) {
return null;
}
try {
return connectivityManager.getActiveNetworkInfo();
} catch (RuntimeException e) {
String str = TAG;
Logger.i(str, "getActiveNetworkInfo failed, exception:" + e.getClass().getSimpleName() + e.getMessage());
return null;
}
}
public static boolean isNetworkAvailable(Context context) {
if (!ContextCompat.checkSelfPermission(context, "android.permission.ACCESS_NETWORK_STATE")) {
return true;
}
NetworkInfo networkInfo = getNetworkInfo(context);
if (networkInfo == null || !networkInfo.isConnected()) {
return false;
}
return true;
}
public static int netWork(Context context) {
int networkType = getNetworkType(context);
String str = TAG;
Logger.v(str, "newWorkType " + networkType);
if (networkType == 4) {
if (TextUtils.equals(STR_NSA, getNetWorkNSAorSA())) {
return 7;
}
return networkType;
} else if (networkType != 5 || !TextUtils.equals(STR_SA, getNetWorkNSAorSA())) {
return networkType;
} else {
return 8;
}
}
public static String getNetWorkNSAorSA() {
try {
HwTelephonyManager hwTelephonyManager = HwTelephonyManager.getDefault();
int default4GSlotId = hwTelephonyManager.getDefault4GSlotId();
String str = TAG;
Logger.v(str, "phoneId " + default4GSlotId);
boolean isNsaState = hwTelephonyManager.isNsaState(default4GSlotId);
String str2 = TAG;
Logger.v(str2, "isNsa " + isNsaState);
return isNsaState ? STR_NSA : STR_SA;
} catch (Throwable unused) {
Logger.v(TAG, "isNsaState error");
return null;
}
}
public static int getNetworkType(Context context) {
if (context != null) {
return getNetworkType(getNetworkInfo(context), context);
}
return 0;
}
private static int getHwNetworkType(Context context) {
TelephonyManager telephonyManager;
ServiceState serviceState;
if (!ReflectionUtils.checkCompatible(EmuiUtil.BUILDEX_VERSION) || context == null || (telephonyManager = (TelephonyManager) ContextCompat.getSystemService(context, "phone")) == null) {
return 0;
}
try {
if (BuildEx.VERSION.EMUI_SDK_INT < 21 || (serviceState = telephonyManager.getServiceState()) == null) {
return 0;
}
return ServiceStateEx.getConfigRadioTechnology(serviceState);
} catch (SecurityException unused) {
Logger.w(TAG, "requires permission maybe missing.");
return 0;
} catch (NoSuchMethodError unused2) {
Logger.w(TAG, "NoSuchMethodError occur in method getHwNetworkType.");
return 0;
} catch (NoClassDefFoundError unused3) {
Logger.w(TAG, "NoClassDefFoundError occur in method getHwNetworkType.");
return 0;
}
}
public static int getNetworkType(NetworkInfo networkInfo, Context context) {
int i;
if (networkInfo == null || !networkInfo.isConnected()) {
return -1;
}
int type = networkInfo.getType();
if (1 == type || 13 == type) {
return 1;
}
if (type == 0) {
int hwNetworkType = getHwNetworkType(context);
String str = TAG;
Logger.v(str, "getHwNetworkType return is: " + hwNetworkType);
if (hwNetworkType == 0) {
hwNetworkType = networkInfo.getSubtype();
}
if (hwNetworkType != 20) {
switch (hwNetworkType) {
case 1:
case 2:
case 4:
case 7:
case 11:
i = 2;
break;
case 3:
case 5:
case 6:
case 8:
case 9:
case 10:
case 12:
case 14:
case 15:
i = 3;
break;
case 13:
i = 4;
break;
default:
i = 0;
break;
}
} else {
i = 5;
}
if (i != 0 || Build.VERSION.SDK_INT < 25) {
return i;
}
if (hwNetworkType == 16) {
return 2;
}
if (hwNetworkType != 17) {
return 0;
}
return 3;
}
return 0;
}
public static int getNetworkType(NetworkInfo networkInfo) {
return getNetworkType(networkInfo, null);
}
private static String[] getDnsServerIpsFromConnectionManager(Context context) {
ConnectivityManager connectivityManager;
NetworkInfo networkInfo;
LinkProperties linkProperties;
LinkedList linkedList = new LinkedList();
if (!(Build.VERSION.SDK_INT < 21 || context == null || (connectivityManager = (ConnectivityManager) ContextCompat.getSystemService(context, "connectivity")) == null)) {
try {
NetworkInfo activeNetworkInfo = connectivityManager.getActiveNetworkInfo();
if (activeNetworkInfo != null) {
Network[] allNetworks = connectivityManager.getAllNetworks();
for (Network network : allNetworks) {
if (!(network == null || (networkInfo = connectivityManager.getNetworkInfo(network)) == null || networkInfo.getType() != activeNetworkInfo.getType() || (linkProperties = connectivityManager.getLinkProperties(network)) == null)) {
for (InetAddress inetAddress : linkProperties.getDnsServers()) {
linkedList.add(inetAddress.getHostAddress());
}
}
}
}
} catch (SecurityException e) {
Logger.i(TAG, "getActiveNetworkInfo failed, exception:" + e.getClass().getSimpleName());
} catch (RuntimeException e2) {
Logger.i(TAG, "getActiveNetworkInfo failed, exception:" + e2.getClass().getSimpleName());
}
}
return linkedList.isEmpty() ? new String[0] : (String[]) linkedList.toArray(new String[linkedList.size()]);
}
public static String getDnsServerIps(Context context) {
return Arrays.toString(getDnsServerIpsFromConnectionManager(context));
}
public static int getMobileRsrp(Context context) {
SignalStrength signalStrength = getSignalStrength(context);
if (signalStrength == null) {
return 0;
}
try {
if (Build.VERSION.SDK_INT > 28) {
List cellSignalStrengths = signalStrength.getCellSignalStrengths(CellSignalStrengthLte.class);
if (cellSignalStrengths.size() > 0) {
return ((CellSignalStrengthLte) cellSignalStrengths.get(0)).getDbm();
}
return 0;
}
final Method declaredMethod = SignalStrength.class.getDeclaredMethod("getDbm", new Class[0]);
AccessController.doPrivileged(new PrivilegedAction() {
/* class com.huawei.hms.framework.common.NetworkUtil.AnonymousClass1 */
@Override // java.security.PrivilegedAction
public final Object run() {
declaredMethod.setAccessible(true);
return null;
}
});
return ((Integer) declaredMethod.invoke(signalStrength, new Object[0])).intValue();
} catch (NoSuchMethodException unused) {
Logger.i(TAG, "getDbm: function not found");
return 0;
} catch (IllegalAccessException unused2) {
Logger.i(TAG, "getDbm: cannot access");
return 0;
} catch (InvocationTargetException unused3) {
Logger.i(TAG, "getDbm: InvocationTargetException");
return 0;
} catch (Throwable th) {
String str = TAG;
Logger.i(str, "getDbm: throwable:" + th.getClass());
return 0;
}
}
private static SignalStrength getSignalStrength(Context context) {
if (context == null || Build.VERSION.SDK_INT < 28) {
return null;
}
Object systemService = ContextCompat.getSystemService(context, "phone");
if (systemService instanceof TelephonyManager) {
return ((TelephonyManager) systemService).createForSubscriptionId(SubscriptionManager.getDefaultDataSubscriptionId()).getSignalStrength();
}
return null;
}
public static int getWifiRssi(Context context) {
if (context == null) {
return INVALID_RSSI;
}
Object systemService = ContextCompat.getSystemService(context.getApplicationContext(), "wifi");
if (!(systemService instanceof WifiManager)) {
return INVALID_RSSI;
}
try {
WifiInfo connectionInfo = ((WifiManager) systemService).getConnectionInfo();
if (connectionInfo == null || connectionInfo.getBSSID() == null) {
return INVALID_RSSI;
}
return connectionInfo.getRssi();
} catch (RuntimeException e) {
String str = TAG;
Logger.i(str, "getWifiRssiLevel did not has permission!" + e.getClass().getSimpleName() + e.getMessage());
return INVALID_RSSI;
}
}
public static int getWifiRssiLevel(Context context) {
return WifiManager.calculateSignalLevel(getWifiRssi(context), 5);
}
public static String getWifiGatewayIp(Context context) {
if (context == null) {
return " ";
}
Object systemService = ContextCompat.getSystemService(context.getApplicationContext(), "wifi");
if (!(systemService instanceof WifiManager)) {
return " ";
}
try {
int i = ((WifiManager) systemService).getDhcpInfo().gateway;
return InetAddress.getByAddress(new byte[]{(byte) (i & 255), (byte) ((i >> 8) & 255), (byte) ((i >> 16) & 255), (byte) ((i >> 24) & 255)}).getHostAddress();
} catch (RuntimeException | UnknownHostException e) {
String str = TAG;
Logger.i(str, "getWifiGatewayIp error!" + e.getClass().getSimpleName() + e.getMessage());
return " ";
}
}
public static NetworkInfo.DetailedState getNetworkStatus(Context context) {
NetworkInfo.DetailedState detailedState = NetworkInfo.DetailedState.IDLE;
if (context == null) {
return detailedState;
}
Object systemService = ContextCompat.getSystemService(context, "connectivity");
if (systemService instanceof ConnectivityManager) {
try {
NetworkInfo activeNetworkInfo = ((ConnectivityManager) systemService).getActiveNetworkInfo();
if (activeNetworkInfo != null) {
return activeNetworkInfo.getDetailedState();
}
Logger.i(TAG, "getNetworkStatus networkIsConnected netInfo is null!");
return detailedState;
} catch (RuntimeException e) {
String str = TAG;
Logger.i(str, "getNetworkStatus exception" + e.getClass().getSimpleName() + e.getMessage());
return detailedState;
}
} else {
Logger.i(TAG, "getNetworkStatus ConnectivityManager is null!");
return detailedState;
}
}
public static int readDataSaverMode(Context context) {
if (context != null && Build.VERSION.SDK_INT >= 24 && ContextCompat.checkSelfPermission(context, "android.permission.ACCESS_NETWORK_STATE")) {
Object systemService = ContextCompat.getSystemService(context, "connectivity");
if (systemService instanceof ConnectivityManager) {
ConnectivityManager connectivityManager = (ConnectivityManager) systemService;
try {
if (connectivityManager.isActiveNetworkMetered()) {
return connectivityManager.getRestrictBackgroundStatus();
}
Logger.v(TAG, "ConnectType is not Mobile Network!");
} catch (RuntimeException e) {
Logger.e(TAG, "SystemServer error:", e);
}
}
}
return 0;
}
public static boolean isSimReady(Context context) {
Object systemService = ContextCompat.getSystemService(context, "phone");
TelephonyManager telephonyManager = systemService instanceof TelephonyManager ? (TelephonyManager) systemService : null;
return telephonyManager != null && telephonyManager.getSimState() == 5;
}
public static String getMNC(Context context) {
if (context == null || !isSimReady(context)) {
return "unknown";
}
TelephonyManager telephonyManager = null;
Object systemService = ContextCompat.getSystemService(context, "phone");
if (systemService instanceof TelephonyManager) {
telephonyManager = (TelephonyManager) systemService;
}
if (telephonyManager == null) {
Logger.e(TAG, "getSubscriptionOperatorType: other error!");
return "unknown";
}
String networkOperator = telephonyManager.getNetworkOperator();
if ("46001".equals(networkOperator) || "46006".equals(networkOperator) || "46009".equals(networkOperator)) {
return "China_Unicom";
}
if ("46000".equals(networkOperator) || "46002".equals(networkOperator) || "46004".equals(networkOperator) || "46007".equals(networkOperator)) {
return "China_Mobile";
}
return ("46003".equals(networkOperator) || "46005".equals(networkOperator) || "46011".equals(networkOperator)) ? "China_Telecom" : "other";
}
public static String getHost(String str) {
if (TextUtils.isEmpty(str)) {
return "";
}
try {
return new URI(str).getHost();
} catch (URISyntaxException e) {
Logger.w(TAG, e.getClass().getSimpleName());
return "";
}
}
public static boolean isUserUnlocked(Context context) {
UserManager userManager;
if (Build.VERSION.SDK_INT < 24 || (userManager = (UserManager) ContextCompat.getSystemService(context, "user")) == null) {
return true;
}
try {
return userManager.isUserUnlocked();
} catch (RuntimeException e) {
Logger.e(TAG, "dealType rethrowFromSystemServer:", e);
return true;
}
}
@Deprecated
public static boolean isForeground(Context context) {
return ActivityUtil.isForeground(context);
}
@Deprecated
public static NetworkInfo.DetailedState networkStatus(Context context) {
return getNetworkStatus(context);
}
public static boolean isConnectTypeChange(NetworkInfo networkInfo, NetworkInfo networkInfo2) {
if (networkInfo == null || !networkInfo.isConnected() || !networkInfo2.isConnected() || getPrimaryNetworkType(networkInfo) == getPrimaryNetworkType(networkInfo2)) {
return false;
}
Logger.v(TAG, "Find activity network changed");
return true;
}
public static boolean isChangeToConnected(NetworkInfo networkInfo, NetworkInfo networkInfo2) {
if ((networkInfo != null && networkInfo.isConnected()) || !networkInfo2.isConnected()) {
return false;
}
Logger.v(TAG, "Find network state changed to connected");
return true;
}
public static int getPrimaryNetworkType(Context context) {
return groupNetworkType(getNetworkType(getNetworkInfo(context), context));
}
public static int getPrimaryNetworkType(NetworkInfo networkInfo) {
return groupNetworkType(getNetworkType(networkInfo));
}
}