package com.seewo.libsvendors.vendor.google.ethernet;

import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.NetworkUtils;
import android.net.RouteInfo;
import android.util.Log;
import com.seewo.libsvendors.inter.BaseEthernetDevInfo;
import com.seewo.libsvendors.utils.IEthernetConstant;
import com.seewo.libsvendors.utils.reflect.Reflect;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.net.UnknownHostException;
import java.util.ArrayList;
import java.util.Iterator;
import java.util.List;

/* JADX INFO: loaded from: classes.dex */
public class AndroidEthernetDevInfo extends BaseEthernetDevInfo {
    private static final String EMPTY_IP = "0.0.0.0";
    private static final String KEY_ETH_INTERFACE = "eth0";
    private static final String TAG = "AndroidEthernetDevInfo";
    private Inet4Address EMPTY_ADDRESS;
    private String mDns1Addr;
    private String mDns2Addr;
    private AndroidEthernetManager mEthernetManager;
    private String mIpAddress;
    private LinkProperties mLinkProperties;
    private String mNetMask;
    private String mRouteAddr;

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getIfName() {
        return null;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getProxyHost() {
        return null;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setIfName(String str) {
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setProxyHost(String str) {
    }

    public AndroidEthernetDevInfo(AndroidEthernetManager androidEthernetManager, LinkProperties linkProperties) {
        this.mIpAddress = "0.0.0.0";
        this.mNetMask = "0.0.0.0";
        this.mRouteAddr = "0.0.0.0";
        this.mDns1Addr = "0.0.0.0";
        this.mDns2Addr = "0.0.0.0";
        this.mEthernetManager = androidEthernetManager;
        this.mLinkProperties = linkProperties;
        try {
            this.EMPTY_ADDRESS = (Inet4Address) InetAddress.getByName("0.0.0.0");
        } catch (UnknownHostException e) {
            Log.e(TAG, "init: EMPTY_ADDRESS", e);
        }
        LinkProperties linkProperties2 = this.mLinkProperties;
        if (linkProperties2 == null) {
            Log.e(TAG, "AndroidEthernetDevInfo: mLinkProperties is null.");
            return;
        }
        this.mIpAddress = getIpV4(linkProperties2).getHostAddress();
        this.mNetMask = NetworkUtils.intToInetAddress(prefixLengthToNetmaskInt(getPrefixLengthV4(linkProperties))).getHostAddress();
        this.mRouteAddr = getGateWayV4(this.mLinkProperties).getHostAddress();
        this.mDns1Addr = getDns1(this.mLinkProperties).getHostAddress();
        this.mDns2Addr = getDns2(this.mLinkProperties).getHostAddress();
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setIpAddress(String str) {
        this.mIpAddress = str;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getIpAddress() {
        return this.mIpAddress;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setNetMask(String str) {
        this.mNetMask = str;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getNetMask() {
        return this.mNetMask;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setRouteAddr(String str) {
        this.mRouteAddr = str;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getRouteAddr() {
        return this.mRouteAddr;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setDnsAddr(String str) {
        this.mDns1Addr = str;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getDnsAddr() {
        return this.mDns1Addr;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public void setDns2Addr(String str) {
        this.mDns2Addr = str;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getDns2Addr() {
        return this.mDns2Addr;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public boolean setConnectMode(String str) {
        Object obj = Reflect.on("android.net.IpConfiguration").create(this.mEthernetManager.getConfiguration()).get();
        if (IEthernetConstant.ETHERNET_CONN_MODE_MANUAL.equals(str)) {
            Reflect.on(obj).set("ipAssignment", IpAssignmentValueOf("STATIC"));
            Object obj2 = Reflect.on("android.net.StaticIpConfiguration").create(Reflect.on(obj).call("getStaticIpConfiguration").get()).get();
            Reflect.on(obj2).set("ipAddress", Reflect.on("android.net.LinkAddress").create(this.mIpAddress + "/" + Integer.bitCount(NetworkUtils.inetAddressToInt((Inet4Address) NetworkUtils.numericToInetAddress(this.mNetMask)))).get());
            Reflect.on(obj2).set("gateway", NetworkUtils.numericToInetAddress(this.mRouteAddr));
            Reflect.on(obj2).field("dnsServers").call("clear");
            Reflect.on(obj2).field("dnsServers").call("add", NetworkUtils.numericToInetAddress(this.mDns1Addr));
            Reflect.on(obj2).field("dnsServers").call("add", NetworkUtils.numericToInetAddress(this.mDns2Addr));
            Reflect.on(obj).call("setStaticIpConfiguration", obj2);
            this.mEthernetManager.setConfiguration(getCurrentInterface(), obj);
            return true;
        }
        if (!IEthernetConstant.ETHERNET_CONN_MODE_DHCP.equals(str)) {
            return false;
        }
        Reflect.on(obj).set("ipAssignment", IpAssignmentValueOf("DHCP"));
        this.mEthernetManager.setConfiguration(getCurrentInterface(), obj);
        return true;
    }

    private String getCurrentInterface() {
        return KEY_ETH_INTERFACE;
    }

    private Object IpAssignmentValueOf(String str) {
        return Enum.valueOf((Class) Reflect.on("android.net.IpConfiguration$IpAssignment").get(), str);
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getConnectMode() {
        Object obj;
        Object configuration = this.mEthernetManager.getConfiguration();
        if (configuration == null || (obj = Reflect.on(configuration).field("ipAssignment").get()) == null) {
            return IEthernetConstant.ETHERNET_CONN_MODE_NONE;
        }
        String str = (String) Reflect.on(obj).call("name").get();
        str.hashCode();
        if (str.equals("STATIC")) {
            return IEthernetConstant.ETHERNET_CONN_MODE_MANUAL;
        }
        if (!str.equals("DHCP")) {
            return IEthernetConstant.ETHERNET_CONN_MODE_NONE;
        }
        return IEthernetConstant.ETHERNET_CONN_MODE_DHCP;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getMacAddress(String str) {
        return IEthernetConstant.DEFAULT_MAC_ADDRESS;
    }

    @Override // com.seewo.libsvendors.inter.IEthernetDevInfo
    public String getMacAddress() {
        return IEthernetConstant.DEFAULT_MAC_ADDRESS;
    }

    private Inet4Address getIpV4(LinkProperties linkProperties) {
        List<Inet4Address> ipV4List = getIpV4List(linkProperties);
        if (ipV4List.size() > 0) {
            return ipV4List.get(0);
        }
        return this.EMPTY_ADDRESS;
    }

    private List<Inet4Address> getIpV4List(LinkProperties linkProperties) {
        ArrayList arrayList = new ArrayList();
        Iterator<LinkAddress> it = linkProperties.getLinkAddresses().iterator();
        while (it.hasNext()) {
            InetAddress address = it.next().getAddress();
            if (address instanceof Inet4Address) {
                arrayList.add((Inet4Address) address);
            }
        }
        return arrayList;
    }

    private Inet4Address getGateWayV4(LinkProperties linkProperties) {
        for (Inet4Address inet4Address : getGatewayV4List(linkProperties)) {
            Log.d(TAG, "getGateWayV4: address=" + inet4Address);
            if (!inet4Address.isAnyLocalAddress() && !inet4Address.isLoopbackAddress()) {
                Log.d(TAG, "getGateWayV4: found address=" + inet4Address);
                return inet4Address;
            }
        }
        return this.EMPTY_ADDRESS;
    }

    private List<Inet4Address> getGatewayV4List(LinkProperties linkProperties) {
        ArrayList arrayList = new ArrayList();
        Iterator it = ((List) Reflect.on(linkProperties).call("getAllRoutes").get()).iterator();
        while (it.hasNext()) {
            InetAddress gateway = ((RouteInfo) it.next()).getGateway();
            if (gateway instanceof Inet4Address) {
                arrayList.add((Inet4Address) gateway);
            }
        }
        return arrayList;
    }

    private int getPrefixLengthV4(LinkProperties linkProperties) {
        for (LinkAddress linkAddress : linkProperties.getLinkAddresses()) {
            if (linkAddress.getAddress() instanceof Inet4Address) {
                return linkAddress.getPrefixLength();
            }
        }
        return 0;
    }

    private Inet4Address getDns1(LinkProperties linkProperties) {
        List<Inet4Address> dnsV4List = getDnsV4List(linkProperties);
        if (dnsV4List.size() > 0) {
            return dnsV4List.get(0);
        }
        return this.EMPTY_ADDRESS;
    }

    private Inet4Address getDns2(LinkProperties linkProperties) {
        List<Inet4Address> dnsV4List = getDnsV4List(linkProperties);
        if (dnsV4List.size() > 1) {
            return dnsV4List.get(1);
        }
        return this.EMPTY_ADDRESS;
    }

    private List<Inet4Address> getDnsV4List(LinkProperties linkProperties) {
        ArrayList arrayList = new ArrayList();
        List<InetAddress> dnsServers = linkProperties.getDnsServers();
        Log.d(TAG, "getDnsV4 dnsServerssize " + dnsServers.size());
        for (InetAddress inetAddress : dnsServers) {
            Log.d(TAG, "getDnsV4List: dnsServer=" + inetAddress);
            if (inetAddress instanceof Inet4Address) {
                arrayList.add((Inet4Address) inetAddress);
            }
        }
        return arrayList;
    }

    private static int prefixLengthToNetmaskInt(int i) throws IllegalArgumentException {
        if (i >= 0 && i <= 32) {
            return Integer.reverseBytes((-1) << (32 - i));
        }
        throw new IllegalArgumentException("Invalid prefix length (0 <= prefix <= 32)");
    }
}