最近在调试RK3588的板子,硬件设计带双网口,但是设置中只有一个网口选项,导致同时插两根网线时设置中只能显示一个ip地址,添加的代码在此记录一下。
代码添加的逻辑其实很简单,因为之前设置中已经有一份网口的代码了,并且也能获取到ip,能显示网口插入的图标,所以只需要依葫芦画瓢,复制一份代码就可以,毕竟设置中网口已经实现了。
在Settings中新建Ethernet2Settings.java
packages/apps/Settings/src/com/android/settings/ethernet/Ethernet2Settings.java
/*
* Copyright (C) 2009 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
package com.android.settings.ethernet;
import com.android.settings.R;
import com.android.settings.SettingsPreferenceFragment;
import android.app.Activity;
import android.app.AlertDialog;
import android.app.Dialog;
import android.app.admin.DevicePolicyManager;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.ComponentName;
import android.content.Context;
import android.content.DialogInterface;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.pm.PackageManager;
import android.content.res.Resources;
import android.net.ConnectivityManager;
import android.net.InetAddresses;
import android.net.NetworkInfo;
import android.net.Uri;
import android.os.Bundle;
import android.os.Handler;
import android.os.Message;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.os.UserManager;
import android.preference.CheckBoxPreference;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.PreferenceScreen;
import android.provider.SearchIndexableResource;
import android.provider.Settings;
import android.telephony.TelephonyManager;
import android.text.TextUtils;
import android.util.Log;
import android.content.Intent;
import androidx.preference.SwitchPreference;
import androidx.preference.ListPreference;
import androidx.preference.Preference;
import java.io.File;
import java.io.FileDescriptor;
import java.io.File;
import java.io.BufferedReader;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.InputStreamReader;
import java.util.regex.Pattern;
import java.lang.Integer;
import java.net.InetAddress;
import java.net.Inet4Address;
import java.util.Iterator;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collection;
import java.util.List;
import android.preference.Preference.OnPreferenceChangeListener;
import android.preference.Preference.OnPreferenceClickListener;
import com.android.settings.SettingsPreferenceFragment.SettingsDialogFragment;
/*for 5.0*/
import android.net.EthernetManager;
import android.net.IpConfiguration;
import android.net.IpConfiguration.IpAssignment;
import android.net.IpConfiguration.ProxySettings;
import android.net.wifi.SupplicantState;
import android.net.wifi.WifiInfo;
import android.net.wifi.WifiManager;
import android.net.StaticIpConfiguration;
//import android.net.NetworkUtils;
import android.net.LinkAddress;
import android.net.LinkProperties;
import android.widget.Toast;
//import android.preference.ListPreference;
//import com.android.internal.logging.MetricsProto.MetricsEvent;
import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
import com.android.settings.ethernet.ethernet_static_ip_dialog;
public class Ethernet2Settings extends SettingsPreferenceFragment
implements DialogInterface.OnClickListener, Preference.OnPreferenceChangeListener {
private static final String TAG = "Ethernet2Settings";
public enum ETHERNET_STATE {
ETHER_STATE_DISCONNECTED,
ETHER_STATE_CONNECTING,
ETHER_STATE_CONNECTED
}
private static final String KEY_ETH_IP_ADDRESS = "ethernet_ip_addr";
private static final String KEY_ETH_HW_ADDRESS = "ethernet_hw_addr";
private static final String KEY_ETH_NET_MASK = "ethernet_netmask";
private static final String KEY_ETH_GATEWAY = "ethernet_gateway";
private static final String KEY_ETH_DNS1 = "ethernet_dns1";
private static final String KEY_ETH_DNS2 = "ethernet_dns2";
private static final String KEY_ETH_MODE = "ethernet_mode_select";
private static String mEthHwAddress = null;
private static String mEthIpAddress = null;
private static String mEthNetmask = null;
private static String mEthGateway = null;
private static String mEthdns1 = null;
private static String mEthdns2 = null;
private final static String nullIpInfo = "0.0.0.0";
private ListPreference mkeyEthMode;
// private SwitchPreference mEthCheckBox;
private CheckBoxPreference staticEthernet;
private final IntentFilter mIntentFilter;
IpConfiguration mIpConfiguration;
EthernetManager mEthManager;
StaticIpConfiguration mStaticIpConfiguration;
Context mContext;
private ethernet_static_ip_dialog mDialog;
private String mIfaceName;
private long mChangeTime;
private static final int SHOW_RENAME_DIALOG = 0;
private static final int ETHER_IFACE_STATE_DOWN = 0;
private static final int ETHER_IFACE_STATE_UP = 1;
private static final int ETHERNET_NUMBER = 2;
private static final String FILE = "/sys/class/net/eth0/flags";
private static final int MSG_GET_ETHERNET_STATE = 0;
private Handler mHandler = new Handler() {
@Override
public void handleMessage(Message msg) {
if (MSG_GET_ETHERNET_STATE == msg.what) {
handleEtherStateChange((ETHERNET_STATE) msg.obj);
}
}
};
@Override
public int getMetricsCategory() {
return MetricsEvent.WIFI_TETHER_SETTINGS;
}
@Override
public int getDialogMetricsCategory(int dialogId) {
switch (dialogId) {
case SHOW_RENAME_DIALOG:
return MetricsEvent.WIFI_TETHER_SETTINGS;
default:
return 0;
}
}
private final BroadcastReceiver mReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
String action = intent.getAction();
log("Action " + action);
//mIfaceName = get_mIfaceName();
if (ConnectivityManager.CONNECTIVITY_ACTION.equals(action)) {
NetworkInfo info = intent.getParcelableExtra(ConnectivityManager.EXTRA_NETWORK_INFO);
Log.v(TAG, "===" + info.toString());
if (null != info && ConnectivityManager.TYPE_ETHERNET == info.getType()) {
long currentTime = System.currentTimeMillis();
int delayTime = 0;
if (currentTime - mChangeTime < 1000) {
delayTime = 2000;
}
if (NetworkInfo.State.CONNECTED == info.getState()) {
handleEtherStateChange(ETHERNET_STATE.ETHER_STATE_CONNECTED, delayTime);
} else if (NetworkInfo.State.DISCONNECTED == info.getState()) {
handleEtherStateChange(ETHERNET_STATE.ETHER_STATE_DISCONNECTED, delayTime);
}
}
}
}
};
public Ethernet2Settings() {
mIntentFilter = new IntentFilter();
mIntentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION);
}
private void handleEtherStateChange(ETHERNET_STATE EtherState, long delayMillis) {
mHandler.removeMessages(MSG_GET_ETHERNET_STATE);
if (delayMillis > 0) {
Message msg = new Message();
msg.what = MSG_GET_ETHERNET_STATE;
msg.obj = EtherState;
mHandler.sendMessageDelayed(msg, delayMillis);
} else {
handleEtherStateChange(EtherState);
}
}
private void handleEtherStateChange(ETHERNET_STATE EtherState) {
log("curEtherState" + EtherState);
switch (EtherState) {
case ETHER_STATE_DISCONNECTED:
mEthHwAddress = nullIpInfo;
mEthIpAddress = nullIpInfo;
mEthNetmask = nullIpInfo;
mEthGateway = nullIpInfo;
mEthdns1 = nullIpInfo;
mEthdns2 = nullIpInfo;
break;
case ETHER_STATE_CONNECTING:
String mStatusString = this.getResources().getString(R.string.ethernet_info_getting);
mEthHwAddress = mStatusString;
mEthIpAddress = mStatusString;
mEthNetmask = mStatusString;
mEthGateway = mStatusString;
mEthdns1 = mStatusString;
mEthdns2 = mStatusString;
break;
case ETHER_STATE_CONNECTED:
getEthInfo();
break;
}
refreshUI();
}
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.ethernet_settings);
mContext = this.getActivity().getApplicationContext();
mEthManager = (EthernetManager) getSystemService(Context.ETHERNET_SERVICE);
if (mEthManager == null) {
Log.e(TAG, "get ethernet manager failed");
Toast.makeText(mContext, R.string.disabled_feature, Toast.LENGTH_SHORT).show();
finish();
return;
}
String[] ifaces = mEthManager.getAvailableInterfaces();
if (ifaces.length > 0) {
mIfaceName = ifaces[1];//"eth1";
}
if (null == mIfaceName) {
Log.e(TAG, "get ethernet ifaceName failed");
Toast.makeText(mContext, R.string.disabled_feature, Toast.LENGTH_SHORT).show();
finish();
}
}
private Inet4Address getIPv4Address(String text) {
try {
return (Inet4Address)InetAddresses.parseNumericAddress(text);
} catch (IllegalArgumentException | ClassCastException e) {
return null;
}
}
@Override
public void onResume() {
super.onResume();
if (null == mIfaceName) {
return;
}
if (mkeyEthMode == null) {
mkeyEthMode = (ListPreference) findPreference(KEY_ETH_MODE);
mkeyEthMode.setOnPreferenceChangeListener(this);
}
/*
if (mEthCheckBox== null) {
mEthCheckBox = (SwitchPreference) findPreference("ethernet");
mEthCheckBox.setOnPreferenceChangeListener(this);
}
*/
//handleEtherStateChange(1 == getEthernetCarrierState(mIfaceName)? EthernetManager.ETHER_STATE_CONNECTED/*mEthManager.getEthernetConnectState()*/);
refreshUI();
log("resume");
mContext.registerReceiver(mReceiver, mIntentFilter);
}
@Override
public void onPause() {
super.onPause();
if (null == mIfaceName) {
return;
}
mContext.unregisterReceiver(mReceiver);
}
@Override
public void onDestroy() {
super.onDestroy();
mHandler.removeMessages(MSG_GET_ETHERNET_STATE);
log("destory");
}
@Override
public void onStop() {
super.onStop();
log("stop");
}
private void setStringSummary(String preference, String value) {
try {
findPreference(preference).setSummary(value);
} catch (RuntimeException e) {
findPreference(preference).setSummary("");
log("can't find " + preference);
}
}
private String getStringFromPref(String preference) {
try {
return findPreference(preference).getSummary().toString();
} catch (RuntimeException e) {
return null;
}
}
private void refreshUI() {
// setStringSummary(KEY_ETH_HW_ADDRESS,mEthHwAddress);
setStringSummary(KEY_ETH_IP_ADDRESS, mEthIpAddress);
setStringSummary(KEY_ETH_NET_MASK, mEthNetmask);
setStringSummary(KEY_ETH_GATEWAY, mEthGateway);
setStringSummary(KEY_ETH_DNS1, mEthdns1);
setStringSummary(KEY_ETH_DNS2, mEthdns2);
updateCheckbox();
}
private void updateCheckbox() { //add by ljh for adding a checkbox switch
if (mEthManager == null) {
mkeyEthMode.setSummary("null");
} else {
IpAssignment mode = mEthManager.getConfiguration(mIfaceName).getIpAssignment();
if (mode == IpAssignment.DHCP || mode == IpAssignment.UNASSIGNED) {
mkeyEthMode.setValue("DHCP");
mkeyEthMode.setSummary(R.string.usedhcp);
} else {
mkeyEthMode.setValue("StaticIP");
mkeyEthMode.setSummary(R.string.usestatic);
}
/* int isEnable = mEthManager.getEthernetIfaceState();
if(isEnable == ETHER_IFACE_STATE_UP) {
mEthCheckBox.setChecked(true);
}else{
mEthCheckBox.setChecked(false);
}
*/
}
}
@Override
public boolean onPreferenceChange(Preference preference, Object newValue) {
log("onPreferenceChange");
if (preference == mkeyEthMode) {
String value = (String) newValue;
if (value.equals("DHCP")) {
mChangeTime = System.currentTimeMillis();
handleEtherStateChange(ETHERNET_STATE.ETHER_STATE_CONNECTING);
IpConfiguration ipConfiguration = new IpConfiguration();
ipConfiguration.setIpAssignment(IpAssignment.DHCP);
ipConfiguration.setProxySettings(ProxySettings.NONE);
mEthManager.setConfiguration(mIfaceName, ipConfiguration);
log("switch to dhcp");
} else if (value.equals("StaticIP")) {
log("static editor");
this.showDialog(SHOW_RENAME_DIALOG);
}
}
return true;
}
//将子网掩码转换成ip子网掩码形式,比如输入32输出为255.255.255.255
public 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;
}
/*
* convert subMask string to prefix length
*/
private int maskStr2InetMask(String maskStr) {
StringBuffer sb;
String str;
int inetmask = 0;
int count = 0;
/*
* check the subMask format
*/
Pattern pattern = Pattern.compile("(^((\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])\\.){3}(\\d|[01]?\\d\\d|2[0-4]\\d|25[0-5])$)|^(\\d|[1-2]\\d|3[0-2])$");
if (pattern.matcher(maskStr).matches() == false) {
Log.e(TAG, "subMask is error");
return 0;
}
String[] ipSegment = maskStr.split("\\.");
for (int n = 0; n < ipSegment.length; n++) {
sb = new StringBuffer(Integer.toBinaryString(Integer.parseInt(ipSegment[n])));
str = sb.reverse().toString();
count = 0;
for (int i = 0; i < str.length(); i++) {
i = str.indexOf("1", i);
if (i == -1)
break;
count++;
}
inetmask += count;
}
return inetmask;
}
private boolean setStaticIpConfiguration() {
/*
* get ip address, netmask,dns ,gw etc.
*/
Inet4Address inetAddr = getIPv4Address(this.mEthIpAddress);
int prefixLength = maskStr2InetMask(this.mEthNetmask);
InetAddress gatewayAddr = getIPv4Address(this.mEthGateway);
InetAddress dnsAddr = getIPv4Address(this.mEthdns1);
if (null == inetAddr || inetAddr.getAddress().toString().isEmpty()
|| prefixLength == 0
|| gatewayAddr.toString().isEmpty()
|| dnsAddr.toString().isEmpty()) {
log("ip,mask or dnsAddr is wrong");
return false;
}
String dnsStr2 = this.mEthdns2;
ArrayList<InetAddress> dnsAddrs = new ArrayList<InetAddress>();
dnsAddrs.add(dnsAddr);
if (!dnsStr2.isEmpty()) {
dnsAddrs.add(getIPv4Address(dnsStr2));
}
mStaticIpConfiguration = new StaticIpConfiguration.Builder()
.setIpAddress(new LinkAddress(inetAddr, prefixLength))
.setGateway(gatewayAddr)
.setDnsServers(dnsAddrs)
.build();
mIpConfiguration = new IpConfiguration();
mIpConfiguration.setIpAssignment(IpAssignment.STATIC);
mIpConfiguration.setProxySettings(ProxySettings.NONE);
mIpConfiguration.setStaticIpConfiguration(mStaticIpConfiguration);
return true;
}
public void getEthInfoFromDhcp() {
String tempIpInfo;
tempIpInfo = /*SystemProperties.get("dhcp."+ iface +".ipaddress");*/
mEthManager.getIpAddress(mIfaceName);
if ((tempIpInfo != null) && (!tempIpInfo.equals(""))) {
mEthIpAddress = tempIpInfo;
} else {
mEthIpAddress = nullIpInfo;
}
tempIpInfo = /*SystemProperties.get("dhcp."+ iface +".mask");*/
mEthManager.getNetmask(mIfaceName);
if ((tempIpInfo != null) && (!tempIpInfo.equals(""))) {
mEthNetmask = tempIpInfo;
} else {
mEthNetmask = nullIpInfo;
}
tempIpInfo = /*SystemProperties.get("dhcp."+ iface +".gateway");*/
mEthManager.getGateway(mIfaceName);
if ((tempIpInfo != null) && (!tempIpInfo.equals(""))) {
mEthGateway = tempIpInfo;
} else {
mEthGateway = nullIpInfo;
}
tempIpInfo = /*SystemProperties.get("dhcp."+ iface +".dns1");*/
mEthManager.getDns(mIfaceName);
if ((tempIpInfo != null) && (!tempIpInfo.equals(""))) {
String data[] = tempIpInfo.split(",");
mEthdns1 = data[0];
if (data.length <= 1) {
mEthdns2 = nullIpInfo;
} else {
mEthdns2 = data[1];
}
} else {
mEthdns1 = nullIpInfo;
}
}
public void getEthInfoFromStaticIp() {
StaticIpConfiguration staticIpConfiguration = mEthManager.getConfiguration(mIfaceName).getStaticIpConfiguration();
if (staticIpConfiguration == null) {
return;
}
LinkAddress ipAddress = staticIpConfiguration.getIpAddress();
InetAddress gateway = staticIpConfiguration.getGateway();
List<InetAddress> dnsServers = staticIpConfiguration.getDnsServers();
if (ipAddress != null) {
mEthIpAddress = ipAddress.getAddress().getHostAddress();
mEthNetmask = interMask2String(ipAddress.getPrefixLength());
}
if (gateway != null) {
mEthGateway = gateway.getHostAddress();
}
mEthdns1 = dnsServers.get(0).getHostAddress();
if (dnsServers.size() > 1) { /* 只保留两个*/
mEthdns2 = dnsServers.get(1).getHostAddress();
}
}
/*
* TODO:
*/
public void getEthInfo() {
/*
mEthHwAddress = mEthManager.getEthernetHwaddr(mEthManager.getEthernetIfaceName());
if (mEthHwAddress == null) mEthHwAddress = nullIpInfo;
*/
IpAssignment mode = mEthManager.getConfiguration(mIfaceName).getIpAssignment();
if (mode == IpAssignment.DHCP || mode == IpAssignment.UNASSIGNED) {
/*
* getEth from dhcp
*/
getEthInfoFromDhcp();
} else if (mode == IpAssignment.STATIC) {
/*
* TODO: get static IP
*/
getEthInfoFromStaticIp();
}
}
/*
* tools
*/
private void log(String s) {
Log.d(TAG, s);
}
@Override
public void onClick(DialogInterface dialogInterface, int button) {
if (button == ethernet_static_ip_dialog.BUTTON_SUBMIT) {
mDialog.saveIpSettingInfo(); //从Dialog获取静态数据
if (setStaticIpConfiguration()) {
mChangeTime = System.currentTimeMillis();
handleEtherStateChange(ETHERNET_STATE.ETHER_STATE_CONNECTING);
mEthManager.setConfiguration(mIfaceName, mIpConfiguration);
} else {
Log.e(TAG, mIpConfiguration.toString());
}
}
updateCheckbox();
}
@Override
public Dialog onCreateDialog(int dialogId) {
log("onCreateDialog " + dialogId);
//mIfaceName = get_mIfaceName();
switch (dialogId) {
case SHOW_RENAME_DIALOG:
mDialog = new ethernet_static_ip_dialog(getActivity(), false, this, mGetStaticIpInfo, mIfaceName);
return mDialog;
}
return super.onCreateDialog(dialogId);
}
/*interface*/
public getStaticIpInfo mGetStaticIpInfo = new getStaticIpInfo() {
public boolean getStaticIp(String ipAddr) {
mEthIpAddress = ipAddr;
log("ipAddr: " + ipAddr);
return true;
}
public boolean getStaticNetMask(String netMask) {
mEthNetmask = netMask;
log("netMask: " + netMask);
return true;
}
public boolean getStaticGateway(String gateway) {
mEthGateway = gateway;
log("gateway: " + gateway);
return true;
}
public boolean getStaticDns1(String dns1) {
mEthdns1 = dns1;
log("dns1: " + dns1);
return true;
}
public boolean getStaticDns2(String dns2) {
mEthdns2 = dns2;
log("dns2: " + dns2);
return true;
}
};
private String get_mIfaceName() {
String[] ifaces = mEthManager.getAvailableInterfaces();
if (ifaces.length > 0) {
for(int i=0;i<ETHERNET_NUMBER;i++){
int carrier = getEthernetCarrierState(ifaces[i]);
Log.d(TAG, "cgl ============= ifaces = "+ifaces[i]+" carrier = " +carrier);
if(carrier == 1)
mIfaceName = ifaces[i];
}
}
return mIfaceName;
}
private String ReadFromFile(File file) {
if ((file != null) && file.exists()) {
try {
FileInputStream fin = new FileInputStream(file);
BufferedReader reader = new BufferedReader(new InputStreamReader(fin));
String flag = reader.readLine();
fin.close();
return flag;
} catch (Exception e) {
e.printStackTrace();
}
}
return null;
}
private int getEthernetCarrierState(String iface) {
if (iface != "") {
try {
File file = new File("/sys/class/net/" + iface + "/carrier");
String carrier = ReadFromFile(file);
return Integer.parseInt(carrier);
} catch (Exception e) {
e.printStackTrace();
return 0;
}
} else {
return 0;
}
}
public static boolean isAvailable() {
return "true".equals(SystemProperties.get("ro.rk.ethernet_settings"));
}
}
需要注意的是在onCreate中,指定是哪一个网口,mIfaceName = ifaces[1]。Ethernet2Settings.java指定获取eth1的ip地址,EthernetSettings.java指定获取eth0的ip地址。这样就能在设置中实现两个网口独立显示两个ip互不干扰。
@Override
public void onCreate(Bundle savedInstanceState) {
super.onCreate(savedInstanceState);
addPreferencesFromResource(R.xml.ethernet_settings);
mContext = this.getActivity().getApplicationContext();
mEthManager = (EthernetManager) getSystemService(Context.ETHERNET_SERVICE);
if (mEthManager == null) {
Log.e(TAG, "get ethernet manager failed");
Toast.makeText(mContext, R.string.disabled_feature, Toast.LENGTH_SHORT).show();
finish();
return;
}
String[] ifaces = mEthManager.getAvailableInterfaces();
if (ifaces.length > 0) {
mIfaceName = ifaces[1];//"eth1";
}
if (null == mIfaceName) {
Log.e(TAG, "get ethernet ifaceName failed");
Toast.makeText(mContext, R.string.disabled_feature, Toast.LENGTH_SHORT).show();
finish();
}
}
接下来就是添加显示位置和显示的标题字符
packages/apps/Settings/res/xml/network_and_internet.xml
<com.android.settingslib.RestrictedPreference
android:fragment="com.android.settings.ethernet.EthernetSettings"
android:icon="@drawable/ic_ethernet"
android:key="ethernet_settings"
android:title="@string/ethernet_settings_title"
settings:useAdminDisabledSummary="true"
settings:userRestriction="no_ethernet_settings" />
+ <com.android.settingslib.RestrictedPreference
+ android:fragment="com.android.settings.ethernet.Ethernet2Settings"
+ android:icon="@drawable/ic_ethernet"
+ android:key="ethernet_settings"
+ android:title="@string/ethernet2_settings_title"
+ settings:useAdminDisabledSummary="true"
+ settings:userRestriction="no_ethernet_settings" />
packages/apps/Settings/res/xml/network_provider_internet.xml
<com.android.settingslib.RestrictedPreference
android:fragment="com.android.settings.ethernet.EthernetSettings"
android:icon="@drawable/ic_ethernet"
android:key="ethernet_settings"
android:title="@string/ethernet_settings_title"
settings:useAdminDisabledSummary="true"
settings:userRestriction="no_ethernet_settings" />
+ <com.android.settingslib.RestrictedPreference
+ android:fragment="com.android.settings.ethernet.Ethernet2Settings"
+ android:icon="@drawable/ic_ethernet"
+ android:key="ethernet_settings"
+ android:title="@string/ethernet2_settings_title"
+ settings:useAdminDisabledSummary="true"
+ settings:userRestriction="no_ethernet_settings" />
packages/apps/Settings/src/com/android/settings/SettingsActivity.java
import com.android.settings.ethernet.EthernetSettings;
+import com.android.settings.ethernet.Ethernet2Settings;
somethingChanged = setTileEnabled(changedList, new ComponentName(packageName,
Settings.EthernetSettingsActivity.class.getName()),
EthernetSettings.isAvailable(), isAdmin)
|| somethingChanged;
+ somethingChanged = setTileEnabled(changedList, new ComponentName(packageName,
+ Settings.EthernetSettingsActivity.class.getName()),
+ Ethernet2Settings.isAvailable(), isAdmin)
+ || somethingChanged;
packages/apps/Settings/res/values/strings.xml
<!-- Ethernet Settings -->
<string name="ethernet_settings_title">Ethernet</string>
+ <string name="ethernet2_settings_title">Ethernet1</string>
至此,设置中双网口的选项添加就完成了,显示效果如下图所示: