Loading core/java/android/net/ConnectivityDiagnosticsManager.java +8 −0 Original line number Diff line number Diff line Loading @@ -711,6 +711,13 @@ public class ConnectivityDiagnosticsManager { * not currently registered. If a ConnectivityDiagnosticsCallback instance is registered with * multiple NetworkRequests, an IllegalArgumentException will be thrown. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * callbacks in {@link ConnectivityManager}. Registering a callback with this method will count * toward this limit. If this limit is exceeded, an exception will be thrown. To avoid hitting * this issue and to conserve resources, make sure to unregister the callbacks with * {@link #unregisterConnectivityDiagnosticsCallback}. * * @param request The NetworkRequest that will be used to match with Networks for which * callbacks will be fired * @param e The Executor to be used for running the callback method invocations Loading @@ -718,6 +725,7 @@ public class ConnectivityDiagnosticsManager { * System * @throws IllegalArgumentException if the same callback instance is registered with multiple * NetworkRequests * @throws RuntimeException if the app already has too many callbacks registered. */ public void registerConnectivityDiagnosticsCallback( @NonNull NetworkRequest request, Loading core/java/android/net/ConnectivityManager.java +78 −9 Original line number Diff line number Diff line Loading @@ -3794,13 +3794,22 @@ public class ConnectivityManager { * or the ability to modify system settings as determined by * {@link android.provider.Settings.System#canWrite}.</p> * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #registerNetworkCallback} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note * the callback must not be shared - it uniquely specifies this request. * The callback is invoked on the default internal Handler. * @throws IllegalArgumentException if {@code request} contains invalid network capabilities. * @throws SecurityException if missing the appropriate permissions. * @throws RuntimeException if request limit per UID is exceeded. * @throws RuntimeException if the app already has too many callbacks registered. */ public void requestNetwork(@NonNull NetworkRequest request, @NonNull NetworkCallback networkCallback) { Loading @@ -3814,8 +3823,8 @@ public class ConnectivityManager { * but runs all the callbacks on the passed Handler. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback)} and throws the same exceptions in * the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading Loading @@ -3846,8 +3855,8 @@ public class ConnectivityManager { * for that purpose. Calling this method will attempt to bring up the requested network. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback)} and throws the same exceptions in * the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading @@ -3873,8 +3882,8 @@ public class ConnectivityManager { * on the passed Handler. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback, int)} and throws the same exceptions * in the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading Loading @@ -3943,6 +3952,15 @@ public class ConnectivityManager { * is unknown prior to bringing up the network so the framework does not * know how to go about satisfying a request with these capabilities. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #registerNetworkCallback} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with {@link #unregisterNetworkCallback(PendingIntent)} * or {@link #releaseNetworkRequest(PendingIntent)}. * * <p>This method requires the caller to hold either the * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission * or the ability to modify system settings as determined by Loading @@ -3954,7 +3972,7 @@ public class ConnectivityManager { * comes from {@link PendingIntent#getBroadcast}. Cannot be null. * @throws IllegalArgumentException if {@code request} contains invalid network capabilities. * @throws SecurityException if missing the appropriate permissions. * @throws RuntimeException if request limit per UID is exceeded. * @throws RuntimeException if the app already has too many callbacks registered. */ public void requestNetwork(@NonNull NetworkRequest request, @NonNull PendingIntent operation) { Loading Loading @@ -4010,10 +4028,20 @@ public class ConnectivityManager { * either the application exits or {@link #unregisterNetworkCallback(NetworkCallback)} is * called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} that the system will call as suitable * networks change state. * The callback is invoked on the default internal Handler. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading @@ -4027,10 +4055,21 @@ public class ConnectivityManager { * either the application exits or {@link #unregisterNetworkCallback(NetworkCallback)} is * called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} that the system will call as suitable * networks change state. * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading Loading @@ -4064,10 +4103,21 @@ public class ConnectivityManager { * <p> * The request may be released normally by calling * {@link #unregisterNetworkCallback(android.app.PendingIntent)}. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with {@link #unregisterNetworkCallback(PendingIntent)} * or {@link #releaseNetworkRequest(PendingIntent)}. * * @param request {@link NetworkRequest} describing this request. * @param operation Action to perform when the network is available (corresponds * to the {@link NetworkCallback#onAvailable} call. Typically * comes from {@link PendingIntent#getBroadcast}. Cannot be null. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading @@ -4089,9 +4139,19 @@ public class ConnectivityManager { * will continue to be called until either the application exits or * {@link #unregisterNetworkCallback(NetworkCallback)} is called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param networkCallback The {@link NetworkCallback} that the system will call as the * system default network changes. * The callback is invoked on the default internal Handler. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerDefaultNetworkCallback(@NonNull NetworkCallback networkCallback) { Loading @@ -4103,9 +4163,19 @@ public class ConnectivityManager { * will continue to be called until either the application exits or * {@link #unregisterNetworkCallback(NetworkCallback)} is called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param networkCallback The {@link NetworkCallback} that the system will call as the * system default network changes. * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerDefaultNetworkCallback(@NonNull NetworkCallback networkCallback, Loading Loading @@ -4197,7 +4267,6 @@ public class ConnectivityManager { * Cannot be null. */ public void unregisterNetworkCallback(@NonNull PendingIntent operation) { checkPendingIntentNotNull(operation); releaseNetworkRequest(operation); } Loading services/core/java/com/android/server/ConnectivityService.java +1 −1 Original line number Diff line number Diff line Loading @@ -6426,7 +6426,7 @@ public class ConnectivityService extends IConnectivityManager.Stub final boolean shouldFilter = requiresVpnIsolation(nai, newNc, nai.linkProperties); final String iface = nai.linkProperties.getInterfaceName(); // For VPN uid interface filtering, old ranges need to be removed before new ranges can // be added, due to the range being expanded and stored as invidiual UIDs. For example // be added, due to the range being expanded and stored as individual UIDs. For example // the UIDs might be updated from [0, 99999] to ([0, 10012], [10014, 99999]) which means // prevRanges = [0, 99999] while newRanges = [0, 10012], [10014, 99999]. If prevRanges // were added first and then newRanges got removed later, there would be only one uid Loading Loading
core/java/android/net/ConnectivityDiagnosticsManager.java +8 −0 Original line number Diff line number Diff line Loading @@ -711,6 +711,13 @@ public class ConnectivityDiagnosticsManager { * not currently registered. If a ConnectivityDiagnosticsCallback instance is registered with * multiple NetworkRequests, an IllegalArgumentException will be thrown. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * callbacks in {@link ConnectivityManager}. Registering a callback with this method will count * toward this limit. If this limit is exceeded, an exception will be thrown. To avoid hitting * this issue and to conserve resources, make sure to unregister the callbacks with * {@link #unregisterConnectivityDiagnosticsCallback}. * * @param request The NetworkRequest that will be used to match with Networks for which * callbacks will be fired * @param e The Executor to be used for running the callback method invocations Loading @@ -718,6 +725,7 @@ public class ConnectivityDiagnosticsManager { * System * @throws IllegalArgumentException if the same callback instance is registered with multiple * NetworkRequests * @throws RuntimeException if the app already has too many callbacks registered. */ public void registerConnectivityDiagnosticsCallback( @NonNull NetworkRequest request, Loading
core/java/android/net/ConnectivityManager.java +78 −9 Original line number Diff line number Diff line Loading @@ -3794,13 +3794,22 @@ public class ConnectivityManager { * or the ability to modify system settings as determined by * {@link android.provider.Settings.System#canWrite}.</p> * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #registerNetworkCallback} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note * the callback must not be shared - it uniquely specifies this request. * The callback is invoked on the default internal Handler. * @throws IllegalArgumentException if {@code request} contains invalid network capabilities. * @throws SecurityException if missing the appropriate permissions. * @throws RuntimeException if request limit per UID is exceeded. * @throws RuntimeException if the app already has too many callbacks registered. */ public void requestNetwork(@NonNull NetworkRequest request, @NonNull NetworkCallback networkCallback) { Loading @@ -3814,8 +3823,8 @@ public class ConnectivityManager { * but runs all the callbacks on the passed Handler. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback)} and throws the same exceptions in * the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading Loading @@ -3846,8 +3855,8 @@ public class ConnectivityManager { * for that purpose. Calling this method will attempt to bring up the requested network. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback)} and throws the same exceptions in * the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading @@ -3873,8 +3882,8 @@ public class ConnectivityManager { * on the passed Handler. * * <p>This method has the same permission requirements as * {@link #requestNetwork(NetworkRequest, NetworkCallback, int)} and throws the same exceptions * in the same conditions. * {@link #requestNetwork(NetworkRequest, NetworkCallback)}, is subject to the same limitations, * and throws the same exceptions in the same conditions. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} to be utilized for this request. Note Loading Loading @@ -3943,6 +3952,15 @@ public class ConnectivityManager { * is unknown prior to bringing up the network so the framework does not * know how to go about satisfying a request with these capabilities. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #registerNetworkCallback} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with {@link #unregisterNetworkCallback(PendingIntent)} * or {@link #releaseNetworkRequest(PendingIntent)}. * * <p>This method requires the caller to hold either the * {@link android.Manifest.permission#CHANGE_NETWORK_STATE} permission * or the ability to modify system settings as determined by Loading @@ -3954,7 +3972,7 @@ public class ConnectivityManager { * comes from {@link PendingIntent#getBroadcast}. Cannot be null. * @throws IllegalArgumentException if {@code request} contains invalid network capabilities. * @throws SecurityException if missing the appropriate permissions. * @throws RuntimeException if request limit per UID is exceeded. * @throws RuntimeException if the app already has too many callbacks registered. */ public void requestNetwork(@NonNull NetworkRequest request, @NonNull PendingIntent operation) { Loading Loading @@ -4010,10 +4028,20 @@ public class ConnectivityManager { * either the application exits or {@link #unregisterNetworkCallback(NetworkCallback)} is * called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} that the system will call as suitable * networks change state. * The callback is invoked on the default internal Handler. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading @@ -4027,10 +4055,21 @@ public class ConnectivityManager { * either the application exits or {@link #unregisterNetworkCallback(NetworkCallback)} is * called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * * @param request {@link NetworkRequest} describing this request. * @param networkCallback The {@link NetworkCallback} that the system will call as suitable * networks change state. * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading Loading @@ -4064,10 +4103,21 @@ public class ConnectivityManager { * <p> * The request may be released normally by calling * {@link #unregisterNetworkCallback(android.app.PendingIntent)}. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with {@link #unregisterNetworkCallback(PendingIntent)} * or {@link #releaseNetworkRequest(PendingIntent)}. * * @param request {@link NetworkRequest} describing this request. * @param operation Action to perform when the network is available (corresponds * to the {@link NetworkCallback#onAvailable} call. Typically * comes from {@link PendingIntent#getBroadcast}. Cannot be null. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerNetworkCallback(@NonNull NetworkRequest request, Loading @@ -4089,9 +4139,19 @@ public class ConnectivityManager { * will continue to be called until either the application exits or * {@link #unregisterNetworkCallback(NetworkCallback)} is called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param networkCallback The {@link NetworkCallback} that the system will call as the * system default network changes. * The callback is invoked on the default internal Handler. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerDefaultNetworkCallback(@NonNull NetworkCallback networkCallback) { Loading @@ -4103,9 +4163,19 @@ public class ConnectivityManager { * will continue to be called until either the application exits or * {@link #unregisterNetworkCallback(NetworkCallback)} is called. * * <p>To avoid performance issues due to apps leaking callbacks, the system will limit the * number of outstanding requests to 100 per app (identified by their UID), shared with * all variants of this method, of {@link #requestNetwork} as well as * {@link ConnectivityDiagnosticsManager#registerConnectivityDiagnosticsCallback}. * Requesting a network with this method will count toward this limit. If this limit is * exceeded, an exception will be thrown. To avoid hitting this issue and to conserve resources, * make sure to unregister the callbacks with * {@link #unregisterNetworkCallback(NetworkCallback)}. * * @param networkCallback The {@link NetworkCallback} that the system will call as the * system default network changes. * @param handler {@link Handler} to specify the thread upon which the callback will be invoked. * @throws RuntimeException if the app already has too many callbacks registered. */ @RequiresPermission(android.Manifest.permission.ACCESS_NETWORK_STATE) public void registerDefaultNetworkCallback(@NonNull NetworkCallback networkCallback, Loading Loading @@ -4197,7 +4267,6 @@ public class ConnectivityManager { * Cannot be null. */ public void unregisterNetworkCallback(@NonNull PendingIntent operation) { checkPendingIntentNotNull(operation); releaseNetworkRequest(operation); } Loading
services/core/java/com/android/server/ConnectivityService.java +1 −1 Original line number Diff line number Diff line Loading @@ -6426,7 +6426,7 @@ public class ConnectivityService extends IConnectivityManager.Stub final boolean shouldFilter = requiresVpnIsolation(nai, newNc, nai.linkProperties); final String iface = nai.linkProperties.getInterfaceName(); // For VPN uid interface filtering, old ranges need to be removed before new ranges can // be added, due to the range being expanded and stored as invidiual UIDs. For example // be added, due to the range being expanded and stored as individual UIDs. For example // the UIDs might be updated from [0, 99999] to ([0, 10012], [10014, 99999]) which means // prevRanges = [0, 99999] while newRanges = [0, 10012], [10014, 99999]. If prevRanges // were added first and then newRanges got removed later, there would be only one uid Loading
