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);
}
}