android14网络共存，网络优先级

已于 2025-06-11 09:33:02 修改
阅读量556 收藏 8
点赞数 4
CC 4.0 BY-SA版权
文章标签： c++ 开发语言
于 2025-06-11 09:32:19 首次发布
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/a23456789a/article/details/148579376

android14双网共存和网络优先级

system-netd-server-rooutecontroller.patch

diff --git a/server/RouteController.cpp b/server/RouteController.cpp
index 97ca84e9..91f19607 100644
--- a/server/RouteController.cpp
+++ b/server/RouteController.cpp
@@ -777,6 +777,18 @@ int RouteController::modifyVpnFallthroughRule(uint16_t action, unsigned vpnNetId
                         fwmark.intValue, mask.intValue);
 }
 
+
+// added by cgt ethernet and wifi coexist start
+// Add a new rule to look up the 'main' table, with the same selectors as the "default network"
+// rule, but with a lower priority. We will never create routes in the main table; it should only be
+// used for directly-connected routes implicitly created by the kernel when adding IP addresses.
+// This is necessary, for example, when adding a route through a directly-connected gateway: in
+// order to add the route, there must already be a directly-connected route that covers the gateway.
+[[nodiscard]] static int addDirectlyConnectedRule() {
+    return modifyIpRule(RTM_NEWRULE, RULE_PRIORITY_DIRECTLY_CONNECTED, RT_TABLE_MAIN,
+                        MARK_UNSET, MARK_UNSET, IIF_NONE, OIF_NONE, INVALID_UID, INVALID_UID);
+}
+
 /* static */
 int RouteController::configureDummyNetwork() {
     const char *interface = DummyNetwork::INTERFACE_NAME;
@@ -1305,6 +1317,9 @@ int RouteController::Init(unsigned localNetId) {
     if (int ret = addLocalNetworkRules(localNetId)) {
         return ret;
     }
+   if (int ret = addDirectlyConnectedRule()) {
+       return ret;
+    }    
     if (int ret = addUnreachableRule()) {
         return ret;
     }
diff --git a/server/RouteController.h b/server/RouteController.h
index a56d4e05..501a1b2b 100644
--- a/server/RouteController.h
+++ b/server/RouteController.h
@@ -43,6 +43,7 @@ constexpr int32_t RULE_PRIORITY_PROHIBIT_NON_VPN                  = 14000;
 // not have the necessary permission bits in the fwmark. We cannot just give any socket on any of
 // these networks the permission bits, because if the UID that created the socket loses access to
 // the network, then the socket must not match any rule that selects that network.
+constexpr int32_t RULE_PRIORITY_DIRECTLY_CONNECTED                = 9999;
 constexpr int32_t RULE_PRIORITY_UID_EXPLICIT_NETWORK              = 15000;
 constexpr int32_t RULE_PRIORITY_EXPLICIT_NETWORK                  = 16000;
 constexpr int32_t RULE_PRIORITY_OUTPUT_INTERFACE                  = 17000;

connectivity.path

diff --git a/framework/api/module-lib-current.txt b/framework/api/module-lib-current.txt
index 193bd920d2..7e4494a1c0 100644
--- a/framework/api/module-lib-current.txt
+++ b/framework/api/module-lib-current.txt
@@ -73,12 +73,14 @@ package android.net {
 
   public class ConnectivitySettingsManager {
     method public static void clearGlobalProxy(@NonNull android.content.Context);
+    method public static boolean getBluetoothAlwaysRequested(@NonNull android.content.Context, boolean);
     method @Nullable public static String getCaptivePortalHttpUrl(@NonNull android.content.Context);
     method public static int getCaptivePortalMode(@NonNull android.content.Context, int);
     method @NonNull public static java.time.Duration getConnectivityKeepPendingIntentDuration(@NonNull android.content.Context, @NonNull java.time.Duration);
     method @NonNull public static android.util.Range<java.lang.Integer> getDnsResolverSampleRanges(@NonNull android.content.Context);
     method @NonNull public static java.time.Duration getDnsResolverSampleValidityDuration(@NonNull android.content.Context, @NonNull java.time.Duration);
     method public static int getDnsResolverSuccessThresholdPercent(@NonNull android.content.Context, int);
+    method public static boolean getEthernetAlwaysRequested(@NonNull android.content.Context, boolean);
     method @Nullable public static android.net.ProxyInfo getGlobalProxy(@NonNull android.content.Context);
     method public static long getIngressRateLimitInBytesPerSecond(@NonNull android.content.Context);
     method @NonNull public static java.time.Duration getMobileDataActivityTimeout(@NonNull android.content.Context, @NonNull java.time.Duration);
@@ -94,12 +96,14 @@ package android.net {
     method @NonNull public static java.util.Set<java.lang.Integer> getUidsAllowedOnRestrictedNetworks(@NonNull android.content.Context);
     method public static boolean getWifiAlwaysRequested(@NonNull android.content.Context, boolean);
     method @NonNull public static java.time.Duration getWifiDataActivityTimeout(@NonNull android.content.Context, @NonNull java.time.Duration);
+    method public static void setBluetoothAlwaysRequested(@NonNull android.content.Context, boolean);
     method public static void setCaptivePortalHttpUrl(@NonNull android.content.Context, @Nullable String);
     method public static void setCaptivePortalMode(@NonNull android.content.Context, int);
     method public static void setConnectivityKeepPendingIntentDuration(@NonNull android.content.Context, @NonNull java.time.Duration);
     method public static void setDnsResolverSampleRanges(@NonNull android.content.Context, @NonNull android.util.Range<java.lang.Integer>);
     method public static void setDnsResolverSampleValidityDuration(@NonNull android.content.Context, @NonNull java.time.Duration);
     method public static void setDnsResolverSuccessThresholdPercent(@NonNull android.content.Context, @IntRange(from=0, to=100) int);
+    method public static void setEthernetAlwaysRequested(@NonNull android.content.Context, boolean);
     method public static void setGlobalProxy(@NonNull android.content.Context, @NonNull android.net.ProxyInfo);
     method public static void setIngressRateLimitInBytesPerSecond(@NonNull android.content.Context, @IntRange(from=-1L, to=4294967295L) long);
     method public static void setMobileDataActivityTimeout(@NonNull android.content.Context, @NonNull java.time.Duration);
@@ -115,9 +119,11 @@ package android.net {
     method public static void setUidsAllowedOnRestrictedNetworks(@NonNull android.content.Context, @NonNull java.util.Set<java.lang.Integer>);
     method public static void setWifiAlwaysRequested(@NonNull android.content.Context, boolean);
     method public static void setWifiDataActivityTimeout(@NonNull android.content.Context, @NonNull java.time.Duration);
+    field public static final String BLUETOOTH_ALWAYS_REQUESTED = "bluetooth_always_requested";
     field public static final int CAPTIVE_PORTAL_MODE_AVOID = 2; // 0x2
     field public static final int CAPTIVE_PORTAL_MODE_IGNORE = 0; // 0x0
     field public static final int CAPTIVE_PORTAL_MODE_PROMPT = 1; // 0x1
+    field public static final String ETHERNET_ALWAYS_REQUESTED = "ethernet_always_requested";
     field public static final int NETWORK_AVOID_BAD_WIFI_AVOID = 2; // 0x2
     field public static final int NETWORK_AVOID_BAD_WIFI_IGNORE = 0; // 0x0
     field public static final int NETWORK_AVOID_BAD_WIFI_PROMPT = 1; // 0x1
diff --git a/framework/src/android/net/ConnectivitySettingsManager.java b/framework/src/android/net/ConnectivitySettingsManager.java
index 822e67d339..8ef43a9a18 100644
--- a/framework/src/android/net/ConnectivitySettingsManager.java
+++ b/framework/src/android/net/ConnectivitySettingsManager.java
@@ -291,6 +291,10 @@ public class ConnectivitySettingsManager {
      */
     public static final String WIFI_ALWAYS_REQUESTED = "wifi_always_requested";
 
+
+     public static final String ETHERNET_ALWAYS_REQUESTED = "ethernet_always_requested";
+     
+     public static final String BLUETOOTH_ALWAYS_REQUESTED = "bluetooth_always_requested";
     /**
      * Whether to automatically switch away from wifi networks that lose Internet access.
      * Only meaningful if config_networkAvoidBadWifi is set to 0, otherwise the system always
@@ -902,6 +906,64 @@ public class ConnectivitySettingsManager {
                 context.getContentResolver(), WIFI_ALWAYS_REQUESTED, (enable ? 1 : 0));
     }
 
+    /**
+     * Read from {@link Settings} whether the ethernet data connection should remain active
+     * even when higher priority networks are active.
+     *
+     * @param context The {@link Context} to query the setting.
+     * @param def The default value if no setting value.
+     * @return Whether the ethernet data connection should remain active even when higher
+     *         priority networks are active.
+     */
+    public static boolean getEthernetAlwaysRequested(@NonNull Context context, boolean def) {
+        final int enable = Settings.Global.getInt(
+                context.getContentResolver(), ETHERNET_ALWAYS_REQUESTED, (def ? 1 : 0));
+        return (enable != 0) ? true : false;
+    }
+
+    /**
+     * Write into {@link Settings} whether the ethernet data connection should remain active
+     * even when higher priority networks are active.
+     *
+     * @param context The {@link Context} to set the setting.
+     * @param enable Whether the ethernet data connection should remain active even when higher
+     *               priority networks are active
+     */
+    public static void setEthernetAlwaysRequested(@NonNull Context context, boolean enable) {
+        Settings.Global.putInt(
+                context.getContentResolver(), ETHERNET_ALWAYS_REQUESTED, (enable ? 1 : 0));
+    }
+
+/**
+ * Read from {@link Settings} whether the bluetooth data connection should remain active
+ * even when higher priority networks are active.
+ *
+ * @param context The {@link Context} to query the setting.
+ * @param def The default value if no setting value.
+ * @return Whether the bluetooth data connection should remain active even when higher
+ *         priority networks are active.
+ */
+public static boolean getBluetoothAlwaysRequested(@NonNull Context context, boolean def) {
+    final int enable = Settings.Global.getInt(
+            context.getContentResolver(), BLUETOOTH_ALWAYS_REQUESTED, (def ? 1 : 0));
+    return (enable != 0) ? true : false;
+}
+
+/**
+ * Write into {@link Settings} whether the bluetooth data connection should remain active
+ * even when higher priority networks are active.
+ *
+ * @param context The {@link Context} to set the setting.
+ * @param enable Whether the bluetooth data connection should remain active even when higher
+ *               priority networks are active
+ */
+public static void setBluetoothAlwaysRequested(@NonNull Context context, boolean enable) {
+    Settings.Global.putInt(
+            context.getContentResolver(), BLUETOOTH_ALWAYS_REQUESTED, (enable ? 1 : 0));
+}
+
+
+
     /**
      * Get avoid bad wifi setting from {@link Settings}.
      *
diff --git a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
index 59b50bb6f9..c9c458e0b8 100644
--- a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
+++ b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
@@ -742,6 +742,16 @@ public class EthernetNetworkFactory {
             if (mNetworkOfferCallback == null) {
                 mNetworkOfferCallback = new EthernetNetworkOfferCallback();
             }
+	
+	   if(name!=null && name.equals("eth1")){
+
+    		 //mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+     		 mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+     		 //mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN);
+     		 Log.d(TAG, "hcq mCapabilities: " + mCapabilities);
+	     }
+
+
             mNetworkProvider.registerNetworkOffer(getNetworkScore(),
                     new NetworkCapabilities(mCapabilities), cmd -> mHandler.post(cmd),
                     mNetworkOfferCallback);
diff --git a/service/src/com/android/server/ConnectivityService.java b/service/src/com/android/server/ConnectivityService.java
index 120486c1df..4a86b2c040 100755
--- a/service/src/com/android/server/ConnectivityService.java
+++ b/service/src/com/android/server/ConnectivityService.java
@@ -357,8 +357,8 @@ public class ConnectivityService extends IConnectivityManager.Stub
     private static final String TRAFFICCONTROLLER_ARG = "trafficcontroller";
 
     private static final boolean DBG = true;
-    private static final boolean DDBG = Log.isLoggable(TAG, Log.DEBUG);
-    private static final boolean VDBG = Log.isLoggable(TAG, Log.VERBOSE);
+    private static final boolean DDBG = true; //Log.isLoggable(TAG, Log.DEBUG);
+    private static final boolean VDBG = true; //Log.isLoggable(TAG, Log.VERBOSE);
 
     private static final boolean LOGD_BLOCKED_NETWORKINFO = true;
 
@@ -1608,6 +1608,12 @@ public class ConnectivityService extends IConnectivityManager.Stub
         mDefaultVehicleRequest = createAlwaysOnRequestForCapability(
                 NetworkCapabilities.NET_CAPABILITY_VEHICLE_INTERNAL,
                 NetworkRequest.Type.BACKGROUND_REQUEST);
+				
+		mDefaultEthernetRequest = createDefaultInternetRequestForTransport(
+                NetworkCapabilities.TRANSPORT_ETHERNET, NetworkRequest.Type.BACKGROUND_REQUEST);
+				
+		mDefaultBluetoothRequest = createDefaultInternetRequestForTransport(
+                NetworkCapabilities.TRANSPORT_BLUETOOTH, NetworkRequest.Type.BACKGROUND_REQUEST);
 
         mLingerDelayMs = mSystemProperties.getInt(LINGER_DELAY_PROPERTY, DEFAULT_LINGER_DELAY_MS);
         // TODO: Consider making the timer customizable.
@@ -1928,10 +1934,16 @@ public class ConnectivityService extends IConnectivityManager.Stub
         handleAlwaysOnNetworkRequest(mDefaultMobileDataRequest,
                 ConnectivitySettingsManager.MOBILE_DATA_ALWAYS_ON, true /* defaultValue */);
         handleAlwaysOnNetworkRequest(mDefaultWifiRequest,
-                ConnectivitySettingsManager.WIFI_ALWAYS_REQUESTED, false /* defaultValue */);
+                ConnectivitySettingsManager.WIFI_ALWAYS_REQUESTED, true /* defaultValue */);
         final boolean vehicleAlwaysRequested = mResources.get().getBoolean(
                 R.bool.config_vehicleInternalNetworkAlwaysRequested);
         handleAlwaysOnNetworkRequest(mDefaultVehicleRequest, vehicleAlwaysRequested);
+		
+		handleAlwaysOnNetworkRequest(mDefaultEthernetRequest,
+                ConnectivitySettingsManager.ETHERNET_ALWAYS_REQUESTED, true /* defaultValue */);
+				
+	    handleAlwaysOnNetworkRequest(mDefaultEthernetRequest,
+                ConnectivitySettingsManager.BLUETOOTH_ALWAYS_REQUESTED, true /* defaultValue */);
     }
 
     // Note that registering observer for setting do not get initial callback when registering,
@@ -1962,6 +1974,11 @@ public class ConnectivityService extends IConnectivityManager.Stub
                 Settings.Global.getUriFor(
                         ConnectivitySettingsManager.INGRESS_RATE_LIMIT_BYTES_PER_SECOND),
                 EVENT_INGRESS_RATE_LIMIT_CHANGED);
+				
+	    // Watch for whether to keep ethernet always on.
+        mSettingsObserver.observe(
+                Settings.Global.getUriFor(ConnectivitySettingsManager.ETHERNET_ALWAYS_REQUESTED),
+                EVENT_CONFIGURE_ALWAYS_ON_NETWORKS);
     }
 
     private void registerPrivateDnsSettingsCallbacks() {
@@ -4925,6 +4942,10 @@ public class ConnectivityService extends IConnectivityManager.Stub
     private boolean unneeded(NetworkAgentInfo nai, UnneededFor reason) {
         ensureRunningOnConnectivityServiceThread();
 
+	boolean needed = nai.isWIFI();
+	if(needed)
+		return false;
+
         if (!nai.everConnected() || nai.isVPN() || nai.isInactive()
                 || nai.getScore().getKeepConnectedReason() != NetworkScore.KEEP_CONNECTED_NONE) {
             return false;
@@ -7751,6 +7772,9 @@ public class ConnectivityService extends IConnectivityManager.Stub
     // Request used to optionally keep vehicle internal network always active
     private final NetworkRequest mDefaultVehicleRequest;
 
+    private final NetworkRequest mDefaultEthernetRequest;
+	
+	private final NetworkRequest mDefaultBluetoothRequest;
     // Sentinel NAI used to direct apps with default networks that should have no connectivity to a
     // network with no service. This NAI should never be matched against, nor should any public API
     // ever return the associated network. For this reason, this NAI is not in the list of available
@@ -9044,7 +9068,7 @@ public class ConnectivityService extends IConnectivityManager.Stub
                 break;
             }
         }
-        nai.disconnect();
+        // nai.disconnect();
     }
 
     private void handleLingerComplete(NetworkAgentInfo oldNetwork) {
diff --git a/service/src/com/android/server/connectivity/NetworkAgentInfo.java b/service/src/com/android/server/connectivity/NetworkAgentInfo.java
index 85282cbc9b..b6cc1b7b75 100644
--- a/service/src/com/android/server/connectivity/NetworkAgentInfo.java
+++ b/service/src/com/android/server/connectivity/NetworkAgentInfo.java
@@ -1181,6 +1181,15 @@ public class NetworkAgentInfo implements NetworkRanker.Scoreable {
         return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_VPN);
     }
 
+    /** Whether this network is a WIFI. */
+    public boolean isWIFI() {
+        return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_WIFI);
+    }
+
+    /** Whether this network is a ETHERNET. */
+    public boolean isETHERNET() {
+        return networkCapabilities.hasTransport(NetworkCapabilities.TRANSPORT_ETHERNET);
+    }    
     /**
      * Whether this network should propagate the capabilities from its underlying networks.
      * Currently only true for VPNs.
diff --git a/service/src/com/android/server/connectivity/NetworkRanker.java b/service/src/com/android/server/connectivity/NetworkRanker.java
index d94c8dceeb..d1f1a9082f 100644
--- a/service/src/com/android/server/connectivity/NetworkRanker.java
+++ b/service/src/com/android/server/connectivity/NetworkRanker.java
@@ -50,11 +50,17 @@ import java.util.Collection;
 import java.util.List;
 import java.util.Objects;
 import java.util.function.Predicate;
+import android.util.Log;
+import android.os.SystemProperties;
 
 /**
  * A class that knows how to find the best network matching a request out of a list of networks.
  */
 public class NetworkRanker {
+	private static final String TAG = "NetworkRanker";
+	private static final String PERSIST_NET_PREFERRED_TRANSPORTS_ORDER = "persist.net.preferred.transports.order";
+	
+	private static int[] preferredTransportsOrder;
     /**
      * Home for all configurations of NetworkRanker
      */
@@ -118,10 +124,63 @@ public class NetworkRanker {
         return getBestNetworkByPolicy(candidates, currentSatisfier);
     }
 
+    //public static final int TRANSPORT_BLUETOOTH = 2;
+    //public static final int TRANSPORT_CELLULAR = 0;
+    //public static final int TRANSPORT_ETHERNET = 3;
+    //public static final int TRANSPORT_WIFI = 1;
+	
+	
     // Transport preference order, if it comes down to that.
-    private static final int[] PREFERRED_TRANSPORTS_ORDER = { TRANSPORT_ETHERNET, TRANSPORT_WIFI,
+    private static int[] PREFERRED_TRANSPORTS_ORDER = { TRANSPORT_ETHERNET, TRANSPORT_WIFI,
             TRANSPORT_BLUETOOTH, TRANSPORT_CELLULAR };
 
+    private static int[] parseTransportsOrder(String transportsOrderStr) {
+        String[] transportStrings = transportsOrderStr.split(",");
+        int[] transportsOrder = new int[transportStrings.length];
+
+        for (int i = 0; i < transportStrings.length; i++) {
+            try {
+                int transport = Integer.parseInt(transportStrings[i].trim());
+                switch (transport) {
+                    case TRANSPORT_BLUETOOTH:
+                    case TRANSPORT_CELLULAR:
+                    case TRANSPORT_ETHERNET:
+                    case TRANSPORT_WIFI:
+                        transportsOrder[i] = transport;
+                        break;
+                    default:
+                        Log.w(TAG, "Invalid transport value: " + transport);
+                        return null;
+                }
+            } catch (NumberFormatException e) {
+                Log.e(TAG, "Invalid transport format: " + transportsOrderStr);
+                return null;
+            }
+        }
+
+        return transportsOrder;
+    }
+	
+	
+    static void getPreferredTransportsOrder() {
+        String transportsOrderStr = SystemProperties.get(PERSIST_NET_PREFERRED_TRANSPORTS_ORDER);
+        if (transportsOrderStr == null || transportsOrderStr.isEmpty()) {
+            Log.w(TAG, "No preferred transports order set, using default.");
+            return;
+        }
+
+        preferredTransportsOrder = parseTransportsOrder(transportsOrderStr);
+        if (preferredTransportsOrder == null) {
+            Log.e(TAG, "Failed to parse the transports order string.");
+            return;
+        }
+       
+        Log.i(TAG, "Preferred transports order set to: " + Arrays.toString(preferredTransportsOrder));
+		
+		
+    }
+	
+
     // Function used to partition a list into two working areas depending on whether they
     // satisfy a predicate. All items satisfying the predicate will be put in |positive|, all
     // items that don't will be put in |negative|.
@@ -324,6 +383,12 @@ public class NetworkRanker {
         // change from the previous result. If there were, it's guaranteed candidates.size() > 0
         // because accepted.size() > 0 above.
 
+        getPreferredTransportsOrder();
+		
+		if(preferredTransportsOrder != null)
+			PREFERRED_TRANSPORTS_ORDER = preferredTransportsOrder;
+		
+		Log.i(TAG, "Confirm candidates transports order" + Arrays.toString(PREFERRED_TRANSPORTS_ORDER));
         // If some of the networks have a better transport than others, keep only the ones with
         // the best transports.
         for (final int transport : PREFERRED_TRANSPORTS_ORDER) {
@@ -381,6 +446,12 @@ public class NetworkRanker {
         // If there is no satisfying network, then this network can beat, because some network
         // is always better than no network.
         if (null == champion) return true;
+
+	boolean needed = contestant.getCapsNoCopy().hasTransport(TRANSPORT_WIFI);
+
+	if(needed)
+		return true;
+
         // If there is no champion, the offer can always beat.
         // Otherwise rank them.
         final ArrayList<Scoreable> candidates = new ArrayList<>();

使用
public static final int TRANSPORT_BLUETOOTH = 2;
public static final int TRANSPORT_CELLULAR = 0;
public static final int TRANSPORT_ETHERNET = 3;
public static final int TRANSPORT_WIFI = 1;

1、//以太网优先 > WIFI> 4G>蓝牙
setprop persist.net.preferred.transports.order “3,1,0,2”

2、//4G优先>WIFI>以太网>BLUETOOTH
setprop persist.net.preferred.transports.order “0,1,3,2”

3、// wifi优先 >4G>以太网>蓝牙 -->存在BUG
setprop persist.net.preferred.transports.order “1,0,3,2”

logcat -s NetworkRanker
11-08 02:05:57.555 705 849 I NetworkRanker: Preferred transports order set to: [0, 1, 3, 2]
11-08 02:05:57.555 705 849 I NetworkRanker: Confirm candidates transports order[0, 1, 3, 2]

这个修改是eth1一直作内网用
cd packages/modules/Connectivity

--- a/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
+++ b/service-t/src/com/android/server/ethernet/EthernetNetworkFactory.java
@@ -742,6 +742,16 @@ public class EthernetNetworkFactory {
             if (mNetworkOfferCallback == null) {
                 mNetworkOfferCallback = new EthernetNetworkOfferCallback();
             }
+	
+	   if(name!=null && name.equals("eth1")){
+
+    		 //mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_INTERNET);
+     		 //mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_METERED);
+     		 mCapabilities.removeCapability(NetworkCapabilities.NET_CAPABILITY_NOT_VPN);
+     		 Log.d(TAG, "hcq mCapabilities: " + mCapabilities);
+	     }

如果编译报错，建议去掉framework/api/module-lib-current.txt，
make update-api 自己更新

Wthe
关注
Android12之网络共存
王涛的博客
04-18 2248
android12之网络共存
Android/Linux设备有线&无线 双网共存（同时上内、外网）
热门推荐
HowieXue 薛永浩的博客
07-23 6万+
Shell脚本实现动态配置IP与路由：解决嵌入式Android/Linux有线和无线网卡双网共存问题（同时上内网 外网） 网络环境及问题再现 命令行方式实现双网共存 Shell脚本自动实现双网共存（根据网络环境动态配置IP路由） –>问题：在使用某嵌入式开发板（Android 6.0系统）过程中，发现无法同时进行有线（Ethernet）和无线（WiFi）网卡同时通讯，同时产品又有需求，必须同时通过这两个网卡与内网和外
Android13多网络共存
02-27
Android13网络共存，支持WiFi和以太网等多网络共存情况
android12 多网络共存补丁
02-27
android12 多网络共存补丁，支持以太网和WiFi等网络共存
Android11 实现有线网络和wifi共存
wenzhi的博客
10-18 6030
Android 系统Framework进行一定适配后，可以实现wifi和有线网络端口都打开的，进而在App端即可实现通过代码控制选择使用wifi或者有线网络进行网络请求。本文只介绍wifi和有线网络端口同时打开的实现，app代码请求特定网络另外文章介绍。Android 默认是只保留打开一个网络的，其他网络是关闭的；手机一般是wifi或者Sim卡；一些的定制设备，比如商显大屏或者Android盒子，一般是wifi或者有线网络（以太网）。
【android 12】【网络】wifi与以太网共存操作
最新发布
zhangboyu1986的博客
04-08 552
1. android系统原生代码只支持单网存在，即接入hdmi后，wifi无法使用，也不可以网络切换。下面的代码修改，可以使wifi与以太网共存，并根据场景实现不同的功能。2. 在1的基础上，解决wifi与以太网共存时，app无法获取以太网ip地址的问题，且设置以太网优先。3. 在2的基础上做网络动态切换，当双网共存时，以太网此时没有网络，切换到wifi，且能互切。1. wifi与以太网共存，且wifi优先。
Android WiFi和Ethernet共存
franc521的博客
04-14 2356
* WiFi上局域网，以太网上外网，只能这样，测试同时打开，先打开以太网再打开wifi，或者先打开wifi再 ，打开以太网都可以同时获取IP wifi测试连接手机热点，笔记本再连接wifi热点测试局域网连接，以太网直接接路由ping外网**通过ip rule查看，并没有经过wlan0到达网关的路由，因此我们需要增加路由配置，使数据包目的地址为 192.168.49.0/24 的数据，使用路由表main。这种场景，可以看出WiFi对应的wlan0有获取到对应的IP，但是ping 网关ping不通。
Android Wi-Fi/移动网络共存信道规避
华南烹鱼宴
06-29 884
Android 12 中引入了 Wi-Fi/移动网络共存信道规避功能，可以识别并规避使用不安全的 Wi-Fi 信道，以免移动网络信道可能产生/遭到干扰。其中包括 STA、SoftAp、Wi-Fi 直连（点对点）、Wi-Fi 感知 (NAN) 等接口。
Android5.0网络之多网络共存与应用
javon_hzw的专栏
07-10 1万+
Android5.0之后，网络framework出现很大的变化，原生支持了以太网，并且支持多个网络同时连接同时存在。 其实多网络共存并不是什么特别的事情，大部分机器(windows, linux)都支持多个网卡，比如一个用于内网，一个用于外网。但是系统只有一套dns和默认路由，这样就导致使用的局限性。下面看看Android是如何解决这个问题的。 Android5.0的多网络管理是由Connec
Android多种网络共存时APP如何请求特定网络
scyangwei的专栏
05-03 762
在Android framework网络模块会对每种提供网络能力的网络类型进行打分，Ethernet默认70分，WIFI 60分，移动网络 50分。如下，当手机默认网络是WIFI时，三方APP也可以使用ConnectivityManager.requestNetwork API传入CELLULAR网络参数，这时移动网络如果已经断开，接着会重连并回调结果给ConnectivityManager。当Android上层APP访问网络时，如果APP没有明确请求网络的具体类型，通常会走手机默认网络类型。
android 10.0 wifi以太网共存1
08-03
android 10 wifi以太网共存wifi上局域网，以太网上外网，只能这样，测试同时打开，先打开以太网再打开wifi，或者先打开wifi再打开以太网都可以
Android12多网共存patch
09-11
Android12多网共存patch
android11 多网络共存补丁
02-27
在技术层面，多网络共存补丁在Android系统的网络堆栈中做了底层的优化，包括优化了网络状态监控、流量分配算法以及接口优先级管理等方面。这些改进不仅提升了网络的用户体验，也为开发者提供了更多功能强大的网络API...
Android 10.0 以太网和wifi共存的产品wifi优先级设置功能实现
安卓兼职framework和app工程师的博客
06-20 1452
在10.0的系统ROM定制化开发中，在对于一些有线网和wifi共存的产品中，由于某些产品的特殊要求首选使用wifi,而在原生 系统中以太网的优先级高于wifi的，所以就需要从优先级的设置来分析，实现设置优先级的相关功能实现
Android14 Settings应用添加有线网开关条目实现
wenzhi的博客
03-26 1139
背景：Android 原生Settings应用没有有线网开关条目；Tv平台一般是有有线网连接的，如果没有有线网控制条目是不太方便的；如果要在原生Settings添加有线网开关和显示有线网ip，要如何实现呢？目前主要的商显TV中，只有我开发的方案中有些原生设置Settings 在某些方案上有修改了原生Settings的添加有线网开关控制，视源、朗国、创维、三星那些都是没修改的。本文简单实现一下，有需要的可以参考修改。
android 14 应用app绑定特定网络，以太网，WiFi，数据网络等
honffeCN的专栏
10-10 981
在多网络共存的系统中，例如 4G/5G，WiFi，以太网1 eth0，以太网2 eth1等共存的情况下，应用如何指定特定网络，通过指定的网络进行数据访问呢？// 如果是通过WiFi，可以通过 req.addTransportType(NetworkCapabilities.TRANSPORT_WIFI);// 在这里进行联网等操作，或者发送消息，然后进行网络相关操作，就是通过设定的网络出口进行通信了。4. 可以把这个放到第2步的 bindProcessToNetwork 之后，也可以是其他形式。
Android 9以太网与WIFI共存
码点
07-06 782
解决思路，在以太网口连接时，不发送断开以太网的广播。实际场景是以太网连接一个摄像头，实时传输视频。连接摄像头传输视频正常，WIFI上网也正常。以上是常规操作，实现以太网与WIFI共存。这个应该就是视频断开一下，再连接上的原因。Android 9以太网与WIFI共存。
Android 网络优先级调整
qijian0503的专栏
11-23 3937
android 网络优先级默认为 以太网 --> Wifi --> 移动数据 有一些同学想在多同络情况下 默认使用 wifi 或者 以太网 那么这就涉及到更改系统网络默认优先级，系统的网络优先级是从 frameworks\base\core\res\res\values\config.xml中读取出来的，读取的属性为 <string-array tra...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值