android13(T) 以太网设置工具类

13 版本的以太网设置和以前版本有所变动，在 AS 中就能直接调用对应 API

将 build.gradle 版本修改 compileSdkVersion 31, 即可直接调用 EthernetManager 相关，

设置静态等方法可以通过反射调用设置。

以下是核心设置静态和动态参数工具类，界面大家可以自由发挥，

以太网电源开关和你们驱动协商写个节点啥的都ok

import android.content.ContentResolver;
import android.content.Context;
import android.net.ConnectivityManager;
import android.net.EthernetManager;
import android.net.IpConfiguration;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.net.RouteInfo;
import android.net.StaticIpConfiguration;
import android.provider.Settings;
import android.provider.Settings.System;
import android.text.TextUtils;
import android.util.Log;

import java.io.FileOutputStream;
import java.lang.reflect.InvocationTargetException;
import java.lang.reflect.Method;
import java.net.Inet4Address;
import java.net.InetAddress;
import java.util.ArrayList;
import java.util.List;

import static android.content.Context.CONNECTIVITY_SERVICE;

public class EthernetUtil {
    private static final String TAG = "EthernetUtil";

    public static final String IS_ETHERNET_OPEN = "isEthernetOpen";
    public static final String IS_ETHERNET_STATUC_OPEN = "isEthernetStaticOpen";
    public static final String ETHERNET_STATIC_DNS1 = "ethernet_static_dns1";
    public static final String ETHERNET_STATIC_DNS2 = "ethernet_static_dns2";
    public static final String ETHERNET_STATIC_GATEWAY = "ethernet_static_gateway";
    public static final String ETHERNET_STATIC_IP = "ethernet_static_ip";
    public static final String ETHERNET_STATIC_NETMASK = "ethernet_static_netmask";

    EthernetManager mEthernetManager;
    Context mContext;
    private static EthernetUtil ethernetUtil;

    public static EthernetUtil getInstance() {
        if (ethernetUtil == null) {
            ethernetUtil = new EthernetUtil();
        }
        return ethernetUtil;
    }

    public void setContext(Context context) {
        mContext = context;
    }

	
    public void saveEthernetConfig() {
        boolean isOpen = isEthernetEnabled();
        boolean isStatic = isStaticEnabled();
        Log.d(TAG, "saveEthernetConfig isOpen=" + isOpen + " isStatic=" + isStatic);
        mEthernetManager = (EthernetManager) mContext.getSystemService(Context.ETHERNET_SERVICE);
        IpConfiguration mIpConfiguration = new IpConfiguration();
        StaticIpConfiguration.Builder staticIpConfiguration = new StaticIpConfiguration.Builder();
        ContentResolver mContentResolver = mContext.getContentResolver();
        if (isOpen) {
            if (isStatic) {
                try {
                    String ip = System.getString(mContentResolver, ETHERNET_STATIC_IP);
                    String gateWay = System.getString(mContentResolver, ETHERNET_STATIC_GATEWAY);
                    String netMask = System.getString(mContentResolver,  ETHERNET_STATIC_NETMASK);
                    String dns1 = System.getString(mContentResolver,  ETHERNET_STATIC_DNS1);
                    String dns2 = System.getString(mContentResolver,  ETHERNET_STATIC_DNS2);
                    staticIpConfiguration.setIpAddress(new LinkAddress(InetAddress.getByName(ip),
                            getNetMaskInt(netMask)));
                    staticIpConfiguration.setDomains(netMask);
                    staticIpConfiguration.setGateway(InetAddress.getByName(gateWay));
                    ArrayList<InetAddress> dnsAddresses = new ArrayList<>();
                    dnsAddresses.add((Inet4Address) InetAddress.getByName(TextUtils.isEmpty(dns1) ? "8.8.8.8" : dns1));
                    dnsAddresses.add((Inet4Address) InetAddress.getByName(TextUtils.isEmpty(dns2) ? "114.114.114.114" : dns2));
                    staticIpConfiguration.setDnsServers(dnsAddresses);
                } catch (Exception e) {
                    e.printStackTrace();
                }
                Log.d(TAG, "IpAssignment.STATIC =" + IpConfiguration.IpAssignment.STATIC);
                mIpConfiguration.setIpAssignment(IpConfiguration.IpAssignment.STATIC);
                mIpConfiguration.setProxySettings(IpConfiguration.ProxySettings.STATIC);
                mIpConfiguration.setStaticIpConfiguration(staticIpConfiguration.build());
            } else {
                mIpConfiguration.setIpAssignment(IpConfiguration.IpAssignment.DHCP);
                mIpConfiguration.setProxySettings(IpConfiguration.ProxySettings.NONE);
                mIpConfiguration.setStaticIpConfiguration(null);
                Log.d(TAG, "IpAssignment.DHCP =" + IpConfiguration.IpAssignment.DHCP);
            }
            setConfiguration("eth0", mIpConfiguration);
			setEthernetEnabled(true);
            Log.d(TAG, "setEthernet true");
        } else {
			setEthernetEnabled(false);
            Log.d(TAG, "setEthernet false");
        }
    }

    private void setEthernetEnabled(boolean enabled) {
        try {
            Class<? extends EthernetManager> c = mEthernetManager.getClass();
            Method method = c.getMethod("setEthernetEnabled", boolean.class);
            EthernetManager tempManager = mEthernetManager;
            method.setAccessible(true);

            Log.e(TAG, "get setEthernetEnabled Method: " + (method == null));
            method.invoke(tempManager, enabled);
        } catch (IllegalAccessException | InvocationTargetException | NoSuchMethodException e) {
            Log.e(TAG, "getDeclaredMethod: " + e.getMessage());
        }
    }

    private void setConfiguration(String iface, IpConfiguration config) {
        try {
            Class<? extends EthernetManager> c = mEthernetManager.getClass();
            Method method = c.getMethod("setConfiguration", String.class, IpConfiguration.class);
            EthernetManager tempManager = mEthernetManager;
            method.setAccessible(true);

            Log.e(TAG, "get setConfiguration Method: " + (method == null));
            method.invoke(tempManager, iface, config);

        } catch (Exception e) {
            Log.e(TAG, "getDeclaredMethod: " + e.getMessage());
        }
    }

    private String interMask2String(int prefixLength) {
        String netMask = null;
        int inetMask = prefixLength;

        int part = inetMask / 8;
        int remainder = inetMask % 8;
        int sum = 0;

        for (int i = 8; i > 8 - remainder; i--) {
            sum = sum + (int) Math.pow(2, i - 1);
        }

        if (part == 0) {
            netMask = sum + ".0.0.0";
        } else if (part == 1) {
            netMask = "255." + sum + ".0.0";
        } else if (part == 2) {
            netMask = "255.255." + sum + ".0";
        } else if (part == 3) {
            netMask = "255.255.255." + sum;
        } else if (part == 4) {
            netMask = "255.255.255.255";
        }

        return netMask;
    }

    public boolean isValidIpAddress(String value) {
        int start = 0;
        int end = value.indexOf('.');
        int numBlocks = 0;

        while (start < value.length()) {

            if (-1 == end) {
                end = value.length();
            }

            try {
                int block = Integer.parseInt(value.substring(start, end));
                if ((block > 255) || (block < 0)) {
                    Log.w(TAG, "isValidIpAddress() : invalid 'block', block = " + block);
                    return false;
                }
            } catch (NumberFormatException e) {
                Log.w(TAG, "isValidIpAddress() : e = " + e);
                return false;
            }

            numBlocks++;

            start = end + 1;
            end = value.indexOf('.', start);
        }

        return numBlocks == 4;
    }

    private int getNetMaskInt(String netMask) {
        Log.d(TAG, "netMask =" + netMask);
        StringBuffer sbf;
        String str;
        int prefixLength = 0, count = 0;
        String[] split = netMask.split("\\.");
        for (int n = 0; n < split.length; n++) {
            sbf = toBin(Integer.parseInt(split[n]));
            str = sbf.reverse().toString();
            //Log.e("net", split[n] + "===" + str);
            count = 0;
            for (int i = 0; i < str.length(); i++) {
                i = str.indexOf('1', i);
                if (i == -1) {
                    break;
                }
                count++;
            }
            prefixLength += count;
        }
        return prefixLength;
    }

    private StringBuffer toBin(int x) {
        StringBuffer result = new StringBuffer();
        result.append(x % 2);
        x /= 2;
        while (x > 0) {
            result.append(x % 2);
            x /= 2;
        }
        return result;
    }

    public String getSaveIp(){
        return Settings.System.getString(mContext.getContentResolver(), ETHERNET_STATIC_IP);
    }
    public String getSaveNetMask(){
        return Settings.System.getString(mContext.getContentResolver(), ETHERNET_STATIC_NETMASK);
    }
    public String getSaveGateway(){
        return Settings.System.getString(mContext.getContentResolver(), ETHERNET_STATIC_GATEWAY);
    }
    public String getSaveDns1(){
        return Settings.System.getString(mContext.getContentResolver(), ETHERNET_STATIC_DNS1);
    }
    public String getSaveDns2(){
        return Settings.System.getString(mContext.getContentResolver(), ETHERNET_STATIC_DNS2);
    }

    public boolean isEthernetEnabled() {
        return Settings.System.getInt(mContext.getContentResolver(), IS_ETHERNET_OPEN, 0) == 1;
    }

    public boolean isStaticEnabled() {
        return Settings.System.getInt(mContext.getContentResolver(), IS_ETHERNET_STATUC_OPEN, 0) == 1;
    }

    public void setEthernetEnabled(boolean flag) {
        Settings.System.putInt(mContext.getContentResolver(), IS_ETHERNET_OPEN, flag ? 1 : 0);
    }

    public void setStaticEnabled(boolean flag) {
        Settings.System.putInt(mContext.getContentResolver(), IS_ETHERNET_STATUC_OPEN, flag ? 1 : 0);
    }

  
}