package com.seewo.vcommons.helper;

import android.content.ContentResolver;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.NetworkInfo;
import android.net.TetheringManager;
import android.net.wifi.WifiManager;
import android.os.Handler;
import android.os.ResultReceiver;
import android.provider.Settings;
import android.util.Log;
import com.seewo.vcommons.data.PreferencesUtils;
import com.seewo.vcommons.data.PropertiesUtils;
import com.seewo.vcommons.utils.RLog;
import com.seewo.vcommons.utils.reflect.WifiManagerInsider;
import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.lang.reflect.Field;
import java.util.LinkedList;
import java.util.List;
import java.util.concurrent.Executor;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

/* JADX INFO: loaded from: classes.dex */
public class NetHelper {
    private static final String CAT_ARP = "cat /proc/net/arp";
    private static final String KEY_ETHERNET_IP = "dhcp.eth0.ipaddress";
    private static final String KEY_WIFI_IP = "dhcp.wlan0.ipaddress";
    private static final String PATTERN_IP_ADDRESS = "((2[0-4]\\d|25[0-5]|[01]?\\d\\d?)\\.){3}(2[0-4]\\d|25[0-5]|[01]?\\d\\d?)";
    private static final String TAG = "NetHelper";
    private static final String TARGET_DEV = "eth1";
    private static final String TARGET_IP_MASK = "192.168.";

    private NetHelper() {
    }

    private static List<String> execCommand(String str) {
        LinkedList linkedList = new LinkedList();
        Process processExec = null;
        try {
            try {
                try {
                    try {
                        processExec = Runtime.getRuntime().exec(str);
                        BufferedReader bufferedReader = new BufferedReader(new InputStreamReader(processExec.getInputStream()));
                        while (true) {
                            String line = bufferedReader.readLine();
                            if (line == null) {
                                break;
                            }
                            linkedList.add(line);
                        }
                    } catch (Throwable th) {
                        if (processExec != null) {
                            try {
                                processExec.destroy();
                            } catch (Exception e) {
                                Log.e(TAG, "close stream error", e);
                            }
                        }
                        throw th;
                    }
                } catch (IOException e2) {
                    Log.e(TAG, "execute shell command error", e2);
                    if (processExec != null) {
                        processExec.destroy();
                    }
                }
            } catch (Exception e3) {
                Log.e(TAG, "process.waitFor exception", e3);
                if (processExec != null) {
                    processExec.destroy();
                }
            }
            if (processExec != null) {
                processExec.destroy();
            }
        } catch (Exception e4) {
            Log.e(TAG, "close stream error", e4);
        }
        return linkedList;
    }

    public static String getSlotIp() {
        String strRegexMatch = null;
        for (String str : execCommand(CAT_ARP)) {
            if (str.contains(TARGET_DEV) && str.contains(TARGET_IP_MASK)) {
                strRegexMatch = regexMatch(PATTERN_IP_ADDRESS, str);
            }
        }
        return strRegexMatch;
    }

    public static String getPCIp() {
        return PropertiesUtils.getCurrentPCIp();
    }

    public static String getAndroidSlotIp() {
        return PropertiesUtils.getCurrentAndroidSlotIp();
    }

    public static String getPlatformIp(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        if (PreferencesUtils.getNetworkState(context)) {
            return PropertiesUtils.getProperty(KEY_ETHERNET_IP);
        }
        if (connectivityManager.getNetworkInfo(1).getState() == NetworkInfo.State.CONNECTED) {
            return PropertiesUtils.getProperty(KEY_WIFI_IP);
        }
        return null;
    }

    private static String regexMatch(String str, String str2) {
        Matcher matcher = Pattern.compile(str).matcher(str2);
        String strGroup = null;
        while (matcher.find()) {
            strGroup = matcher.group(0);
            if (str2.indexOf(str2) <= str2.lastIndexOf(matcher.group(1))) {
                break;
            }
        }
        return strGroup;
    }

    public static void stopNativeHotSpot(Context context) {
        WifiManager wifiManager = (WifiManager) context.getApplicationContext().getSystemService("wifi");
        if (WifiManagerInsider.getWifiApState(wifiManager) == WifiManagerInsider.WIFI_AP_STATE_ENABLED || WifiManagerInsider.getWifiApState(wifiManager) == WifiManagerInsider.WIFI_AP_STATE_ENABLING) {
            doMethod(context.getSystemService("connectivity"), "stopTethering", new Class[]{Integer.TYPE}, 0);
        }
    }

    public static void startNativeHotSpot(Context context) {
        startHightVersionNativeHotSpot(context);
    }

    private static void startLowVersionNativeHotSpot(Context context) {
        ContentResolver contentResolver = context.getContentResolver();
        WifiManager wifiManager = (WifiManager) context.getSystemService("wifi");
        int wifiState = wifiManager.getWifiState();
        if (wifiState == 2 || wifiState == 3) {
            wifiManager.setWifiEnabled(false);
            Settings.Global.putInt(contentResolver, "wifi_saved_state", 1);
        }
        WifiManagerInsider.setWifiApEnabled(wifiManager, null, true);
    }

    private static void startHightVersionNativeHotSpot(Context context) {
        ConnectivityManager connectivityManager = (ConnectivityManager) context.getSystemService("connectivity");
        new ResultReceiver(new Handler());
        try {
            Field declaredField = ConnectivityManager.class.getDeclaredField("mTetheringManager");
            declaredField.setAccessible(true);
            doMethod(declaredField.get(connectivityManager), "startTethering", new Class[]{Integer.TYPE, Executor.class, TetheringManager.StartTetheringCallback.class}, 0, new Executor() { // from class: com.seewo.vcommons.helper.NetHelper.1
                @Override // java.util.concurrent.Executor
                public void execute(Runnable runnable) {
                    runnable.run();
                }
            }, new TetheringManager.StartTetheringCallback() { // from class: com.seewo.vcommons.helper.NetHelper.2
            });
        } catch (Exception e) {
            Log.e(TAG, "start AP error", e);
        }
    }

    private static Object doMethod(Object obj, String str, Class[] clsArr, Object... objArr) {
        try {
            return obj.getClass().getMethod(str, clsArr).invoke(obj, objArr);
        } catch (Exception e) {
            RLog.e(TAG, e.toString());
            return null;
        }
    }
}