1 /* 2 * Copyright (C) 2011 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17 package com.android.server.net; 18 19 import static android.Manifest.permission.CONNECTIVITY_USE_RESTRICTED_NETWORKS; 20 import static android.Manifest.permission.NETWORK_STACK; 21 import static android.app.ActivityManager.PROCESS_CAPABILITY_NONE; 22 import static android.app.ActivityManager.PROCESS_CAPABILITY_POWER_RESTRICTED_NETWORK; 23 import static android.app.ActivityManager.PROCESS_CAPABILITY_USER_RESTRICTED_NETWORK; 24 import static android.app.ActivityManager.PROCESS_STATE_IMPORTANT_FOREGROUND; 25 import static android.app.ActivityManager.PROCESS_STATE_SERVICE; 26 import static android.app.ActivityManager.PROCESS_STATE_TOP; 27 import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_DATA_SAVER; 28 import static android.net.ConnectivityManager.BLOCKED_METERED_REASON_USER_RESTRICTED; 29 import static android.net.ConnectivityManager.BLOCKED_REASON_APP_STANDBY; 30 import static android.net.ConnectivityManager.BLOCKED_REASON_BATTERY_SAVER; 31 import static android.net.ConnectivityManager.BLOCKED_REASON_DOZE; 32 import static android.net.ConnectivityManager.BLOCKED_REASON_LOW_POWER_STANDBY; 33 import static android.net.ConnectivityManager.BLOCKED_REASON_NONE; 34 import static android.net.ConnectivityManager.CONNECTIVITY_ACTION; 35 import static android.net.ConnectivityManager.FIREWALL_CHAIN_LOW_POWER_STANDBY; 36 import static android.net.ConnectivityManager.FIREWALL_CHAIN_RESTRICTED; 37 import static android.net.ConnectivityManager.TYPE_MOBILE; 38 import static android.net.ConnectivityManager.TYPE_WIFI; 39 import static android.net.INetd.FIREWALL_RULE_ALLOW; 40 import static android.net.NetworkCapabilities.NET_CAPABILITY_NOT_ROAMING; 41 import static android.net.NetworkCapabilities.TRANSPORT_CELLULAR; 42 import static android.net.NetworkCapabilities.TRANSPORT_WIFI; 43 import static android.net.NetworkPolicy.LIMIT_DISABLED; 44 import static android.net.NetworkPolicy.SNOOZE_NEVER; 45 import static android.net.NetworkPolicy.WARNING_DISABLED; 46 import static android.net.NetworkPolicyManager.ALLOWED_METERED_REASON_FOREGROUND; 47 import static android.net.NetworkPolicyManager.ALLOWED_METERED_REASON_SYSTEM; 48 import static android.net.NetworkPolicyManager.ALLOWED_REASON_FOREGROUND; 49 import static android.net.NetworkPolicyManager.ALLOWED_REASON_LOW_POWER_STANDBY_ALLOWLIST; 50 import static android.net.NetworkPolicyManager.ALLOWED_REASON_NONE; 51 import static android.net.NetworkPolicyManager.ALLOWED_REASON_SYSTEM; 52 import static android.net.NetworkPolicyManager.ALLOWED_REASON_TOP; 53 import static android.net.NetworkPolicyManager.FIREWALL_RULE_DEFAULT; 54 import static android.net.NetworkPolicyManager.POLICY_ALLOW_METERED_BACKGROUND; 55 import static android.net.NetworkPolicyManager.POLICY_NONE; 56 import static android.net.NetworkPolicyManager.POLICY_REJECT_METERED_BACKGROUND; 57 import static android.net.NetworkPolicyManager.allowedReasonsToString; 58 import static android.net.NetworkPolicyManager.blockedReasonsToString; 59 import static android.net.NetworkPolicyManager.uidPoliciesToString; 60 import static android.net.NetworkPolicyManager.uidRulesToString; 61 import static android.net.NetworkStack.PERMISSION_MAINLINE_NETWORK_STACK; 62 import static android.net.NetworkStats.METERED_NO; 63 import static android.net.NetworkStats.METERED_YES; 64 import static android.net.NetworkTemplate.MATCH_CARRIER; 65 import static android.net.NetworkTemplate.MATCH_MOBILE; 66 import static android.net.NetworkTemplate.MATCH_WIFI; 67 import static android.telephony.CarrierConfigManager.ACTION_CARRIER_CONFIG_CHANGED; 68 import static android.telephony.CarrierConfigManager.DATA_CYCLE_THRESHOLD_DISABLED; 69 import static android.telephony.CarrierConfigManager.DATA_CYCLE_USE_PLATFORM_DEFAULT; 70 import static android.telephony.CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG; 71 import static android.telephony.CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG; 72 import static android.telephony.CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT; 73 import static android.telephony.SubscriptionPlan.BYTES_UNLIMITED; 74 import static android.telephony.SubscriptionPlan.LIMIT_BEHAVIOR_DISABLED; 75 76 import static com.android.server.net.NetworkPolicyManagerInternal.QUOTA_TYPE_JOBS; 77 import static com.android.server.net.NetworkPolicyManagerInternal.QUOTA_TYPE_MULTIPATH; 78 import static com.android.server.net.NetworkPolicyManagerService.OPPORTUNISTIC_QUOTA_UNKNOWN; 79 import static com.android.server.net.NetworkPolicyManagerService.TYPE_LIMIT; 80 import static com.android.server.net.NetworkPolicyManagerService.TYPE_LIMIT_SNOOZED; 81 import static com.android.server.net.NetworkPolicyManagerService.TYPE_RAPID; 82 import static com.android.server.net.NetworkPolicyManagerService.TYPE_WARNING; 83 import static com.android.server.net.NetworkPolicyManagerService.UidBlockedState.getEffectiveBlockedReasons; 84 import static com.android.server.net.NetworkPolicyManagerService.normalizeTemplate; 85 86 import static org.junit.Assert.assertEquals; 87 import static org.junit.Assert.assertFalse; 88 import static org.junit.Assert.assertNotNull; 89 import static org.junit.Assert.assertNull; 90 import static org.junit.Assert.assertTrue; 91 import static org.junit.Assert.fail; 92 import static org.mockito.ArgumentMatchers.any; 93 import static org.mockito.ArgumentMatchers.anyBoolean; 94 import static org.mockito.ArgumentMatchers.anyInt; 95 import static org.mockito.ArgumentMatchers.anyLong; 96 import static org.mockito.ArgumentMatchers.anyString; 97 import static org.mockito.ArgumentMatchers.eq; 98 import static org.mockito.ArgumentMatchers.isA; 99 import static org.mockito.Mockito.CALLS_REAL_METHODS; 100 import static org.mockito.Mockito.atLeast; 101 import static org.mockito.Mockito.atLeastOnce; 102 import static org.mockito.Mockito.clearInvocations; 103 import static org.mockito.Mockito.doAnswer; 104 import static org.mockito.Mockito.doNothing; 105 import static org.mockito.Mockito.mock; 106 import static org.mockito.Mockito.never; 107 import static org.mockito.Mockito.reset; 108 import static org.mockito.Mockito.times; 109 import static org.mockito.Mockito.verify; 110 import static org.mockito.Mockito.when; 111 112 import android.Manifest; 113 import android.app.ActivityManager; 114 import android.app.ActivityManagerInternal; 115 import android.app.IActivityManager; 116 import android.app.IUidObserver; 117 import android.app.Notification; 118 import android.app.NotificationManager; 119 import android.app.usage.NetworkStats; 120 import android.app.usage.NetworkStatsManager; 121 import android.app.usage.UsageStatsManagerInternal; 122 import android.content.BroadcastReceiver; 123 import android.content.Context; 124 import android.content.Intent; 125 import android.content.IntentFilter; 126 import android.content.pm.ApplicationInfo; 127 import android.content.pm.IPackageManager; 128 import android.content.pm.PackageInfo; 129 import android.content.pm.PackageManager; 130 import android.content.pm.PackageManagerInternal; 131 import android.content.pm.Signature; 132 import android.content.pm.UserInfo; 133 import android.net.ConnectivityManager; 134 import android.net.INetworkManagementEventObserver; 135 import android.net.INetworkPolicyListener; 136 import android.net.LinkProperties; 137 import android.net.Network; 138 import android.net.NetworkCapabilities; 139 import android.net.NetworkPolicy; 140 import android.net.NetworkStateSnapshot; 141 import android.net.NetworkTemplate; 142 import android.net.TelephonyNetworkSpecifier; 143 import android.net.wifi.WifiInfo; 144 import android.os.Binder; 145 import android.os.Build; 146 import android.os.Handler; 147 import android.os.INetworkManagementService; 148 import android.os.PersistableBundle; 149 import android.os.PowerManagerInternal; 150 import android.os.PowerSaveState; 151 import android.os.RemoteException; 152 import android.os.SimpleClock; 153 import android.os.UserHandle; 154 import android.os.UserManager; 155 import android.platform.test.annotations.Presubmit; 156 import android.telephony.CarrierConfigManager; 157 import android.telephony.SubscriptionInfo; 158 import android.telephony.SubscriptionManager; 159 import android.telephony.SubscriptionPlan; 160 import android.telephony.TelephonyManager; 161 import android.test.suitebuilder.annotation.MediumTest; 162 import android.text.TextUtils; 163 import android.util.ArrayMap; 164 import android.util.ArraySet; 165 import android.util.DataUnit; 166 import android.util.Log; 167 import android.util.Pair; 168 import android.util.Range; 169 import android.util.RecurrenceRule; 170 import android.util.SparseArray; 171 172 import androidx.test.InstrumentationRegistry; 173 import androidx.test.filters.FlakyTest; 174 import androidx.test.runner.AndroidJUnit4; 175 176 import com.android.internal.util.test.BroadcastInterceptingContext; 177 import com.android.internal.util.test.BroadcastInterceptingContext.FutureIntent; 178 import com.android.internal.util.test.FsUtil; 179 import com.android.server.DeviceIdleInternal; 180 import com.android.server.LocalServices; 181 import com.android.server.pm.pkg.AndroidPackage; 182 import com.android.server.usage.AppStandbyInternal; 183 184 import com.google.common.util.concurrent.AbstractFuture; 185 186 import libcore.io.Streams; 187 188 import org.junit.After; 189 import org.junit.Assume; 190 import org.junit.Before; 191 import org.junit.Rule; 192 import org.junit.Test; 193 import org.junit.rules.MethodRule; 194 import org.junit.runner.RunWith; 195 import org.junit.runners.model.FrameworkMethod; 196 import org.junit.runners.model.Statement; 197 import org.mockito.ArgumentCaptor; 198 import org.mockito.Mock; 199 import org.mockito.MockitoAnnotations; 200 import org.mockito.invocation.InvocationOnMock; 201 import org.mockito.stubbing.Answer; 202 203 import java.io.File; 204 import java.io.FileOutputStream; 205 import java.io.InputStream; 206 import java.io.OutputStream; 207 import java.lang.annotation.Annotation; 208 import java.lang.annotation.ElementType; 209 import java.lang.annotation.Retention; 210 import java.lang.annotation.RetentionPolicy; 211 import java.lang.annotation.Target; 212 import java.time.Clock; 213 import java.time.Instant; 214 import java.time.Period; 215 import java.time.ZoneId; 216 import java.time.ZoneOffset; 217 import java.time.ZonedDateTime; 218 import java.util.ArrayList; 219 import java.util.Arrays; 220 import java.util.Calendar; 221 import java.util.HashMap; 222 import java.util.Iterator; 223 import java.util.LinkedHashSet; 224 import java.util.List; 225 import java.util.Map; 226 import java.util.Set; 227 import java.util.TimeZone; 228 import java.util.concurrent.CountDownLatch; 229 import java.util.concurrent.ExecutionException; 230 import java.util.concurrent.Future; 231 import java.util.concurrent.TimeUnit; 232 import java.util.concurrent.TimeoutException; 233 import java.util.function.Consumer; 234 import java.util.stream.Collectors; 235 236 /** 237 * Tests for {@link NetworkPolicyManagerService}. 238 */ 239 @RunWith(AndroidJUnit4.class) 240 @MediumTest 241 @Presubmit 242 public class NetworkPolicyManagerServiceTest { 243 private static final String TAG = "NetworkPolicyManagerServiceTest"; 244 245 private static final long TEST_START = 1194220800000L; 246 private static final String TEST_IFACE = "test0"; 247 private static final String TEST_WIFI_NETWORK_KEY = "TestWifiNetworkKey"; 248 private static final String TEST_IMSI = "310210"; 249 private static final int TEST_SUB_ID = 42; 250 private static final Network TEST_NETWORK = mock(Network.class, CALLS_REAL_METHODS); 251 252 private static NetworkTemplate sTemplateWifi = new NetworkTemplate.Builder(MATCH_WIFI) 253 .setWifiNetworkKeys(Set.of(TEST_WIFI_NETWORK_KEY)).build(); 254 private static NetworkTemplate sTemplateCarrierMetered = 255 new NetworkTemplate.Builder(MATCH_CARRIER) 256 .setSubscriberIds(Set.of(TEST_IMSI)) 257 .setMeteredness(METERED_YES).build(); 258 259 /** 260 * Path on assets where files used by {@link NetPolicyXml} are located. 261 */ 262 private static final String NETPOLICY_DIR = "NetworkPolicyManagerServiceTest/netpolicy"; 263 private static final String TIMEZONE_UTC = "UTC"; 264 265 private BroadcastInterceptingContext mServiceContext; 266 private File mPolicyDir; 267 268 /** 269 * Relative path of the XML file that will be used as {@code netpolicy.xml}. 270 * 271 * <p>Typically set through a {@link NetPolicyXml} annotation in the test method. 272 */ 273 private String mNetpolicyXml; 274 275 private @Mock IActivityManager mActivityManager; 276 private @Mock INetworkManagementService mNetworkManager; 277 private @Mock ConnectivityManager mConnManager; 278 private @Mock NotificationManager mNotifManager; 279 private @Mock PackageManager mPackageManager; 280 private @Mock IPackageManager mIpm; 281 private @Mock SubscriptionManager mSubscriptionManager; 282 private @Mock CarrierConfigManager mCarrierConfigManager; 283 private @Mock TelephonyManager mTelephonyManager; 284 private @Mock UserManager mUserManager; 285 private @Mock NetworkStatsManager mStatsManager; 286 private TestDependencies mDeps; 287 288 private ArgumentCaptor<ConnectivityManager.NetworkCallback> mNetworkCallbackCaptor = 289 ArgumentCaptor.forClass(ConnectivityManager.NetworkCallback.class); 290 291 private ActivityManagerInternal mActivityManagerInternal; 292 private PackageManagerInternal mPackageManagerInternal; 293 294 private IUidObserver mUidObserver; 295 private INetworkManagementEventObserver mNetworkObserver; 296 297 private NetworkPolicyListenerAnswer mPolicyListener; 298 private NetworkPolicyManagerService mService; 299 300 private final ArraySet<BroadcastReceiver> mRegisteredReceivers = new ArraySet<>(); 301 302 /** 303 * In some of the tests while initializing NetworkPolicyManagerService, 304 * ACTION_RESTRICT_BACKGROUND_CHANGED is broadcasted. This is for capturing that broadcast. 305 */ 306 private FutureIntent mFutureIntent; 307 308 private long mStartTime; 309 private long mElapsedRealtime; 310 311 private static final int USER_ID = 0; 312 private static final int FAKE_SUB_ID = 3737373; 313 private static final String FAKE_SUBSCRIBER_ID = "FAKE_SUBSCRIBER_ID"; 314 private static final int DEFAULT_CYCLE_DAY = 1; 315 private static final int INVALID_CARRIER_CONFIG_VALUE = -9999; 316 private long mDefaultWarningBytes; // filled in with the actual default before tests are run 317 private long mDefaultLimitBytes; // filled in with the actual default before tests are run 318 private PersistableBundle mCarrierConfig = CarrierConfigManager.getDefaultConfig(); 319 320 private static final int APP_ID_A = android.os.Process.FIRST_APPLICATION_UID + 4; 321 private static final int APP_ID_B = android.os.Process.FIRST_APPLICATION_UID + 8; 322 private static final int APP_ID_C = android.os.Process.FIRST_APPLICATION_UID + 15; 323 private static final int APP_ID_D = android.os.Process.FIRST_APPLICATION_UID + 16; 324 private static final int APP_ID_E = android.os.Process.FIRST_APPLICATION_UID + 23; 325 private static final int APP_ID_F = android.os.Process.FIRST_APPLICATION_UID + 42; 326 327 private static final int UID_A = UserHandle.getUid(USER_ID, APP_ID_A); 328 private static final int UID_B = UserHandle.getUid(USER_ID, APP_ID_B); 329 private static final int UID_C = UserHandle.getUid(USER_ID, APP_ID_C); 330 private static final int UID_D = UserHandle.getUid(USER_ID, APP_ID_D); 331 private static final int UID_E = UserHandle.getUid(USER_ID, APP_ID_E); 332 private static final int UID_F = UserHandle.getUid(USER_ID, APP_ID_F); 333 334 private static final String PKG_NAME_A = "name.is.A,pkg.A"; 335 private static final String PKG_NAME_B = "name.is.B,pkg.B"; 336 private static final String PKG_NAME_C = "name.is.C,pkg.C"; 337 338 public final @Rule NetPolicyMethodRule mNetPolicyXmlRule = new NetPolicyMethodRule(); 339 340 private final Clock mClock = new SimpleClock(ZoneOffset.UTC) { 341 @Override 342 public long millis() { 343 return currentTimeMillis(); 344 } 345 }; 346 registerLocalServices()347 private void registerLocalServices() { 348 addLocalServiceMock(DeviceIdleInternal.class); 349 addLocalServiceMock(AppStandbyInternal.class); 350 351 final UsageStatsManagerInternal usageStats = 352 addLocalServiceMock(UsageStatsManagerInternal.class); 353 when(usageStats.getIdleUidsForUser(anyInt())).thenReturn(new int[]{}); 354 355 mActivityManagerInternal = addLocalServiceMock(ActivityManagerInternal.class); 356 mPackageManagerInternal = addLocalServiceMock(PackageManagerInternal.class); 357 358 final PowerSaveState state = new PowerSaveState.Builder() 359 .setBatterySaverEnabled(false).build(); 360 final PowerManagerInternal pmInternal = addLocalServiceMock(PowerManagerInternal.class); 361 when(pmInternal.getLowPowerState(anyInt())).thenReturn(state); 362 } 363 364 private class TestDependencies extends NetworkPolicyManagerService.Dependencies { 365 private final SparseArray<NetworkStats.Bucket> mMockedStats = new SparseArray<>(); 366 TestDependencies(Context context)367 TestDependencies(Context context) { 368 super(context); 369 } 370 371 @Override getNetworkTotalBytes(NetworkTemplate template, long start, long end)372 long getNetworkTotalBytes(NetworkTemplate template, long start, long end) { 373 int total = 0; 374 for (int i = 0; i < mMockedStats.size(); i++) { 375 NetworkStats.Bucket bucket = mMockedStats.valueAt(i); 376 total += bucket.getRxBytes() + bucket.getTxBytes(); 377 } 378 return total; 379 } 380 381 @Override getNetworkUidBytes(NetworkTemplate template, long start, long end)382 List<NetworkStats.Bucket> getNetworkUidBytes(NetworkTemplate template, long start, 383 long end) { 384 final List<NetworkStats.Bucket> ret = new ArrayList<>(); 385 for (int i = 0; i < mMockedStats.size(); i++) { 386 ret.add(mMockedStats.valueAt(i)); 387 } 388 return ret; 389 } 390 setMockedTotalBytes(int uid, long rxBytes, long txBytes)391 private void setMockedTotalBytes(int uid, long rxBytes, long txBytes) { 392 final NetworkStats.Bucket bucket = mock(NetworkStats.Bucket.class); 393 when(bucket.getUid()).thenReturn(uid); 394 when(bucket.getRxBytes()).thenReturn(rxBytes); 395 when(bucket.getTxBytes()).thenReturn(txBytes); 396 mMockedStats.set(uid, bucket); 397 } 398 increaseMockedTotalBytes(int uid, long rxBytes, long txBytes)399 private void increaseMockedTotalBytes(int uid, long rxBytes, long txBytes) { 400 final NetworkStats.Bucket bucket = mMockedStats.get(uid); 401 setMockedTotalBytes(uid, bucket.getRxBytes() + rxBytes, bucket.getTxBytes() + txBytes); 402 } 403 } 404 405 // TODO: Use TestLooperManager instead. 406 /** 407 * Helper that leverages try-with-resources to pause dispatch of 408 * {@link #mHandlerThread} until released. 409 */ 410 static class SyncBarrier implements AutoCloseable { 411 private final int mToken; 412 private Handler mHandler; 413 SyncBarrier(Handler handler)414 SyncBarrier(Handler handler) { 415 mHandler = handler; 416 mToken = mHandler.getLooper().getQueue().postSyncBarrier(); 417 } 418 419 @Override close()420 public void close() throws Exception { 421 mHandler.getLooper().getQueue().removeSyncBarrier(mToken); 422 } 423 } 424 425 @Before callSystemReady()426 public void callSystemReady() throws Exception { 427 MockitoAnnotations.initMocks(this); 428 429 final Context context = InstrumentationRegistry.getContext(); 430 431 setCurrentTimeMillis(TEST_START); 432 433 registerLocalServices(); 434 // Intercept various broadcasts, and pretend that uids have packages. 435 // Also return mock service instances for a few critical services. 436 mServiceContext = new BroadcastInterceptingContext(context) { 437 @Override 438 public PackageManager getPackageManager() { 439 return mPackageManager; 440 } 441 442 @Override 443 public void startActivity(Intent intent) { 444 // ignored 445 } 446 447 @Override 448 public Object getSystemService(String name) { 449 switch (name) { 450 case Context.TELEPHONY_SUBSCRIPTION_SERVICE: 451 return mSubscriptionManager; 452 case Context.CARRIER_CONFIG_SERVICE: 453 return mCarrierConfigManager; 454 case Context.TELEPHONY_SERVICE: 455 return mTelephonyManager; 456 case Context.NOTIFICATION_SERVICE: 457 return mNotifManager; 458 case Context.CONNECTIVITY_SERVICE: 459 return mConnManager; 460 case Context.USER_SERVICE: 461 return mUserManager; 462 case Context.NETWORK_STATS_SERVICE: 463 return mStatsManager; 464 default: 465 return super.getSystemService(name); 466 } 467 } 468 469 @Override 470 public void enforceCallingOrSelfPermission(String permission, String message) { 471 // Assume that we're AID_SYSTEM 472 } 473 474 @Override 475 public Intent registerReceiver(BroadcastReceiver receiver, 476 IntentFilter filter, String broadcastPermission, Handler scheduler) { 477 mRegisteredReceivers.add(receiver); 478 return super.registerReceiver(receiver, filter, broadcastPermission, scheduler); 479 } 480 481 @Override 482 public Intent registerReceiverForAllUsers(BroadcastReceiver receiver, 483 IntentFilter filter, String broadcastPermission, Handler scheduler) { 484 mRegisteredReceivers.add(receiver); 485 return super.registerReceiverForAllUsers(receiver, filter, broadcastPermission, 486 scheduler); 487 } 488 }; 489 490 setNetpolicyXml(context); 491 492 doAnswer(new Answer<Void>() { 493 @Override 494 public Void answer(InvocationOnMock invocation) throws Throwable { 495 mUidObserver = (IUidObserver) invocation.getArguments()[0]; 496 Log.d(TAG, "set mUidObserver to " + mUidObserver); 497 return null; 498 } 499 }).when(mActivityManagerInternal).registerNetworkPolicyUidObserver(any(), 500 anyInt(), anyInt(), any(String.class)); 501 502 mFutureIntent = newRestrictBackgroundChangedFuture(); 503 mDeps = new TestDependencies(mServiceContext); 504 mService = new NetworkPolicyManagerService(mServiceContext, mActivityManager, 505 mNetworkManager, mIpm, mClock, mPolicyDir, true, mDeps); 506 mService.bindConnectivityManager(); 507 mPolicyListener = new NetworkPolicyListenerAnswer(mService); 508 509 // Sets some common expectations. 510 when(mPackageManager.getPackageInfo(anyString(), anyInt())).thenAnswer( 511 new Answer<PackageInfo>() { 512 513 @Override 514 public PackageInfo answer(InvocationOnMock invocation) throws Throwable { 515 final String packageName = (String) invocation.getArguments()[0]; 516 final PackageInfo info = new PackageInfo(); 517 final Signature signature; 518 if ("android".equals(packageName)) { 519 signature = new Signature("F00D"); 520 } else { 521 signature = new Signature("DEAD"); 522 } 523 info.signatures = new Signature[] { 524 signature 525 }; 526 return info; 527 } 528 }); 529 when(mPackageManager.getApplicationInfoAsUser(anyString(), anyInt(), anyInt())) 530 .thenReturn(new ApplicationInfo()); 531 when(mPackageManager.getPackagesForUid(UID_A)).thenReturn(new String[] {PKG_NAME_A}); 532 when(mPackageManager.getPackagesForUid(UID_B)).thenReturn(new String[] {PKG_NAME_B}); 533 when(mPackageManager.getPackagesForUid(UID_C)).thenReturn(new String[] {PKG_NAME_C}); 534 when(mPackageManager.getApplicationInfo(eq(PKG_NAME_A), anyInt())) 535 .thenReturn(buildApplicationInfo(PKG_NAME_A, UID_A)); 536 when(mPackageManager.getApplicationInfo(eq(PKG_NAME_B), anyInt())) 537 .thenReturn(buildApplicationInfo(PKG_NAME_B, UID_B)); 538 when(mPackageManager.getApplicationInfo(eq(PKG_NAME_C), anyInt())) 539 .thenReturn(buildApplicationInfo(PKG_NAME_C, UID_C)); 540 doAnswer(arg -> { 541 final Consumer<AndroidPackage> consumer = 542 (Consumer<AndroidPackage>) arg.getArguments()[0]; 543 for (AndroidPackage androidPackage : buildInstalledPackageList()) { 544 consumer.accept(androidPackage); 545 } 546 return null; 547 }).when(mPackageManagerInternal).forEachInstalledPackage( 548 any(Consumer.class), anyInt()); 549 when(mUserManager.getUsers()).thenReturn(buildUserInfoList()); 550 when(mNetworkManager.isBandwidthControlEnabled()).thenReturn(true); 551 when(mNetworkManager.setDataSaverModeEnabled(anyBoolean())).thenReturn(true); 552 doNothing().when(mConnManager) 553 .registerNetworkCallback(any(), mNetworkCallbackCaptor.capture()); 554 555 // Create the expected carrier config 556 mCarrierConfig.putBoolean(CarrierConfigManager.KEY_CARRIER_CONFIG_APPLIED_BOOL, true); 557 558 // Prepare NPMS. 559 mService.systemReady(mService.networkScoreAndNetworkManagementServiceReady()); 560 561 // catch INetworkManagementEventObserver during systemReady() 562 final ArgumentCaptor<INetworkManagementEventObserver> networkObserver = 563 ArgumentCaptor.forClass(INetworkManagementEventObserver.class); 564 verify(mNetworkManager).registerObserver(networkObserver.capture()); 565 mNetworkObserver = networkObserver.getValue(); 566 567 // Catch UsageCallback during systemReady(). Simulate NetworkStatsService triggered 568 // stats updated callback to signal its readiness. 569 final ArgumentCaptor<NetworkStatsManager.UsageCallback> usageObserver = 570 ArgumentCaptor.forClass(NetworkStatsManager.UsageCallback.class); 571 verify(mStatsManager, times(2)) 572 .registerUsageCallback(any(), anyLong(), any(), usageObserver.capture()); 573 // It doesn't matter which of the observers is returned here. 574 usageObserver.getValue().onThresholdReached( 575 new NetworkTemplate.Builder(MATCH_MOBILE).build()); 576 577 NetworkPolicy defaultPolicy = mService.buildDefaultCarrierPolicy(0, ""); 578 mDefaultWarningBytes = defaultPolicy.warningBytes; 579 mDefaultLimitBytes = defaultPolicy.limitBytes; 580 } 581 582 @After removeFiles()583 public void removeFiles() throws Exception { 584 for (File file : mPolicyDir.listFiles()) { 585 file.delete(); 586 } 587 } 588 589 @After unregisterLocalServices()590 public void unregisterLocalServices() throws Exception { 591 // Registered by NetworkPolicyManagerService's constructor. 592 LocalServices.removeServiceForTest(NetworkPolicyManagerInternal.class); 593 594 // Added in registerLocalServices() 595 LocalServices.removeServiceForTest(ActivityManagerInternal.class); 596 LocalServices.removeServiceForTest(PowerManagerInternal.class); 597 LocalServices.removeServiceForTest(DeviceIdleInternal.class); 598 LocalServices.removeServiceForTest(AppStandbyInternal.class); 599 LocalServices.removeServiceForTest(UsageStatsManagerInternal.class); 600 LocalServices.removeServiceForTest(PackageManagerInternal.class); 601 } 602 603 @After resetClock()604 public void resetClock() throws Exception { 605 RecurrenceRule.sClock = Clock.systemDefaultZone(); 606 } 607 608 @After unregisterReceivers()609 public void unregisterReceivers() throws Exception { 610 for (BroadcastReceiver receiver : mRegisteredReceivers) { 611 mServiceContext.unregisterReceiver(receiver); 612 } 613 } 614 615 @Test testTurnRestrictBackgroundOn()616 public void testTurnRestrictBackgroundOn() throws Exception { 617 assertRestrictBackgroundOff(); 618 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 619 setRestrictBackground(true); 620 assertRestrictBackgroundChangedReceived(futureIntent, null); 621 } 622 623 @Test 624 @NetPolicyXml("restrict-background-on.xml") testTurnRestrictBackgroundOff()625 public void testTurnRestrictBackgroundOff() throws Exception { 626 assertRestrictBackgroundOn(); 627 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 628 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 629 setRestrictBackground(false); 630 assertRestrictBackgroundChangedReceived(futureIntent, null); 631 } 632 633 /** 634 * Adds an app to allowlist when restrict background is on - app should receive an intent. 635 */ 636 @Test 637 @NetPolicyXml("restrict-background-on.xml") testAddRestrictBackgroundAllowlist_restrictBackgroundOn()638 public void testAddRestrictBackgroundAllowlist_restrictBackgroundOn() throws Exception { 639 assertRestrictBackgroundOn(); 640 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 641 addRestrictBackgroundAllowlist(true); 642 } 643 644 /** 645 * Adds an app to allowlist when restrict background is off - app should not receive an intent. 646 */ 647 @Test testAddRestrictBackgroundAllowlist_restrictBackgroundOff()648 public void testAddRestrictBackgroundAllowlist_restrictBackgroundOff() throws Exception { 649 assertRestrictBackgroundOff(); 650 addRestrictBackgroundAllowlist(false); 651 } 652 addRestrictBackgroundAllowlist(boolean expectIntent)653 private void addRestrictBackgroundAllowlist(boolean expectIntent) throws Exception { 654 assertRestrictBackgroundAllowedUids(); 655 assertUidPolicy(UID_A, POLICY_NONE); 656 657 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 658 mPolicyListener.expect().onUidPoliciesChanged(anyInt(), anyInt()); 659 660 mService.setUidPolicy(UID_A, POLICY_ALLOW_METERED_BACKGROUND); 661 662 assertRestrictBackgroundAllowedUids(UID_A); 663 assertUidPolicy(UID_A, POLICY_ALLOW_METERED_BACKGROUND); 664 mPolicyListener.waitAndVerify() 665 .onUidPoliciesChanged(APP_ID_A, POLICY_ALLOW_METERED_BACKGROUND); 666 if (expectIntent) { 667 assertRestrictBackgroundChangedReceived(futureIntent, PKG_NAME_A); 668 } else { 669 futureIntent.assertNotReceived(); 670 } 671 } 672 673 /** 674 * Removes an app from allowlist when restrict background is on - app should receive an intent. 675 */ 676 @Test 677 @NetPolicyXml("uidA-allowed-restrict-background-on.xml") testRemoveRestrictBackgroundAllowlist_restrictBackgroundOn()678 public void testRemoveRestrictBackgroundAllowlist_restrictBackgroundOn() throws Exception { 679 assertRestrictBackgroundOn(); 680 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 681 removeRestrictBackgroundAllowlist(true); 682 } 683 684 /** 685 * Removes an app from allowlist when restrict background is off - app should not 686 * receive an intent. 687 */ 688 @Test 689 @NetPolicyXml("uidA-allowed-restrict-background-off.xml") testRemoveRestrictBackgroundAllowlist_restrictBackgroundOff()690 public void testRemoveRestrictBackgroundAllowlist_restrictBackgroundOff() throws Exception { 691 assertRestrictBackgroundOff(); 692 removeRestrictBackgroundAllowlist(false); 693 } 694 695 @Test testLowPowerModeObserver_ListenersRegistered()696 public void testLowPowerModeObserver_ListenersRegistered() 697 throws Exception { 698 PowerManagerInternal pmInternal = LocalServices.getService(PowerManagerInternal.class); 699 700 verify(pmInternal, atLeast(2)).registerLowPowerModeObserver(any()); 701 } 702 703 @Test updateRestrictBackgroundByLowPowerMode_RestrictOnBeforeBsm_RestrictOnAfterBsm()704 public void updateRestrictBackgroundByLowPowerMode_RestrictOnBeforeBsm_RestrictOnAfterBsm() 705 throws Exception { 706 setRestrictBackground(true); 707 PowerSaveState stateOn = new PowerSaveState.Builder() 708 .setGlobalBatterySaverEnabled(true) 709 .setBatterySaverEnabled(false) 710 .build(); 711 mService.updateRestrictBackgroundByLowPowerModeUL(stateOn); 712 713 // RestrictBackground should be on even though battery saver want to turn it off 714 assertTrue(mService.getRestrictBackground()); 715 716 PowerSaveState stateOff = new PowerSaveState.Builder() 717 .setGlobalBatterySaverEnabled(false) 718 .setBatterySaverEnabled(false) 719 .build(); 720 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 721 722 // RestrictBackground should be on, as before. 723 assertTrue(mService.getRestrictBackground()); 724 725 stateOn = new PowerSaveState.Builder() 726 .setGlobalBatterySaverEnabled(true) 727 .setBatterySaverEnabled(true) 728 .build(); 729 mService.updateRestrictBackgroundByLowPowerModeUL(stateOn); 730 731 // RestrictBackground should be on. 732 assertTrue(mService.getRestrictBackground()); 733 734 stateOff = new PowerSaveState.Builder() 735 .setGlobalBatterySaverEnabled(false) 736 .setBatterySaverEnabled(false) 737 .build(); 738 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 739 740 // RestrictBackground should be on, as it was enabled manually before battery saver. 741 assertTrue(mService.getRestrictBackground()); 742 } 743 744 @Test updateRestrictBackgroundByLowPowerMode_RestrictOffBeforeBsm_RestrictOffAfterBsm()745 public void updateRestrictBackgroundByLowPowerMode_RestrictOffBeforeBsm_RestrictOffAfterBsm() 746 throws Exception { 747 setRestrictBackground(false); 748 PowerSaveState stateOn = new PowerSaveState.Builder() 749 .setGlobalBatterySaverEnabled(true) 750 .setBatterySaverEnabled(true) 751 .build(); 752 753 mService.updateRestrictBackgroundByLowPowerModeUL(stateOn); 754 755 // RestrictBackground should be turned on because of battery saver 756 assertTrue(mService.getRestrictBackground()); 757 758 PowerSaveState stateOff = new PowerSaveState.Builder() 759 .setGlobalBatterySaverEnabled(false) 760 .setBatterySaverEnabled(false) 761 .build(); 762 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 763 764 // RestrictBackground should be off, following its previous state 765 assertFalse(mService.getRestrictBackground()); 766 767 PowerSaveState stateOnRestrictOff = new PowerSaveState.Builder() 768 .setGlobalBatterySaverEnabled(true) 769 .setBatterySaverEnabled(false) 770 .build(); 771 772 mService.updateRestrictBackgroundByLowPowerModeUL(stateOnRestrictOff); 773 774 assertFalse(mService.getRestrictBackground()); 775 776 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 777 778 // RestrictBackground should still be off. 779 assertFalse(mService.getRestrictBackground()); 780 } 781 782 @Test updateRestrictBackgroundByLowPowerMode_StatusChangedInBsm_DoNotRestore()783 public void updateRestrictBackgroundByLowPowerMode_StatusChangedInBsm_DoNotRestore() 784 throws Exception { 785 setRestrictBackground(true); 786 PowerSaveState stateOn = new PowerSaveState.Builder() 787 .setGlobalBatterySaverEnabled(true) 788 .setBatterySaverEnabled(true) 789 .build(); 790 mService.updateRestrictBackgroundByLowPowerModeUL(stateOn); 791 792 // RestrictBackground should still be on 793 assertTrue(mService.getRestrictBackground()); 794 795 // User turns off RestrictBackground manually 796 setRestrictBackground(false); 797 // RestrictBackground should be off because user changed it manually 798 assertFalse(mService.getRestrictBackground()); 799 800 PowerSaveState stateOff = new PowerSaveState.Builder() 801 .setGlobalBatterySaverEnabled(false) 802 .setBatterySaverEnabled(false) 803 .build(); 804 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 805 806 // RestrictBackground should remain off. 807 assertFalse(mService.getRestrictBackground()); 808 } 809 810 @Test updateRestrictBackgroundByLowPowerMode_RestrictOnWithGlobalOff()811 public void updateRestrictBackgroundByLowPowerMode_RestrictOnWithGlobalOff() 812 throws Exception { 813 setRestrictBackground(false); 814 PowerSaveState stateOn = new PowerSaveState.Builder() 815 .setGlobalBatterySaverEnabled(false) 816 .setBatterySaverEnabled(true) 817 .build(); 818 819 mService.updateRestrictBackgroundByLowPowerModeUL(stateOn); 820 821 // RestrictBackground should be turned on because of battery saver. 822 assertTrue(mService.getRestrictBackground()); 823 824 PowerSaveState stateRestrictOff = new PowerSaveState.Builder() 825 .setGlobalBatterySaverEnabled(true) 826 .setBatterySaverEnabled(false) 827 .build(); 828 mService.updateRestrictBackgroundByLowPowerModeUL(stateRestrictOff); 829 830 // RestrictBackground should be off, returning to its state before battery saver's change. 831 assertFalse(mService.getRestrictBackground()); 832 833 PowerSaveState stateOff = new PowerSaveState.Builder() 834 .setGlobalBatterySaverEnabled(false) 835 .setBatterySaverEnabled(false) 836 .build(); 837 mService.updateRestrictBackgroundByLowPowerModeUL(stateOff); 838 839 // RestrictBackground should still be off, back in its pre-battery saver state. 840 assertFalse(mService.getRestrictBackground()); 841 } 842 removeRestrictBackgroundAllowlist(boolean expectIntent)843 private void removeRestrictBackgroundAllowlist(boolean expectIntent) throws Exception { 844 assertRestrictBackgroundAllowedUids(UID_A); 845 assertUidPolicy(UID_A, POLICY_ALLOW_METERED_BACKGROUND); 846 847 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 848 mPolicyListener.expect().onUidPoliciesChanged(anyInt(), anyInt()); 849 850 mService.setUidPolicy(UID_A, POLICY_NONE); 851 852 assertRestrictBackgroundAllowedUids(); 853 assertUidPolicy(UID_A, POLICY_NONE); 854 mPolicyListener.waitAndVerify().onUidPoliciesChanged(APP_ID_A, POLICY_NONE); 855 if (expectIntent) { 856 assertRestrictBackgroundChangedReceived(futureIntent, PKG_NAME_A); 857 } else { 858 futureIntent.assertNotReceived(); 859 } 860 } 861 862 /** 863 * Adds an app to denylist when restrict background is on - app should not receive an intent. 864 */ 865 @Test 866 @NetPolicyXml("restrict-background-on.xml") testAddRestrictBackgroundDenylist_restrictBackgroundOn()867 public void testAddRestrictBackgroundDenylist_restrictBackgroundOn() throws Exception { 868 assertRestrictBackgroundOn(); 869 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 870 addRestrictBackgroundDenylist(false); 871 } 872 873 /** 874 * Adds an app to denylist when restrict background is off - app should receive an intent. 875 */ 876 @Test testAddRestrictBackgroundDenylist_restrictBackgroundOff()877 public void testAddRestrictBackgroundDenylist_restrictBackgroundOff() throws Exception { 878 assertRestrictBackgroundOff(); 879 addRestrictBackgroundDenylist(true); 880 } 881 addRestrictBackgroundDenylist(boolean expectIntent)882 private void addRestrictBackgroundDenylist(boolean expectIntent) throws Exception { 883 assertUidPolicy(UID_A, POLICY_NONE); 884 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 885 mPolicyListener.expect().onUidPoliciesChanged(anyInt(), anyInt()); 886 887 mService.setUidPolicy(UID_A, POLICY_REJECT_METERED_BACKGROUND); 888 889 assertUidPolicy(UID_A, POLICY_REJECT_METERED_BACKGROUND); 890 mPolicyListener.waitAndVerify() 891 .onUidPoliciesChanged(APP_ID_A, POLICY_REJECT_METERED_BACKGROUND); 892 if (expectIntent) { 893 assertRestrictBackgroundChangedReceived(futureIntent, PKG_NAME_A); 894 } else { 895 futureIntent.assertNotReceived(); 896 } 897 } 898 899 /** 900 * Removes an app from denylist when restrict background is on - app should not 901 * receive an intent. 902 */ 903 @Test 904 @NetPolicyXml("uidA-denied-restrict-background-on.xml") testRemoveRestrictBackgroundDenylist_restrictBackgroundOn()905 public void testRemoveRestrictBackgroundDenylist_restrictBackgroundOn() throws Exception { 906 assertRestrictBackgroundOn(); 907 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 908 removeRestrictBackgroundDenylist(false); 909 } 910 911 /** 912 * Removes an app from denylist when restrict background is off - app should 913 * receive an intent. 914 */ 915 @Test 916 @NetPolicyXml("uidA-denied-restrict-background-off.xml") testRemoveRestrictBackgroundDenylist_restrictBackgroundOff()917 public void testRemoveRestrictBackgroundDenylist_restrictBackgroundOff() throws Exception { 918 assertRestrictBackgroundOff(); 919 removeRestrictBackgroundDenylist(true); 920 } 921 removeRestrictBackgroundDenylist(boolean expectIntent)922 private void removeRestrictBackgroundDenylist(boolean expectIntent) throws Exception { 923 assertUidPolicy(UID_A, POLICY_REJECT_METERED_BACKGROUND); 924 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 925 mPolicyListener.expect().onUidPoliciesChanged(anyInt(), anyInt()); 926 927 mService.setUidPolicy(UID_A, POLICY_NONE); 928 929 assertUidPolicy(UID_A, POLICY_NONE); 930 mPolicyListener.waitAndVerify() 931 .onUidPoliciesChanged(APP_ID_A, POLICY_NONE); 932 if (expectIntent) { 933 assertRestrictBackgroundChangedReceived(futureIntent, PKG_NAME_A); 934 } else { 935 futureIntent.assertNotReceived(); 936 } 937 } 938 939 @Test 940 @NetPolicyXml("uidA-denied-restrict-background-on.xml") testDeniedAppIsNotNotifiedWhenRestrictBackgroundIsOn()941 public void testDeniedAppIsNotNotifiedWhenRestrictBackgroundIsOn() throws Exception { 942 assertRestrictBackgroundOn(); 943 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 944 assertUidPolicy(UID_A, POLICY_REJECT_METERED_BACKGROUND); 945 946 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 947 setRestrictBackground(true); 948 futureIntent.assertNotReceived(); 949 } 950 951 @Test 952 @NetPolicyXml("uidA-allowed-restrict-background-on.xml") testAllowedAppIsNotNotifiedWhenRestrictBackgroundIsOn()953 public void testAllowedAppIsNotNotifiedWhenRestrictBackgroundIsOn() throws Exception { 954 assertRestrictBackgroundOn(); 955 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 956 assertRestrictBackgroundAllowedUids(UID_A); 957 958 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 959 setRestrictBackground(true); 960 futureIntent.assertNotReceived(); 961 } 962 963 @Test 964 @NetPolicyXml("uidA-allowed-restrict-background-on.xml") testAllowedAppIsNotifiedWhenDenylisted()965 public void testAllowedAppIsNotifiedWhenDenylisted() throws Exception { 966 assertRestrictBackgroundOn(); 967 assertRestrictBackgroundChangedReceived(mFutureIntent, null); 968 assertRestrictBackgroundAllowedUids(UID_A); 969 970 final FutureIntent futureIntent = newRestrictBackgroundChangedFuture(); 971 mService.setUidPolicy(UID_A, POLICY_REJECT_METERED_BACKGROUND); 972 assertRestrictBackgroundChangedReceived(futureIntent, PKG_NAME_A); 973 } 974 975 @Test 976 @NetPolicyXml("restrict-background-lists-allowlist-format.xml") testRestrictBackgroundLists_allowlistFormat()977 public void testRestrictBackgroundLists_allowlistFormat() throws Exception { 978 restrictBackgroundListsTest(); 979 } 980 981 @Test 982 @NetPolicyXml("restrict-background-lists-uid-policy-format.xml") testRestrictBackgroundLists_uidPolicyFormat()983 public void testRestrictBackgroundLists_uidPolicyFormat() throws Exception { 984 restrictBackgroundListsTest(); 985 } 986 restrictBackgroundListsTest()987 private void restrictBackgroundListsTest() throws Exception { 988 // UIds that are in allowlist. 989 assertRestrictBackgroundAllowedUids(UID_A, UID_B, UID_C); 990 assertUidPolicy(UID_A, POLICY_ALLOW_METERED_BACKGROUND); 991 assertUidPolicy(UID_B, POLICY_ALLOW_METERED_BACKGROUND); 992 assertUidPolicy(UID_C, POLICY_ALLOW_METERED_BACKGROUND); 993 994 // UIDs that are in denylist. 995 assertUidPolicy(UID_D, POLICY_NONE); 996 assertUidPolicy(UID_E, POLICY_REJECT_METERED_BACKGROUND); 997 998 // UIDS that have legacy policies. 999 assertUidPolicy(UID_F, 2); // POLICY_ALLOW_BACKGROUND_BATTERY_SAVE 1000 1001 // Remove an uid from allowlist. 1002 mService.setUidPolicy(UID_A, POLICY_NONE); 1003 assertUidPolicy(UID_A, POLICY_NONE); 1004 assertRestrictBackgroundAllowedUids(UID_B, UID_C); 1005 1006 // Add an app to allowlist which is currently in denylist. 1007 mService.setUidPolicy(UID_E, POLICY_ALLOW_METERED_BACKGROUND); 1008 assertUidPolicy(UID_E, POLICY_ALLOW_METERED_BACKGROUND); 1009 assertRestrictBackgroundAllowedUids(UID_B, UID_C, UID_E); 1010 1011 // Add an app to denylist when is currently in allowlist. 1012 mService.setUidPolicy(UID_B, POLICY_REJECT_METERED_BACKGROUND); 1013 assertUidPolicy(UID_B, POLICY_REJECT_METERED_BACKGROUND); 1014 assertRestrictBackgroundAllowedUids(UID_C, UID_E); 1015 } 1016 1017 /** 1018 * Tests scenario where an UID had {@code restrict-background} and {@code uid-policy} tags. 1019 */ 1020 @Test 1021 @NetPolicyXml("restrict-background-lists-mixed-format.xml") testRestrictBackgroundLists_mixedFormat()1022 public void testRestrictBackgroundLists_mixedFormat() throws Exception { 1023 assertRestrictBackgroundAllowedUids(UID_A, UID_C, UID_D); 1024 assertUidPolicy(UID_A, POLICY_ALLOW_METERED_BACKGROUND); 1025 assertUidPolicy(UID_B, POLICY_REJECT_METERED_BACKGROUND); // Denylist prevails. 1026 assertUidPolicy(UID_C, (POLICY_ALLOW_METERED_BACKGROUND | 2)); 1027 assertUidPolicy(UID_D, POLICY_ALLOW_METERED_BACKGROUND); 1028 } 1029 1030 @Test 1031 @NetPolicyXml("uids-with-mixed-policies.xml") testGetUidsWithPolicy()1032 public void testGetUidsWithPolicy() throws Exception { 1033 assertContainsInAnyOrder(mService.getUidsWithPolicy(POLICY_NONE)); 1034 assertContainsInAnyOrder(mService.getUidsWithPolicy(POLICY_REJECT_METERED_BACKGROUND), 1035 UID_B, UID_D); 1036 assertContainsInAnyOrder(mService.getUidsWithPolicy(POLICY_ALLOW_METERED_BACKGROUND), 1037 UID_E, UID_F); 1038 // Legacy (POLICY_ALLOW_BACKGROUND_BATTERY_SAVE) 1039 assertContainsInAnyOrder(mService.getUidsWithPolicy(2), 1040 UID_C, UID_D, UID_F); 1041 } 1042 1043 // NOTE: testPolicyChangeTriggersListener() is too superficial, they 1044 // don't check for side-effects (like calls to NetworkManagementService) neither cover all 1045 // different modes (Data Saver, Battery Saver, Doze, App idle, etc...). 1046 // These scenarios are extensively tested on CTS' HostsideRestrictBackgroundNetworkTests. 1047 @SuppressWarnings("GuardedBy") 1048 @Test testUidForeground()1049 public void testUidForeground() throws Exception { 1050 // push all uids into background 1051 long procStateSeq = 0; 1052 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq++); 1053 callAndWaitOnUidStateChanged(UID_B, PROCESS_STATE_SERVICE, procStateSeq++); 1054 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1055 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1056 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1057 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1058 1059 // push one of the uids into foreground 1060 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_TOP, procStateSeq++); 1061 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1062 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1063 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1064 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1065 1066 // and swap another uid into foreground 1067 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq++); 1068 callAndWaitOnUidStateChanged(UID_B, PROCESS_STATE_TOP, procStateSeq++); 1069 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1070 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1071 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1072 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1073 1074 // change capability of an uid to allow access to power restricted network 1075 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq++, 1076 PROCESS_CAPABILITY_POWER_RESTRICTED_NETWORK); 1077 callAndWaitOnUidStateChanged(UID_B, PROCESS_STATE_SERVICE, procStateSeq++, 1078 PROCESS_CAPABILITY_NONE); 1079 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1080 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1081 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1082 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1083 1084 // change capability of an uid to allow access to user restricted network 1085 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_IMPORTANT_FOREGROUND, procStateSeq++, 1086 PROCESS_CAPABILITY_USER_RESTRICTED_NETWORK); 1087 callAndWaitOnUidStateChanged(UID_B, PROCESS_STATE_SERVICE, procStateSeq++, 1088 PROCESS_CAPABILITY_NONE); 1089 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1090 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1091 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1092 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1093 } 1094 1095 @SuppressWarnings("GuardedBy") 1096 @Test testUidForeground_withPendingState()1097 public void testUidForeground_withPendingState() throws Exception { 1098 long procStateSeq = 0; 1099 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_SERVICE, 1100 procStateSeq++, PROCESS_CAPABILITY_NONE); 1101 callAndWaitOnUidStateChanged(UID_B, PROCESS_STATE_SERVICE, 1102 procStateSeq++, PROCESS_CAPABILITY_NONE); 1103 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1104 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1105 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1106 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1107 1108 try (SyncBarrier b = new SyncBarrier(mService.mUidEventHandler)) { 1109 // Verify that a callback with an old procStateSeq is ignored. 1110 callOnUidStatechanged(UID_A, PROCESS_STATE_TOP, 0, 1111 PROCESS_CAPABILITY_POWER_RESTRICTED_NETWORK); 1112 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1113 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1114 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1115 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1116 1117 callOnUidStatechanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq++, 1118 PROCESS_CAPABILITY_POWER_RESTRICTED_NETWORK); 1119 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1120 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1121 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1122 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1123 1124 callOnUidStatechanged(UID_A, PROCESS_STATE_IMPORTANT_FOREGROUND, procStateSeq++, 1125 PROCESS_CAPABILITY_USER_RESTRICTED_NETWORK); 1126 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1127 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1128 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1129 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1130 1131 callOnUidStatechanged(UID_A, PROCESS_STATE_TOP, procStateSeq++, 1132 PROCESS_CAPABILITY_NONE); 1133 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1134 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1135 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1136 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1137 } 1138 waitForUidEventHandlerIdle(); 1139 1140 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1141 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1142 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1143 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1144 1145 try (SyncBarrier b = new SyncBarrier(mService.mUidEventHandler)) { 1146 callOnUidStatechanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq++, 1147 PROCESS_CAPABILITY_NONE); 1148 assertTrue(mService.isUidForegroundOnRestrictPowerUL(UID_A)); 1149 assertTrue(mService.isUidForegroundOnRestrictBackgroundUL(UID_A)); 1150 assertFalse(mService.isUidForegroundOnRestrictPowerUL(UID_B)); 1151 assertFalse(mService.isUidForegroundOnRestrictBackgroundUL(UID_B)); 1152 } 1153 waitForUidEventHandlerIdle(); 1154 } 1155 1156 @Test testAppIdleTempWhitelisting()1157 public void testAppIdleTempWhitelisting() throws Exception { 1158 mService.setAppIdleWhitelist(UID_A, true); 1159 mService.setAppIdleWhitelist(UID_B, false); 1160 int[] whitelistedIds = mService.getAppIdleWhitelist(); 1161 assertTrue(Arrays.binarySearch(whitelistedIds, UID_A) >= 0); 1162 assertTrue(Arrays.binarySearch(whitelistedIds, UID_B) < 0); 1163 assertFalse(mService.isUidIdle(UID_A)); 1164 // Can't currently guarantee UID_B's app idle state. 1165 // TODO: expand with multiple app idle states. 1166 } 1167 1168 private static long computeLastCycleBoundary(long currentTime, NetworkPolicy policy) { 1169 RecurrenceRule.sClock = Clock.fixed(Instant.ofEpochMilli(currentTime), 1170 ZoneId.systemDefault()); 1171 final Iterator<Range<ZonedDateTime>> it = policy.cycleIterator(); 1172 while (it.hasNext()) { 1173 final Range<ZonedDateTime> cycle = it.next(); 1174 if (cycle.getLower().toInstant().toEpochMilli() < currentTime) { 1175 return cycle.getLower().toInstant().toEpochMilli(); 1176 } 1177 } 1178 throw new IllegalStateException( 1179 "Failed to find current cycle for " + policy + " at " + currentTime); 1180 } 1181 1182 private static long computeNextCycleBoundary(long currentTime, NetworkPolicy policy) { 1183 RecurrenceRule.sClock = Clock.fixed(Instant.ofEpochMilli(currentTime), 1184 ZoneId.systemDefault()); 1185 return policy.cycleIterator().next().getUpper().toInstant().toEpochMilli(); 1186 } 1187 1188 @Test 1189 public void testLastCycleBoundaryThisMonth() throws Exception { 1190 // assume cycle day of "5th", which should be in same month 1191 final long currentTime = parseTime("2007-11-14T00:00:00.000Z"); 1192 final long expectedCycle = parseTime("2007-11-05T00:00:00.000Z"); 1193 1194 final NetworkPolicy policy = new NetworkPolicy( 1195 sTemplateWifi, 5, TIMEZONE_UTC, 1024L, 1024L, false); 1196 final long actualCycle = computeLastCycleBoundary(currentTime, policy); 1197 assertTimeEquals(expectedCycle, actualCycle); 1198 } 1199 1200 @Test 1201 public void testLastCycleBoundaryLastMonth() throws Exception { 1202 // assume cycle day of "20th", which should be in last month 1203 final long currentTime = parseTime("2007-11-14T00:00:00.000Z"); 1204 final long expectedCycle = parseTime("2007-10-20T00:00:00.000Z"); 1205 1206 final NetworkPolicy policy = new NetworkPolicy( 1207 sTemplateWifi, 20, TIMEZONE_UTC, 1024L, 1024L, false); 1208 final long actualCycle = computeLastCycleBoundary(currentTime, policy); 1209 assertTimeEquals(expectedCycle, actualCycle); 1210 } 1211 1212 @Test 1213 public void testLastCycleBoundaryThisMonthFebruary() throws Exception { 1214 // assume cycle day of "30th" in february; should go to january 1215 final long currentTime = parseTime("2007-02-14T00:00:00.000Z"); 1216 final long expectedCycle = parseTime("2007-01-30T00:00:00.000Z"); 1217 1218 final NetworkPolicy policy = new NetworkPolicy( 1219 sTemplateWifi, 30, TIMEZONE_UTC, 1024L, 1024L, false); 1220 final long actualCycle = computeLastCycleBoundary(currentTime, policy); 1221 assertTimeEquals(expectedCycle, actualCycle); 1222 } 1223 1224 @Test 1225 public void testLastCycleBoundaryLastMonthFebruary() throws Exception { 1226 // assume cycle day of "30th" in february, which should clamp 1227 final long currentTime = parseTime("2007-03-14T00:00:00.000Z"); 1228 final long expectedCycle = parseTime("2007-02-28T23:59:59.999Z"); 1229 1230 final NetworkPolicy policy = new NetworkPolicy( 1231 sTemplateWifi, 30, TIMEZONE_UTC, 1024L, 1024L, false); 1232 final long actualCycle = computeLastCycleBoundary(currentTime, policy); 1233 assertTimeEquals(expectedCycle, actualCycle); 1234 } 1235 1236 @Test 1237 public void testCycleBoundaryLeapYear() throws Exception { 1238 final NetworkPolicy policy = new NetworkPolicy( 1239 sTemplateWifi, 29, TIMEZONE_UTC, 1024L, 1024L, false); 1240 1241 assertTimeEquals(parseTime("2012-01-29T00:00:00.000Z"), 1242 computeNextCycleBoundary(parseTime("2012-01-14T00:00:00.000Z"), policy)); 1243 assertTimeEquals(parseTime("2012-02-29T00:00:00.000Z"), 1244 computeNextCycleBoundary(parseTime("2012-02-14T00:00:00.000Z"), policy)); 1245 assertTimeEquals(parseTime("2012-02-29T00:00:00.000Z"), 1246 computeLastCycleBoundary(parseTime("2012-03-14T00:00:00.000Z"), policy)); 1247 assertTimeEquals(parseTime("2012-03-29T00:00:00.000Z"), 1248 computeNextCycleBoundary(parseTime("2012-03-14T00:00:00.000Z"), policy)); 1249 1250 assertTimeEquals(parseTime("2007-01-29T00:00:00.000Z"), 1251 computeNextCycleBoundary(parseTime("2007-01-14T00:00:00.000Z"), policy)); 1252 assertTimeEquals(parseTime("2007-02-28T23:59:59.999Z"), 1253 computeNextCycleBoundary(parseTime("2007-02-14T00:00:00.000Z"), policy)); 1254 assertTimeEquals(parseTime("2007-02-28T23:59:59.999Z"), 1255 computeLastCycleBoundary(parseTime("2007-03-14T00:00:00.000Z"), policy)); 1256 assertTimeEquals(parseTime("2007-03-29T00:00:00.000Z"), 1257 computeNextCycleBoundary(parseTime("2007-03-14T00:00:00.000Z"), policy)); 1258 } 1259 1260 @Test 1261 public void testNextCycleTimezoneAfterUtc() throws Exception { 1262 // US/Central is UTC-6 1263 final NetworkPolicy policy = new NetworkPolicy( 1264 sTemplateWifi, 10, "US/Central", 1024L, 1024L, false); 1265 assertTimeEquals(parseTime("2012-01-10T06:00:00.000Z"), 1266 computeNextCycleBoundary(parseTime("2012-01-05T00:00:00.000Z"), policy)); 1267 } 1268 1269 @Test 1270 public void testNextCycleTimezoneBeforeUtc() throws Exception { 1271 // Israel is UTC+2 1272 final NetworkPolicy policy = new NetworkPolicy( 1273 sTemplateWifi, 10, "Israel", 1024L, 1024L, false); 1274 assertTimeEquals(parseTime("2012-01-09T22:00:00.000Z"), 1275 computeNextCycleBoundary(parseTime("2012-01-05T00:00:00.000Z"), policy)); 1276 } 1277 1278 @Test 1279 public void testCycleTodayJanuary() throws Exception { 1280 final NetworkPolicy policy = new NetworkPolicy( 1281 sTemplateWifi, 14, "US/Pacific", 1024L, 1024L, false); 1282 1283 assertTimeEquals(parseTime("2013-01-14T00:00:00.000-08:00"), 1284 computeNextCycleBoundary(parseTime("2013-01-13T23:59:59.000-08:00"), policy)); 1285 assertTimeEquals(parseTime("2013-02-14T00:00:00.000-08:00"), 1286 computeNextCycleBoundary(parseTime("2013-01-14T00:00:01.000-08:00"), policy)); 1287 assertTimeEquals(parseTime("2013-02-14T00:00:00.000-08:00"), 1288 computeNextCycleBoundary(parseTime("2013-01-14T15:11:00.000-08:00"), policy)); 1289 1290 assertTimeEquals(parseTime("2012-12-14T00:00:00.000-08:00"), 1291 computeLastCycleBoundary(parseTime("2013-01-13T23:59:59.000-08:00"), policy)); 1292 assertTimeEquals(parseTime("2013-01-14T00:00:00.000-08:00"), 1293 computeLastCycleBoundary(parseTime("2013-01-14T00:00:01.000-08:00"), policy)); 1294 assertTimeEquals(parseTime("2013-01-14T00:00:00.000-08:00"), 1295 computeLastCycleBoundary(parseTime("2013-01-14T15:11:00.000-08:00"), policy)); 1296 } 1297 1298 @FlakyTest 1299 @Test 1300 public void testNetworkPolicyAppliedCycleLastMonth() throws Exception { 1301 List<NetworkStateSnapshot> snapshots = null; 1302 NetworkStats stats = null; 1303 1304 final int CYCLE_DAY = 15; 1305 final long NOW = parseTime("2007-03-10T00:00Z"); 1306 final long CYCLE_START = parseTime("2007-02-15T00:00Z"); 1307 final long CYCLE_END = parseTime("2007-03-15T00:00Z"); 1308 1309 setCurrentTimeMillis(NOW); 1310 1311 // first, pretend that wifi network comes online. no policy active, 1312 // which means we shouldn't push limit to interface. 1313 snapshots = List.of(buildWifi()); 1314 when(mConnManager.getAllNetworkStateSnapshots()).thenReturn(snapshots); 1315 1316 mPolicyListener.expect().onMeteredIfacesChanged(any()); 1317 mServiceContext.sendBroadcast(new Intent(CONNECTIVITY_ACTION)); 1318 mPolicyListener.waitAndVerify().onMeteredIfacesChanged(any()); 1319 1320 // now change cycle to be on 15th, and test in early march, to verify we 1321 // pick cycle day in previous month. 1322 when(mConnManager.getAllNetworkStateSnapshots()).thenReturn(snapshots); 1323 1324 // pretend that 512 bytes total have happened 1325 mDeps.setMockedTotalBytes(UID_A, 256L, 256L); 1326 1327 mPolicyListener.expect().onMeteredIfacesChanged(any()); 1328 setNetworkPolicies(new NetworkPolicy( 1329 sTemplateWifi, CYCLE_DAY, TIMEZONE_UTC, DataUnit.MEBIBYTES.toBytes(1), 1330 DataUnit.MEBIBYTES.toBytes(2), false)); 1331 mPolicyListener.waitAndVerify().onMeteredIfacesChanged(eq(new String[]{TEST_IFACE})); 1332 1333 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1334 DataUnit.MEBIBYTES.toBytes(2) - 512); 1335 } 1336 1337 @Test 1338 public void testNotificationWarningLimitSnooze() throws Exception { 1339 // Get active mobile network in place 1340 expectMobileDefaults(); 1341 mService.updateNetworks(); 1342 1343 // Define simple data plan 1344 final SubscriptionPlan plan = buildMonthlyDataPlan( 1345 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), DataUnit.MEGABYTES.toBytes(1800)); 1346 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[] { plan }, 1347 mServiceContext.getOpPackageName()); 1348 1349 // We're 20% through the month (6 days) 1350 final long start = parseTime("2015-11-01T00:00Z"); 1351 final long end = parseTime("2015-11-07T00:00Z"); 1352 setCurrentTimeMillis(end); 1353 1354 // Normal usage means no notification 1355 { 1356 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(360), 0); 1357 1358 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1359 TelephonyManager tmSub = expectMobileDefaults(); 1360 1361 mService.updateNetworks(); 1362 1363 verify(tmSub, atLeastOnce()).setPolicyDataEnabled(true); 1364 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1365 DataUnit.MEGABYTES.toBytes(1800 - 360)); 1366 verify(mNotifManager, never()).notifyAsUser(any(), anyInt(), any(), any()); 1367 } 1368 1369 // Push over warning 1370 { 1371 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(1799), 0); 1372 1373 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1374 TelephonyManager tmSub = expectMobileDefaults(); 1375 1376 mService.updateNetworks(); 1377 1378 verify(tmSub, atLeastOnce()).setPolicyDataEnabled(true); 1379 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1380 DataUnit.MEGABYTES.toBytes(1800 - 1799)); 1381 verify(mNotifManager, atLeastOnce()).notifyAsUser(any(), eq(TYPE_WARNING), 1382 isA(Notification.class), eq(UserHandle.ALL)); 1383 } 1384 1385 // Push over warning, but with a config that isn't from an identified carrier 1386 { 1387 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(1799), 0); 1388 1389 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1390 TelephonyManager tmSub = expectMobileDefaults(); 1391 expectDefaultCarrierConfig(); 1392 1393 mService.updateNetworks(); 1394 1395 verify(tmSub, atLeastOnce()).setPolicyDataEnabled(true); 1396 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1397 DataUnit.MEGABYTES.toBytes(1800 - 1799)); 1398 // Since this isn't from the identified carrier, there should be no notifications 1399 verify(mNotifManager, never()).notifyAsUser(any(), anyInt(), any(), any()); 1400 } 1401 1402 // Push over limit 1403 { 1404 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(1810), 0); 1405 1406 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1407 TelephonyManager tmSub = expectMobileDefaults(); 1408 1409 mService.updateNetworks(); 1410 1411 verify(tmSub, atLeastOnce()).setPolicyDataEnabled(false); 1412 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1); 1413 verify(mNotifManager, atLeastOnce()).notifyAsUser(any(), eq(TYPE_LIMIT), 1414 isA(Notification.class), eq(UserHandle.ALL)); 1415 } 1416 1417 // Snooze limit 1418 { 1419 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1420 TelephonyManager tmSub = expectMobileDefaults(); 1421 1422 mService.snoozeLimit(sTemplateCarrierMetered); 1423 mService.updateNetworks(); 1424 1425 verify(tmSub, atLeastOnce()).setPolicyDataEnabled(true); 1426 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1427 Long.MAX_VALUE); 1428 verify(mNotifManager, atLeastOnce()).notifyAsUser(any(), eq(TYPE_LIMIT_SNOOZED), 1429 isA(Notification.class), eq(UserHandle.ALL)); 1430 } 1431 } 1432 1433 @Test 1434 public void testNotificationRapid() throws Exception { 1435 // Get active mobile network in place 1436 expectMobileDefaults(); 1437 mService.updateNetworks(); 1438 1439 // Define simple data plan which gives us effectively 60MB/day 1440 final SubscriptionPlan plan = buildMonthlyDataPlan( 1441 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), DataUnit.MEGABYTES.toBytes(1800)); 1442 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[] { plan }, 1443 mServiceContext.getOpPackageName()); 1444 1445 // We're 20% through the month (6 days) 1446 final long start = parseTime("2015-11-01T00:00Z"); 1447 final long end = parseTime("2015-11-07T00:00Z"); 1448 setCurrentTimeMillis(end); 1449 1450 // Using 20% data in 20% time is normal 1451 { 1452 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(360), 0); 1453 1454 reset(mNotifManager); 1455 mService.updateNetworks(); 1456 verify(mNotifManager, never()).notifyAsUser(any(), anyInt(), any(), any()); 1457 } 1458 1459 // Using 80% data in 20% time is alarming; but spread equally among 1460 // three UIDs means we get generic alert 1461 { 1462 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(480), 0); 1463 mDeps.setMockedTotalBytes(UID_B, DataUnit.MEGABYTES.toBytes(480), 0); 1464 mDeps.setMockedTotalBytes(UID_C, DataUnit.MEGABYTES.toBytes(480), 0); 1465 1466 reset(mNotifManager); 1467 mService.updateNetworks(); 1468 1469 final ArgumentCaptor<Notification> notif = ArgumentCaptor.forClass(Notification.class); 1470 verify(mNotifManager, atLeastOnce()).notifyAsUser(any(), eq(TYPE_RAPID), 1471 notif.capture(), eq(UserHandle.ALL)); 1472 1473 final String text = notif.getValue().extras.getCharSequence(Notification.EXTRA_TEXT) 1474 .toString(); 1475 assertFalse(text.contains(PKG_NAME_A)); 1476 assertFalse(text.contains(PKG_NAME_B)); 1477 assertFalse(text.contains(PKG_NAME_C)); 1478 } 1479 1480 // Using 80% data in 20% time is alarming; but mostly done by one UID 1481 // means we get specific alert 1482 { 1483 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(960), 0); 1484 mDeps.setMockedTotalBytes(UID_B, DataUnit.MEGABYTES.toBytes(480), 0); 1485 mDeps.setMockedTotalBytes(UID_C, 0, 0); 1486 1487 reset(mNotifManager); 1488 mService.updateNetworks(); 1489 1490 final ArgumentCaptor<Notification> notif = ArgumentCaptor.forClass(Notification.class); 1491 verify(mNotifManager, atLeastOnce()).notifyAsUser(any(), eq(TYPE_RAPID), 1492 notif.capture(), eq(UserHandle.ALL)); 1493 1494 final String text = notif.getValue().extras.getCharSequence(Notification.EXTRA_TEXT) 1495 .toString(); 1496 assertTrue(text.contains(PKG_NAME_A)); 1497 assertFalse(text.contains(PKG_NAME_B)); 1498 assertFalse(text.contains(PKG_NAME_C)); 1499 } 1500 } 1501 1502 @Test 1503 public void testMeteredNetworkWithoutLimit() throws Exception { 1504 List<NetworkStateSnapshot> snapshots = null; 1505 NetworkStats stats = null; 1506 1507 final long TIME_FEB_15 = 1171497600000L; 1508 final long TIME_MAR_10 = 1173484800000L; 1509 final int CYCLE_DAY = 15; 1510 1511 setCurrentTimeMillis(TIME_MAR_10); 1512 1513 // bring up wifi network with metered policy 1514 snapshots = List.of(buildWifi()); 1515 mDeps.setMockedTotalBytes(UID_A, 0L, 0L); 1516 1517 { 1518 when(mConnManager.getAllNetworkStateSnapshots()).thenReturn(snapshots); 1519 1520 mPolicyListener.expect().onMeteredIfacesChanged(any()); 1521 setNetworkPolicies(new NetworkPolicy( 1522 sTemplateWifi, CYCLE_DAY, TIMEZONE_UTC, WARNING_DISABLED, LIMIT_DISABLED, 1523 true)); 1524 mPolicyListener.waitAndVerify().onMeteredIfacesChanged(eq(new String[]{TEST_IFACE})); 1525 1526 verify(mNetworkManager, atLeastOnce()).setInterfaceQuota(TEST_IFACE, 1527 Long.MAX_VALUE); 1528 } 1529 } 1530 1531 @Test 1532 public void testOnUidStateChanged_notifyAMS() throws Exception { 1533 final long procStateSeq = 222; 1534 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_SERVICE, procStateSeq); 1535 verify(mActivityManagerInternal).notifyNetworkPolicyRulesUpdated(UID_A, procStateSeq); 1536 } 1537 1538 private void callAndWaitOnUidStateChanged(int uid, int procState, long procStateSeq) 1539 throws Exception { 1540 callAndWaitOnUidStateChanged(uid, procState, procStateSeq, 1541 PROCESS_CAPABILITY_NONE); 1542 } 1543 1544 private void callAndWaitOnUidStateChanged(int uid, int procState, long procStateSeq, 1545 int capability) throws Exception { 1546 callOnUidStatechanged(uid, procState, procStateSeq, capability); 1547 waitForUidEventHandlerIdle(); 1548 } 1549 1550 private void callOnUidStatechanged(int uid, int procState, long procStateSeq, int capability) 1551 throws Exception { 1552 mUidObserver.onUidStateChanged(uid, procState, procStateSeq, capability); 1553 } 1554 1555 private void waitForUidEventHandlerIdle() throws Exception { 1556 final CountDownLatch latch = new CountDownLatch(1); 1557 mService.mUidEventHandler.post(() -> { 1558 latch.countDown(); 1559 }); 1560 latch.await(2, TimeUnit.SECONDS); 1561 } 1562 1563 private void assertCycleDayAsExpected(PersistableBundle config, int carrierCycleDay, 1564 boolean expectValid) { 1565 config.putInt(KEY_MONTHLY_DATA_CYCLE_DAY_INT, carrierCycleDay); 1566 int actualCycleDay = mService.getCycleDayFromCarrierConfig(config, 1567 INVALID_CARRIER_CONFIG_VALUE); 1568 if (expectValid) { 1569 assertEquals(carrierCycleDay, actualCycleDay); 1570 } else { 1571 // INVALID_CARRIER_CONFIG_VALUE is returned for invalid values 1572 assertEquals(INVALID_CARRIER_CONFIG_VALUE, actualCycleDay); 1573 } 1574 } 1575 1576 @Test 1577 public void testGetCycleDayFromCarrierConfig() { 1578 PersistableBundle config = CarrierConfigManager.getDefaultConfig(); 1579 final Calendar cal = Calendar.getInstance(); 1580 int actualCycleDay; 1581 1582 config.putInt(KEY_MONTHLY_DATA_CYCLE_DAY_INT, DATA_CYCLE_USE_PLATFORM_DEFAULT); 1583 actualCycleDay = mService.getCycleDayFromCarrierConfig(config, DEFAULT_CYCLE_DAY); 1584 assertEquals(DEFAULT_CYCLE_DAY, actualCycleDay); 1585 1586 // null config returns a default value 1587 actualCycleDay = mService.getCycleDayFromCarrierConfig(null, DEFAULT_CYCLE_DAY); 1588 assertEquals(DEFAULT_CYCLE_DAY, actualCycleDay); 1589 1590 // Valid, non-default values 1591 assertCycleDayAsExpected(config, 1, true); 1592 assertCycleDayAsExpected(config, cal.getMaximum(Calendar.DAY_OF_MONTH), true); 1593 assertCycleDayAsExpected(config, cal.getMinimum(Calendar.DAY_OF_MONTH), true); 1594 1595 // Invalid values 1596 assertCycleDayAsExpected(config, 0, false); 1597 assertCycleDayAsExpected(config, DATA_CYCLE_THRESHOLD_DISABLED, false); 1598 assertCycleDayAsExpected(config, cal.getMaximum(Calendar.DAY_OF_MONTH) + 1, false); 1599 assertCycleDayAsExpected(config, cal.getMinimum(Calendar.DAY_OF_MONTH) - 5, false); 1600 } 1601 1602 private void assertWarningBytesAsExpected(PersistableBundle config, long carrierWarningBytes, 1603 long expected) { 1604 config.putLong(KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, carrierWarningBytes); 1605 long actualWarning = mService.getWarningBytesFromCarrierConfig(config, 1606 INVALID_CARRIER_CONFIG_VALUE); 1607 assertEquals(expected, actualWarning); 1608 } 1609 1610 @Test 1611 public void testGetWarningBytesFromCarrierConfig() { 1612 PersistableBundle config = CarrierConfigManager.getDefaultConfig(); 1613 long actualWarningBytes; 1614 1615 assertWarningBytesAsExpected(config, DATA_CYCLE_USE_PLATFORM_DEFAULT, 1616 mDefaultWarningBytes); 1617 assertWarningBytesAsExpected(config, DATA_CYCLE_THRESHOLD_DISABLED, WARNING_DISABLED); 1618 assertWarningBytesAsExpected(config, 0, 0); 1619 // not a valid value 1620 assertWarningBytesAsExpected(config, -1000, INVALID_CARRIER_CONFIG_VALUE); 1621 1622 // null config returns a default value 1623 actualWarningBytes = mService.getWarningBytesFromCarrierConfig(null, mDefaultWarningBytes); 1624 assertEquals(mDefaultWarningBytes, actualWarningBytes); 1625 } 1626 1627 private void assertLimitBytesAsExpected(PersistableBundle config, long carrierWarningBytes, 1628 long expected) { 1629 config.putLong(KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, carrierWarningBytes); 1630 long actualWarning = mService.getLimitBytesFromCarrierConfig(config, 1631 INVALID_CARRIER_CONFIG_VALUE); 1632 assertEquals(expected, actualWarning); 1633 } 1634 1635 @Test 1636 public void testGetLimitBytesFromCarrierConfig() { 1637 PersistableBundle config = CarrierConfigManager.getDefaultConfig(); 1638 long actualLimitBytes; 1639 1640 assertLimitBytesAsExpected(config, DATA_CYCLE_USE_PLATFORM_DEFAULT, 1641 mDefaultLimitBytes); 1642 assertLimitBytesAsExpected(config, DATA_CYCLE_THRESHOLD_DISABLED, LIMIT_DISABLED); 1643 assertLimitBytesAsExpected(config, 0, 0); 1644 // not a valid value 1645 assertLimitBytesAsExpected(config, -1000, INVALID_CARRIER_CONFIG_VALUE); 1646 1647 // null config returns a default value 1648 actualLimitBytes = mService.getWarningBytesFromCarrierConfig(null, mDefaultLimitBytes); 1649 assertEquals(mDefaultLimitBytes, actualLimitBytes); 1650 } 1651 1652 private PersistableBundle setupUpdateCarrierPolicyCycleTests() throws RemoteException { 1653 when(mConnManager.getAllNetworkStateSnapshots()) 1654 .thenReturn(new ArrayList<NetworkStateSnapshot>()); 1655 1656 setupTelephonySubscriptionManagers(FAKE_SUB_ID, FAKE_SUBSCRIBER_ID); 1657 1658 PersistableBundle bundle = CarrierConfigManager.getDefaultConfig(); 1659 when(mCarrierConfigManager.getConfigForSubId(FAKE_SUB_ID)).thenReturn(bundle); 1660 setNetworkPolicies(buildDefaultFakeCarrierPolicy()); 1661 return bundle; 1662 } 1663 1664 @Test 1665 public void testUpdateCarrierPolicyCycleWithNullConfig() throws RemoteException { 1666 when(mConnManager.getAllNetworkStateSnapshots()) 1667 .thenReturn(new ArrayList<NetworkStateSnapshot>()); 1668 1669 setupTelephonySubscriptionManagers(FAKE_SUB_ID, FAKE_SUBSCRIBER_ID); 1670 1671 when(mCarrierConfigManager.getConfigForSubId(FAKE_SUB_ID)).thenReturn(null); 1672 setNetworkPolicies(buildDefaultFakeCarrierPolicy()); 1673 // smoke test to make sure no errors are raised 1674 mServiceContext.sendBroadcast( 1675 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1676 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1677 ); 1678 assertNetworkPolicyEquals(DEFAULT_CYCLE_DAY, mDefaultWarningBytes, mDefaultLimitBytes, 1679 true); 1680 } 1681 1682 @Test 1683 public void testUpdateCarrierPolicyCycleWithInvalidConfig() throws RemoteException { 1684 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1685 // Test with an invalid CarrierConfig, there should be no changes or crashes. 1686 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, -100); 1687 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, -100); 1688 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, -100); 1689 mServiceContext.sendBroadcast( 1690 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1691 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1692 ); 1693 1694 assertNetworkPolicyEquals(DEFAULT_CYCLE_DAY, mDefaultWarningBytes, mDefaultLimitBytes, 1695 true); 1696 } 1697 1698 @Test 1699 public void testUpdateCarrierPolicyCycleWithDefaultConfig() throws RemoteException { 1700 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1701 // Test that we respect the platform values when told to 1702 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 1703 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1704 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 1705 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1706 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 1707 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1708 mServiceContext.sendBroadcast( 1709 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1710 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1711 ); 1712 1713 assertNetworkPolicyEquals(DEFAULT_CYCLE_DAY, mDefaultWarningBytes, mDefaultLimitBytes, 1714 true); 1715 } 1716 1717 @Test 1718 public void testUpdateCarrierPolicyCycleWithUserOverrides() throws RemoteException { 1719 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1720 1721 // inferred = false implies that a user manually modified this policy. 1722 NetworkPolicy policy = buildDefaultFakeCarrierPolicy(); 1723 policy.inferred = false; 1724 setNetworkPolicies(policy); 1725 1726 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 31); 1727 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 9999); 1728 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 1729 DATA_CYCLE_THRESHOLD_DISABLED); 1730 mServiceContext.sendBroadcast( 1731 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1732 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1733 ); 1734 1735 // The policy still shouldn't change, because we don't want to overwrite user settings. 1736 assertNetworkPolicyEquals(DEFAULT_CYCLE_DAY, mDefaultWarningBytes, mDefaultLimitBytes, 1737 false); 1738 } 1739 1740 @Test 1741 public void testUpdateCarrierPolicyCycleUpdatesDataCycle() throws RemoteException { 1742 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1743 1744 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 31); 1745 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 9999); 1746 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 9999); 1747 mServiceContext.sendBroadcast( 1748 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1749 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1750 ); 1751 1752 assertNetworkPolicyEquals(31, 9999, 9999, true); 1753 } 1754 1755 @Test 1756 public void testUpdateCarrierPolicyCycleDisableThresholds() throws RemoteException { 1757 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1758 1759 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 31); 1760 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 1761 DATA_CYCLE_THRESHOLD_DISABLED); 1762 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 1763 DATA_CYCLE_THRESHOLD_DISABLED); 1764 mServiceContext.sendBroadcast( 1765 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1766 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1767 ); 1768 1769 assertNetworkPolicyEquals(31, WARNING_DISABLED, LIMIT_DISABLED, true); 1770 } 1771 1772 @Test 1773 public void testUpdateCarrierPolicyCycleRevertsToDefault() throws RemoteException { 1774 PersistableBundle bundle = setupUpdateCarrierPolicyCycleTests(); 1775 1776 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 31); 1777 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 1778 DATA_CYCLE_THRESHOLD_DISABLED); 1779 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 1780 DATA_CYCLE_THRESHOLD_DISABLED); 1781 mServiceContext.sendBroadcast( 1782 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1783 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1784 ); 1785 assertNetworkPolicyEquals(31, WARNING_DISABLED, LIMIT_DISABLED, true); 1786 1787 // If the user switches carriers to one that doesn't use a CarrierConfig, we should revert 1788 // to the default data limit and warning. The cycle date doesn't need to revert as it's 1789 // arbitrary anyways. 1790 bundle.putInt(CarrierConfigManager.KEY_MONTHLY_DATA_CYCLE_DAY_INT, 1791 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1792 bundle.putLong(CarrierConfigManager.KEY_DATA_WARNING_THRESHOLD_BYTES_LONG, 1793 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1794 bundle.putLong(CarrierConfigManager.KEY_DATA_LIMIT_THRESHOLD_BYTES_LONG, 1795 DATA_CYCLE_USE_PLATFORM_DEFAULT); 1796 mServiceContext.sendBroadcast( 1797 new Intent(ACTION_CARRIER_CONFIG_CHANGED) 1798 .putExtra(CarrierConfigManager.EXTRA_SUBSCRIPTION_INDEX, FAKE_SUB_ID) 1799 ); 1800 1801 assertNetworkPolicyEquals(31, mDefaultWarningBytes, mDefaultLimitBytes, 1802 true); 1803 } 1804 1805 @Test 1806 public void testOpportunisticQuota() throws Exception { 1807 final Network net = TEST_NETWORK; 1808 final NetworkPolicyManagerInternal internal = LocalServices 1809 .getService(NetworkPolicyManagerInternal.class); 1810 1811 // Get active mobile network in place 1812 expectMobileDefaults(); 1813 mService.updateNetworks(); 1814 1815 // We're 20% through the month (6 days) 1816 final long start = parseTime("2015-11-01T00:00Z"); 1817 final long end = parseTime("2015-11-07T00:00Z"); 1818 setCurrentTimeMillis(end); 1819 1820 // Get some data usage in place 1821 mDeps.setMockedTotalBytes(UID_A, DataUnit.MEGABYTES.toBytes(360), 0); 1822 1823 // No data plan 1824 { 1825 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1826 expectMobileDefaults(); 1827 1828 mService.updateNetworks(); 1829 1830 // No quotas 1831 assertEquals(OPPORTUNISTIC_QUOTA_UNKNOWN, 1832 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_JOBS)); 1833 assertEquals(OPPORTUNISTIC_QUOTA_UNKNOWN, 1834 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_MULTIPATH)); 1835 } 1836 1837 // Limited data plan 1838 { 1839 final SubscriptionPlan plan = buildMonthlyDataPlan( 1840 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), 1841 DataUnit.MEGABYTES.toBytes(1800)); 1842 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[]{plan}, 1843 mServiceContext.getOpPackageName()); 1844 1845 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1846 expectMobileDefaults(); 1847 1848 mService.updateNetworks(); 1849 1850 // We have 1440MB and 24 days left, which is 60MB/day; assuming 10% 1851 // for quota split equally between two types gives 3MB. 1852 assertEquals(DataUnit.MEGABYTES.toBytes(3), 1853 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_JOBS)); 1854 assertEquals(DataUnit.MEGABYTES.toBytes(3), 1855 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_MULTIPATH)); 1856 } 1857 1858 // Limited data plan, over quota 1859 { 1860 final SubscriptionPlan plan = buildMonthlyDataPlan( 1861 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), 1862 DataUnit.MEGABYTES.toBytes(100)); 1863 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[]{plan}, 1864 mServiceContext.getOpPackageName()); 1865 1866 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1867 expectMobileDefaults(); 1868 1869 mService.updateNetworks(); 1870 1871 assertEquals(0L, internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_JOBS)); 1872 assertEquals(0L, internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_MULTIPATH)); 1873 } 1874 1875 // Roaming 1876 { 1877 final SubscriptionPlan plan = buildMonthlyDataPlan( 1878 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), BYTES_UNLIMITED); 1879 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[]{plan}, 1880 mServiceContext.getOpPackageName()); 1881 1882 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1883 expectMobileDefaults(); 1884 expectNetworkStateSnapshot(true /* roaming */); 1885 1886 mService.updateNetworks(); 1887 1888 assertEquals(0L, internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_JOBS)); 1889 assertEquals(0L, internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_MULTIPATH)); 1890 } 1891 1892 // Unlimited data plan 1893 { 1894 final SubscriptionPlan plan = buildMonthlyDataPlan( 1895 ZonedDateTime.parse("2015-11-01T00:00:00.00Z"), BYTES_UNLIMITED); 1896 setSubscriptionPlans(TEST_SUB_ID, new SubscriptionPlan[]{plan}, 1897 mServiceContext.getOpPackageName()); 1898 1899 reset(mTelephonyManager, mNetworkManager, mNotifManager); 1900 expectMobileDefaults(); 1901 1902 mService.updateNetworks(); 1903 1904 // 20MB/day, split equally between two types gives 10MB. 1905 assertEquals(DataUnit.MEBIBYTES.toBytes(10), 1906 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_JOBS)); 1907 assertEquals(DataUnit.MEBIBYTES.toBytes(10), 1908 internal.getSubscriptionOpportunisticQuota(net, QUOTA_TYPE_MULTIPATH)); 1909 1910 // Capabilities change to roaming 1911 final ConnectivityManager.NetworkCallback callback = mNetworkCallbackCaptor.getValue(); 1912 assertNotNull(callback); 1913 expectNetworkStateSnapshot(true /* roaming */); 1914 callback.onCapabilitiesChanged( 1915 TEST_NETWORK, buildNetworkCapabilities(TEST_SUB_ID, true /* roaming */)); 1916 1917 assertEquals(0, internal.getSubscriptionOpportunisticQuota( 1918 TEST_NETWORK, NetworkPolicyManagerInternal.QUOTA_TYPE_MULTIPATH)); 1919 } 1920 } 1921 1922 /** 1923 * Test that policy set of {null, NetworkPolicy, null} does not crash and restores the valid 1924 * NetworkPolicy. 1925 */ 1926 @Test 1927 public void testSetNetworkPolicies_withNullPolicies_doesNotThrow() { 1928 NetworkPolicy[] policies = new NetworkPolicy[3]; 1929 policies[1] = buildDefaultFakeCarrierPolicy(); 1930 setNetworkPolicies(policies); 1931 1932 assertNetworkPolicyEquals(DEFAULT_CYCLE_DAY, mDefaultWarningBytes, mDefaultLimitBytes, 1933 true); 1934 } 1935 1936 private void triggerOnStatsProviderWarningOrLimitReached() throws InterruptedException { 1937 mService.notifyStatsProviderWarningOrLimitReached(); 1938 // Wait for processing of MSG_STATS_PROVIDER_WARNING_OR_LIMIT_REACHED. 1939 postMsgAndWaitForCompletion(); 1940 verify(mStatsManager).forceUpdate(); 1941 // Wait for processing of MSG_*_INTERFACE_QUOTAS. 1942 postMsgAndWaitForCompletion(); 1943 } 1944 1945 /** 1946 * Test that when StatsProvider triggers warning and limit reached, new quotas will be 1947 * calculated and re-armed. 1948 */ 1949 @Test 1950 public void testStatsProviderWarningAndLimitReached() throws Exception { 1951 final int CYCLE_DAY = 15; 1952 1953 mDeps.setMockedTotalBytes(UID_A, 2999, 2000); 1954 1955 // Get active mobile network in place 1956 expectMobileDefaults(); 1957 mService.updateNetworks(); 1958 verify(mStatsManager).setStatsProviderWarningAndLimitAsync(TEST_IFACE, Long.MAX_VALUE, 1959 Long.MAX_VALUE); 1960 1961 // Set warning to 7KB and limit to 10KB. 1962 setNetworkPolicies(new NetworkPolicy( 1963 sTemplateCarrierMetered, CYCLE_DAY, TIMEZONE_UTC, 7000L, 10000L, 1964 true)); 1965 postMsgAndWaitForCompletion(); 1966 1967 // Verifies that remaining quotas are set to providers. 1968 verify(mStatsManager).setStatsProviderWarningAndLimitAsync(TEST_IFACE, 2001L, 5001L); 1969 reset(mStatsManager); 1970 1971 // Increase the usage and simulates that limit reached fires earlier by provider, 1972 // but actually the quota is not yet reached. Verifies that the limit reached leads to 1973 // a force update and new quotas should be set. 1974 mDeps.increaseMockedTotalBytes(UID_A, 1000, 999); 1975 triggerOnStatsProviderWarningOrLimitReached(); 1976 verify(mStatsManager).setStatsProviderWarningAndLimitAsync(TEST_IFACE, 2L, 3002L); 1977 reset(mStatsManager); 1978 1979 // Increase the usage and simulate warning reached, the new warning should be unlimited 1980 // since service will disable warning quota to stop lower layer from keep triggering 1981 // warning reached event. 1982 mDeps.increaseMockedTotalBytes(UID_A, 1000L, 1000); 1983 triggerOnStatsProviderWarningOrLimitReached(); 1984 verify(mStatsManager).setStatsProviderWarningAndLimitAsync( 1985 TEST_IFACE, Long.MAX_VALUE, 1002L); 1986 reset(mStatsManager); 1987 1988 // Increase the usage that over the warning and limit, the new limit should set to 1 to 1989 // block the network traffic. 1990 mDeps.increaseMockedTotalBytes(UID_A, 1000L, 1000); 1991 triggerOnStatsProviderWarningOrLimitReached(); 1992 verify(mStatsManager).setStatsProviderWarningAndLimitAsync(TEST_IFACE, Long.MAX_VALUE, 1L); 1993 reset(mStatsManager); 1994 } 1995 1996 private void enableRestrictedMode(boolean enable) throws Exception { 1997 mService.mRestrictedNetworkingMode = enable; 1998 mService.updateRestrictedModeAllowlistUL(); 1999 verify(mNetworkManager).setFirewallChainEnabled(FIREWALL_CHAIN_RESTRICTED, 2000 enable); 2001 } 2002 2003 @Test 2004 public void testUpdateRestrictedModeAllowlist() throws Exception { 2005 // initialization calls setFirewallChainEnabled, so we want to reset the invocations. 2006 clearInvocations(mNetworkManager); 2007 expectHasUseRestrictedNetworksPermission(UID_A, true); 2008 expectHasUseRestrictedNetworksPermission(UID_B, false); 2009 2010 Map<Integer, Integer> firewallUidRules = new ArrayMap<>(); 2011 doAnswer(arg -> { 2012 int[] uids = arg.getArgument(1); 2013 int[] rules = arg.getArgument(2); 2014 assertTrue(uids.length == rules.length); 2015 2016 for (int i = 0; i < uids.length; ++i) { 2017 firewallUidRules.put(uids[i], rules[i]); 2018 } 2019 return null; 2020 }).when(mNetworkManager).setFirewallUidRules(eq(FIREWALL_CHAIN_RESTRICTED), 2021 any(int[].class), any(int[].class)); 2022 2023 enableRestrictedMode(true); 2024 assertEquals(FIREWALL_RULE_ALLOW, firewallUidRules.get(UID_A).intValue()); 2025 assertFalse(mService.isUidNetworkingBlocked(UID_A, false)); 2026 assertTrue(mService.isUidNetworkingBlocked(UID_B, false)); 2027 2028 enableRestrictedMode(false); 2029 assertFalse(mService.isUidNetworkingBlocked(UID_A, false)); 2030 assertFalse(mService.isUidNetworkingBlocked(UID_B, false)); 2031 } 2032 2033 @Test testUpdateRestrictedModeForUid()2034 public void testUpdateRestrictedModeForUid() throws Exception { 2035 // initialization calls setFirewallChainEnabled, so we want to reset the invocations. 2036 clearInvocations(mNetworkManager); 2037 expectHasUseRestrictedNetworksPermission(UID_A, true); 2038 expectHasUseRestrictedNetworksPermission(UID_B, false); 2039 enableRestrictedMode(true); 2040 2041 // UID_D and UID_E are not part of installed applications list, so it won't have any 2042 // firewall rules set yet 2043 expectHasUseRestrictedNetworksPermission(UID_D, false); 2044 mService.updateRestrictedModeForUidUL(UID_D); 2045 verify(mNetworkManager).setFirewallUidRule(FIREWALL_CHAIN_RESTRICTED, UID_D, 2046 FIREWALL_RULE_DEFAULT); 2047 assertTrue(mService.isUidNetworkingBlocked(UID_D, false)); 2048 2049 expectHasUseRestrictedNetworksPermission(UID_E, true); 2050 mService.updateRestrictedModeForUidUL(UID_E); 2051 verify(mNetworkManager).setFirewallUidRule(FIREWALL_CHAIN_RESTRICTED, UID_E, 2052 FIREWALL_RULE_ALLOW); 2053 assertFalse(mService.isUidNetworkingBlocked(UID_E, false)); 2054 } 2055 2056 @Test testLowPowerStandbyAllowlist()2057 public void testLowPowerStandbyAllowlist() throws Exception { 2058 callAndWaitOnUidStateChanged(UID_A, PROCESS_STATE_TOP, 0); 2059 callAndWaitOnUidStateChanged(UID_B, ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE, 0); 2060 callAndWaitOnUidStateChanged(UID_C, ActivityManager.PROCESS_STATE_FOREGROUND_SERVICE, 0); 2061 expectHasInternetPermission(UID_A, true); 2062 expectHasInternetPermission(UID_B, true); 2063 expectHasInternetPermission(UID_C, true); 2064 2065 final NetworkPolicyManagerInternal internal = LocalServices 2066 .getService(NetworkPolicyManagerInternal.class); 2067 2068 Map<Integer, Integer> firewallUidRules = new ArrayMap<>(); 2069 doAnswer(arg -> { 2070 int[] uids = arg.getArgument(1); 2071 int[] rules = arg.getArgument(2); 2072 assertTrue(uids.length == rules.length); 2073 2074 for (int i = 0; i < uids.length; ++i) { 2075 firewallUidRules.put(uids[i], rules[i]); 2076 } 2077 return null; 2078 }).when(mNetworkManager).setFirewallUidRules(eq(FIREWALL_CHAIN_LOW_POWER_STANDBY), 2079 any(int[].class), any(int[].class)); 2080 2081 internal.setLowPowerStandbyAllowlist(new int[] { UID_B }); 2082 internal.setLowPowerStandbyActive(true); 2083 assertEquals(FIREWALL_RULE_ALLOW, firewallUidRules.get(UID_A).intValue()); 2084 assertEquals(FIREWALL_RULE_ALLOW, firewallUidRules.get(UID_B).intValue()); 2085 assertFalse(mService.isUidNetworkingBlocked(UID_A, false)); 2086 assertFalse(mService.isUidNetworkingBlocked(UID_B, false)); 2087 assertTrue(mService.isUidNetworkingBlocked(UID_C, false)); 2088 2089 internal.setLowPowerStandbyActive(false); 2090 assertFalse(mService.isUidNetworkingBlocked(UID_A, false)); 2091 assertFalse(mService.isUidNetworkingBlocked(UID_B, false)); 2092 assertFalse(mService.isUidNetworkingBlocked(UID_C, false)); 2093 } 2094 2095 @Test testUpdateEffectiveBlockedReasons()2096 public void testUpdateEffectiveBlockedReasons() { 2097 final Map<Pair<Integer, Integer>, Integer> effectiveBlockedReasons = new HashMap<>(); 2098 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_NONE, ALLOWED_REASON_NONE), 2099 BLOCKED_REASON_NONE); 2100 2101 effectiveBlockedReasons.put( 2102 Pair.create(BLOCKED_REASON_BATTERY_SAVER, ALLOWED_REASON_SYSTEM), 2103 BLOCKED_REASON_NONE); 2104 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_BATTERY_SAVER | BLOCKED_REASON_DOZE, 2105 ALLOWED_REASON_SYSTEM), BLOCKED_REASON_NONE); 2106 effectiveBlockedReasons.put( 2107 Pair.create(BLOCKED_METERED_REASON_DATA_SAVER, ALLOWED_METERED_REASON_SYSTEM), 2108 BLOCKED_REASON_NONE); 2109 effectiveBlockedReasons.put(Pair.create(BLOCKED_METERED_REASON_DATA_SAVER 2110 | BLOCKED_METERED_REASON_USER_RESTRICTED, 2111 ALLOWED_METERED_REASON_SYSTEM), BLOCKED_REASON_NONE); 2112 2113 effectiveBlockedReasons.put( 2114 Pair.create(BLOCKED_REASON_BATTERY_SAVER | BLOCKED_METERED_REASON_DATA_SAVER, 2115 ALLOWED_REASON_SYSTEM), BLOCKED_METERED_REASON_DATA_SAVER); 2116 effectiveBlockedReasons.put( 2117 Pair.create(BLOCKED_REASON_APP_STANDBY | BLOCKED_METERED_REASON_USER_RESTRICTED, 2118 ALLOWED_METERED_REASON_SYSTEM), BLOCKED_REASON_APP_STANDBY); 2119 2120 effectiveBlockedReasons.put( 2121 Pair.create(BLOCKED_REASON_BATTERY_SAVER, ALLOWED_REASON_FOREGROUND), 2122 BLOCKED_REASON_NONE); 2123 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_BATTERY_SAVER | BLOCKED_REASON_DOZE, 2124 ALLOWED_REASON_FOREGROUND), BLOCKED_REASON_NONE); 2125 effectiveBlockedReasons.put( 2126 Pair.create(BLOCKED_METERED_REASON_DATA_SAVER, ALLOWED_METERED_REASON_FOREGROUND), 2127 BLOCKED_REASON_NONE); 2128 effectiveBlockedReasons.put(Pair.create(BLOCKED_METERED_REASON_DATA_SAVER 2129 | BLOCKED_METERED_REASON_USER_RESTRICTED, 2130 ALLOWED_METERED_REASON_FOREGROUND), BLOCKED_REASON_NONE); 2131 effectiveBlockedReasons.put( 2132 Pair.create(BLOCKED_REASON_BATTERY_SAVER | BLOCKED_METERED_REASON_DATA_SAVER, 2133 ALLOWED_REASON_FOREGROUND), BLOCKED_METERED_REASON_DATA_SAVER); 2134 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_BATTERY_SAVER 2135 | BLOCKED_METERED_REASON_USER_RESTRICTED, 2136 ALLOWED_METERED_REASON_FOREGROUND), BLOCKED_REASON_BATTERY_SAVER); 2137 2138 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_LOW_POWER_STANDBY, 2139 ALLOWED_REASON_FOREGROUND), BLOCKED_REASON_LOW_POWER_STANDBY); 2140 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_LOW_POWER_STANDBY, 2141 ALLOWED_REASON_TOP), BLOCKED_REASON_NONE); 2142 effectiveBlockedReasons.put(Pair.create(BLOCKED_REASON_LOW_POWER_STANDBY, 2143 ALLOWED_REASON_LOW_POWER_STANDBY_ALLOWLIST), BLOCKED_REASON_NONE); 2144 // TODO: test more combinations of blocked reasons. 2145 2146 for (Map.Entry<Pair<Integer, Integer>, Integer> test : effectiveBlockedReasons.entrySet()) { 2147 final int expectedEffectiveBlockedReasons = test.getValue(); 2148 final int blockedReasons = test.getKey().first; 2149 final int allowedReasons = test.getKey().second; 2150 final String errorMsg = "Expected=" 2151 + blockedReasonsToString(expectedEffectiveBlockedReasons) 2152 + "; blockedReasons=" + blockedReasonsToString(blockedReasons) 2153 + ", allowedReasons=" + allowedReasonsToString(allowedReasons); 2154 assertEquals(errorMsg, expectedEffectiveBlockedReasons, 2155 getEffectiveBlockedReasons(blockedReasons, allowedReasons)); 2156 } 2157 } 2158 2159 @Test 2160 @NetPolicyXml("network-policy-mobile.xml") testStartToSupportCarrierUsagePolicy()2161 public void testStartToSupportCarrierUsagePolicy() throws Exception { 2162 NetworkPolicy[] policies = mService.getNetworkPolicies( 2163 mServiceContext.getOpPackageName()); 2164 assertEquals("Unexpected number of network policies", 1, policies.length); 2165 NetworkPolicy actualPolicy = policies[0]; 2166 assertEquals("Unexpected template match rule in network policies", 2167 NetworkTemplate.MATCH_CARRIER, 2168 actualPolicy.template.getMatchRule()); 2169 assertTrue("Unexpected subscriberIds size in network policies", 2170 actualPolicy.template.getSubscriberIds().size() > 0); 2171 assertEquals("Unexpected template meteredness in network policies", 2172 METERED_YES, actualPolicy.template.getMeteredness()); 2173 } 2174 2175 @Test 2176 @NetPolicyXml("network-policy-wifi-with-subscriberId-match-rule-all-and-templateMetered-no.xml") testSupportedCarrierUsagePolicy()2177 public void testSupportedCarrierUsagePolicy() throws Exception { 2178 NetworkPolicy[] policies = mService.getNetworkPolicies( 2179 mServiceContext.getOpPackageName()); 2180 assertEquals("Unexpected number of network policies", 1, policies.length); 2181 NetworkPolicy actualPolicy = policies[0]; 2182 assertEquals("Unexpected template match rule in network policies", 2183 MATCH_WIFI, 2184 actualPolicy.template.getMatchRule()); 2185 assertEquals("Unexpected subscriberIds size in network policies", 2186 actualPolicy.template.getSubscriberIds().size(), 0); 2187 assertEquals("Unexpected template meteredness in network policies", 2188 METERED_NO, actualPolicy.template.getMeteredness()); 2189 } 2190 2191 @Test testNormalizeTemplate_duplicatedMergedImsiList()2192 public void testNormalizeTemplate_duplicatedMergedImsiList() { 2193 // This test leads to a Log.wtf, so skip it on eng builds. Otherwise, Log.wtf() would 2194 // result in this process getting killed. 2195 Assume.assumeFalse(Build.IS_ENG); 2196 final NetworkTemplate template = new NetworkTemplate.Builder(MATCH_CARRIER) 2197 .setSubscriberIds(Set.of(TEST_IMSI)).build(); 2198 final String[] mergedImsiGroup = new String[] {TEST_IMSI, TEST_IMSI}; 2199 final ArrayList<String[]> mergedList = new ArrayList<>(); 2200 mergedList.add(mergedImsiGroup); 2201 // Verify the duplicated items in the merged IMSI list won't crash the system. 2202 final NetworkTemplate result = normalizeTemplate(template, mergedList); 2203 assertEquals(template, result); 2204 } 2205 formatBlockedStateError(int uid, int rule, boolean metered, boolean backgroundRestricted)2206 private String formatBlockedStateError(int uid, int rule, boolean metered, 2207 boolean backgroundRestricted) { 2208 return String.format( 2209 "Unexpected BlockedState: (uid=%d, rule=%s, metered=%b, backgroundRestricted=%b)", 2210 uid, uidRulesToString(rule), metered, backgroundRestricted); 2211 } 2212 buildMonthlyDataPlan(ZonedDateTime start, long limitBytes)2213 private SubscriptionPlan buildMonthlyDataPlan(ZonedDateTime start, long limitBytes) { 2214 return SubscriptionPlan.Builder 2215 .createRecurringMonthly(start) 2216 .setDataLimit(limitBytes, LIMIT_BEHAVIOR_DISABLED) 2217 .build(); 2218 } 2219 buildApplicationInfo(String label, int uid)2220 private ApplicationInfo buildApplicationInfo(String label, int uid) { 2221 final ApplicationInfo ai = new ApplicationInfo(); 2222 ai.nonLocalizedLabel = label; 2223 ai.uid = uid; 2224 return ai; 2225 } 2226 buildInstalledPackageList()2227 private List<AndroidPackage> buildInstalledPackageList() { 2228 final List<AndroidPackage> installedApps = new ArrayList<>(); 2229 installedApps.add(createPackageMock(UID_A)); 2230 installedApps.add(createPackageMock(UID_B)); 2231 installedApps.add(createPackageMock(UID_C)); 2232 return installedApps; 2233 } 2234 createPackageMock(int uid)2235 private AndroidPackage createPackageMock(int uid) { 2236 final AndroidPackage androidPackage = mock(AndroidPackage.class); 2237 when(androidPackage.getUid()).thenReturn(uid); 2238 return androidPackage; 2239 } 2240 buildUserInfoList()2241 private List<UserInfo> buildUserInfoList() { 2242 final List<UserInfo> users = new ArrayList<>(); 2243 users.add(new UserInfo(USER_ID, "user1", 0)); 2244 return users; 2245 } 2246 buildLinkProperties(String iface)2247 private LinkProperties buildLinkProperties(String iface) { 2248 final LinkProperties lp = new LinkProperties(); 2249 lp.setInterfaceName(iface); 2250 return lp; 2251 } 2252 buildNetworkCapabilities(int subId, boolean roaming)2253 private NetworkCapabilities buildNetworkCapabilities(int subId, boolean roaming) { 2254 final NetworkCapabilities.Builder builder = new NetworkCapabilities.Builder(); 2255 builder.addTransportType(TRANSPORT_CELLULAR); 2256 if (!roaming) { 2257 builder.addCapability(NET_CAPABILITY_NOT_ROAMING); 2258 } 2259 builder.setNetworkSpecifier(new TelephonyNetworkSpecifier.Builder() 2260 .setSubscriptionId(subId).build()); 2261 return builder.build(); 2262 } 2263 buildDefaultFakeCarrierPolicy()2264 private NetworkPolicy buildDefaultFakeCarrierPolicy() { 2265 NetworkPolicy p = mService.buildDefaultCarrierPolicy(FAKE_SUB_ID, FAKE_SUBSCRIBER_ID); 2266 // set a deterministic cycle date 2267 p.cycleRule = new RecurrenceRule( 2268 p.cycleRule.start.withDayOfMonth(DEFAULT_CYCLE_DAY), 2269 p.cycleRule.end, Period.ofMonths(1)); 2270 return p; 2271 } 2272 buildFakeCarrierPolicy(int cycleDay, long warningBytes, long limitBytes, boolean inferred)2273 private static NetworkPolicy buildFakeCarrierPolicy(int cycleDay, long warningBytes, 2274 long limitBytes, boolean inferred) { 2275 // TODO: Refactor this to use sTemplateCarrierMetered. 2276 final NetworkTemplate template = new NetworkTemplate.Builder(MATCH_CARRIER) 2277 .setSubscriberIds(Set.of(FAKE_SUBSCRIBER_ID)) 2278 .setMeteredness(METERED_YES).build(); 2279 return new NetworkPolicy(template, cycleDay, TimeZone.getDefault().getID(), warningBytes, 2280 limitBytes, SNOOZE_NEVER, SNOOZE_NEVER, true, inferred); 2281 } 2282 assertNetworkPolicyEquals(int expectedCycleDay, long expectedWarningBytes, long expectedLimitBytes, boolean expectedInferred)2283 private void assertNetworkPolicyEquals(int expectedCycleDay, long expectedWarningBytes, 2284 long expectedLimitBytes, boolean expectedInferred) { 2285 NetworkPolicy[] policies = mService.getNetworkPolicies( 2286 mServiceContext.getOpPackageName()); 2287 assertEquals("Unexpected number of network policies", 1, policies.length); 2288 NetworkPolicy actualPolicy = policies[0]; 2289 NetworkPolicy expectedPolicy = buildFakeCarrierPolicy(expectedCycleDay, 2290 expectedWarningBytes, expectedLimitBytes, expectedInferred); 2291 assertEquals(expectedPolicy, actualPolicy); 2292 } 2293 parseTime(String time)2294 private static long parseTime(String time) { 2295 return ZonedDateTime.parse(time).toInstant().toEpochMilli(); 2296 } 2297 setNetworkPolicies(NetworkPolicy... policies)2298 private void setNetworkPolicies(NetworkPolicy... policies) { 2299 mService.setNetworkPolicies(policies); 2300 } 2301 buildWifi()2302 private static NetworkStateSnapshot buildWifi() { 2303 WifiInfo mockWifiInfo = mock(WifiInfo.class); 2304 when(mockWifiInfo.makeCopy(anyLong())).thenReturn(mockWifiInfo); 2305 when(mockWifiInfo.getNetworkKey()).thenReturn(TEST_WIFI_NETWORK_KEY); 2306 final LinkProperties prop = new LinkProperties(); 2307 prop.setInterfaceName(TEST_IFACE); 2308 final NetworkCapabilities networkCapabilities = new NetworkCapabilities.Builder() 2309 .addTransportType(TRANSPORT_WIFI).setTransportInfo(mockWifiInfo).build(); 2310 return new NetworkStateSnapshot(TEST_NETWORK, networkCapabilities, prop, 2311 null /*subscriberId*/, TYPE_WIFI); 2312 } 2313 expectHasInternetPermission(int uid, boolean hasIt)2314 private void expectHasInternetPermission(int uid, boolean hasIt) throws Exception { 2315 when(mIpm.checkUidPermission(Manifest.permission.INTERNET, uid)).thenReturn( 2316 hasIt ? PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED); 2317 } 2318 expectHasUseRestrictedNetworksPermission(int uid, boolean hasIt)2319 private void expectHasUseRestrictedNetworksPermission(int uid, boolean hasIt) throws Exception { 2320 when(mIpm.checkUidPermission(CONNECTIVITY_USE_RESTRICTED_NETWORKS, uid)).thenReturn( 2321 hasIt ? PackageManager.PERMISSION_GRANTED : PackageManager.PERMISSION_DENIED); 2322 when(mIpm.checkUidPermission(NETWORK_STACK, uid)).thenReturn( 2323 PackageManager.PERMISSION_DENIED); 2324 when(mIpm.checkUidPermission(PERMISSION_MAINLINE_NETWORK_STACK, uid)).thenReturn( 2325 PackageManager.PERMISSION_DENIED); 2326 } 2327 expectNetworkStateSnapshot(boolean roaming)2328 private void expectNetworkStateSnapshot(boolean roaming) throws Exception { 2329 when(mCarrierConfigManager.getConfigForSubId(eq(TEST_SUB_ID))) 2330 .thenReturn(mCarrierConfig); 2331 List<NetworkStateSnapshot> snapshots = List.of(new NetworkStateSnapshot( 2332 TEST_NETWORK, 2333 buildNetworkCapabilities(TEST_SUB_ID, roaming), 2334 buildLinkProperties(TEST_IFACE), TEST_IMSI, TYPE_MOBILE)); 2335 when(mConnManager.getAllNetworkStateSnapshots()).thenReturn(snapshots); 2336 } 2337 expectDefaultCarrierConfig()2338 private void expectDefaultCarrierConfig() throws Exception { 2339 when(mCarrierConfigManager.getConfigForSubId(eq(TEST_SUB_ID))) 2340 .thenReturn(CarrierConfigManager.getDefaultConfig()); 2341 } 2342 expectMobileDefaults()2343 private TelephonyManager expectMobileDefaults() throws Exception { 2344 TelephonyManager tmSub = setupTelephonySubscriptionManagers(TEST_SUB_ID, TEST_IMSI); 2345 doNothing().when(tmSub).setPolicyDataEnabled(anyBoolean()); 2346 expectNetworkStateSnapshot(false /* roaming */); 2347 return tmSub; 2348 } 2349 verifyAdvisePersistThreshold()2350 private void verifyAdvisePersistThreshold() throws Exception { 2351 verify(mStatsManager).setDefaultGlobalAlert(anyLong()); 2352 } 2353 2354 private static class TestAbstractFuture<T> extends AbstractFuture<T> { 2355 @Override get()2356 public T get() throws InterruptedException, ExecutionException { 2357 try { 2358 return get(5, TimeUnit.SECONDS); 2359 } catch (TimeoutException e) { 2360 throw new RuntimeException(e); 2361 } 2362 } 2363 } 2364 assertTimeEquals(long expected, long actual)2365 private static void assertTimeEquals(long expected, long actual) { 2366 if (expected != actual) { 2367 fail("expected " + formatTime(expected) + " but was actually " + formatTime(actual)); 2368 } 2369 } 2370 formatTime(long millis)2371 private static String formatTime(long millis) { 2372 return Instant.ofEpochMilli(millis) + " [" + millis + "]"; 2373 } 2374 assertEqualsFuzzy(long expected, long actual, long fuzzy)2375 private static void assertEqualsFuzzy(long expected, long actual, long fuzzy) { 2376 final long low = expected - fuzzy; 2377 final long high = expected + fuzzy; 2378 if (actual < low || actual > high) { 2379 fail("value " + formatTime(actual) + " is outside [" + formatTime(low) + "," 2380 + formatTime(high) + "]"); 2381 } 2382 } 2383 assertUnique(LinkedHashSet<Long> seen, Long value)2384 private static void assertUnique(LinkedHashSet<Long> seen, Long value) { 2385 if (!seen.add(value)) { 2386 fail("found duplicate time " + value + " in series " + seen.toString()); 2387 } 2388 } 2389 assertNotificationType(int expected, String actualTag)2390 private static void assertNotificationType(int expected, String actualTag) { 2391 assertEquals("notification type mismatch for '" + actualTag + "'", 2392 Integer.toString(expected), actualTag.substring(actualTag.lastIndexOf(':') + 1)); 2393 } 2394 assertUidPolicy(int uid, int expected)2395 private void assertUidPolicy(int uid, int expected) { 2396 final int actual = mService.getUidPolicy(uid); 2397 if (expected != actual) { 2398 fail("Wrong policy for UID " + uid + ": expected " + uidPoliciesToString(expected) 2399 + ", actual " + uidPoliciesToString(actual)); 2400 } 2401 } 2402 assertRestrictBackgroundAllowedUids(int... uids)2403 private void assertRestrictBackgroundAllowedUids(int... uids) { 2404 assertContainsInAnyOrder(mService.getUidsWithPolicy(POLICY_ALLOW_METERED_BACKGROUND), uids); 2405 } 2406 assertRestrictBackgroundOn()2407 private void assertRestrictBackgroundOn() throws Exception { 2408 assertTrue("restrictBackground should be set", mService.getRestrictBackground()); 2409 } 2410 assertRestrictBackgroundOff()2411 private void assertRestrictBackgroundOff() throws Exception { 2412 assertFalse("restrictBackground should not be set", mService.getRestrictBackground()); 2413 } 2414 newRestrictBackgroundChangedFuture()2415 private FutureIntent newRestrictBackgroundChangedFuture() { 2416 return mServiceContext 2417 .nextBroadcastIntent(ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED); 2418 } 2419 assertRestrictBackgroundChangedReceived(Future<Intent> future, String expectedPackage)2420 private void assertRestrictBackgroundChangedReceived(Future<Intent> future, 2421 String expectedPackage) throws Exception { 2422 final String action = ConnectivityManager.ACTION_RESTRICT_BACKGROUND_CHANGED; 2423 final Intent intent = future.get(5, TimeUnit.SECONDS); 2424 assertNotNull("Didn't get a " + action + "intent in 5 seconds"); 2425 assertEquals("Wrong package on " + action + " intent", 2426 expectedPackage, intent.getPackage()); 2427 } 2428 2429 // TODO: replace by Truth, Hamcrest, or a similar tool. assertContainsInAnyOrder(int[] actual, int...expected)2430 private void assertContainsInAnyOrder(int[] actual, int...expected) { 2431 final StringBuilder errors = new StringBuilder(); 2432 if (actual.length != expected.length) { 2433 errors.append("\tsize does not match\n"); 2434 } 2435 final List<Integer> actualList = 2436 Arrays.stream(actual).boxed().collect(Collectors.<Integer>toList()); 2437 final List<Integer> expectedList = 2438 Arrays.stream(expected).boxed().collect(Collectors.<Integer>toList()); 2439 if (!actualList.containsAll(expectedList)) { 2440 errors.append("\tmissing elements on actual list\n"); 2441 } 2442 if (!expectedList.containsAll(actualList)) { 2443 errors.append("\tmissing elements on expected list\n"); 2444 } 2445 if (errors.length() > 0) { 2446 fail("assertContainsInAnyOrder(expected=" + Arrays.toString(expected) 2447 + ", actual=" + Arrays.toString(actual) + ") failed: \n" + errors); 2448 } 2449 } 2450 getElapsedRealtime()2451 private long getElapsedRealtime() { 2452 return mElapsedRealtime; 2453 } 2454 setCurrentTimeMillis(long currentTimeMillis)2455 private void setCurrentTimeMillis(long currentTimeMillis) { 2456 RecurrenceRule.sClock = Clock.fixed(Instant.ofEpochMilli(currentTimeMillis), 2457 ZoneId.systemDefault()); 2458 mStartTime = currentTimeMillis; 2459 mElapsedRealtime = 0L; 2460 } 2461 currentTimeMillis()2462 private long currentTimeMillis() { 2463 return mStartTime + mElapsedRealtime; 2464 } 2465 incrementCurrentTime(long duration)2466 private void incrementCurrentTime(long duration) { 2467 mElapsedRealtime += duration; 2468 } 2469 2470 private FutureIntent mRestrictBackgroundChanged; 2471 postMsgAndWaitForCompletion()2472 private void postMsgAndWaitForCompletion() throws InterruptedException { 2473 final Handler handler = mService.getHandlerForTesting(); 2474 final CountDownLatch latch = new CountDownLatch(1); 2475 mService.getHandlerForTesting().post(latch::countDown); 2476 if (!latch.await(5, TimeUnit.SECONDS)) { 2477 fail("Timed out waiting for the test msg to be handled"); 2478 } 2479 } 2480 setSubscriptionPlans(int subId, SubscriptionPlan[] plans, String callingPackage)2481 private void setSubscriptionPlans(int subId, SubscriptionPlan[] plans, String callingPackage) 2482 throws InterruptedException { 2483 mService.setSubscriptionPlans(subId, plans, 0, callingPackage); 2484 // setSubscriptionPlans() triggers async events, wait for those to be completed before 2485 // moving forward as they could interfere with the tests later. 2486 postMsgAndWaitForCompletion(); 2487 } 2488 setRestrictBackground(boolean flag)2489 private void setRestrictBackground(boolean flag) throws Exception { 2490 mService.setRestrictBackground(flag); 2491 assertEquals("restrictBackground not set", flag, mService.getRestrictBackground()); 2492 } 2493 2494 /** 2495 * Creates a mock and registers it to {@link LocalServices}. 2496 */ addLocalServiceMock(Class<T> clazz)2497 private static <T> T addLocalServiceMock(Class<T> clazz) { 2498 final T mock = mock(clazz); 2499 LocalServices.addService(clazz, mock); 2500 return mock; 2501 } 2502 2503 /** 2504 * Creates a mock {@link TelephonyManager} and {@link SubscriptionManager}. 2505 * 2506 */ setupTelephonySubscriptionManagers(int subscriptionId, String subscriberId)2507 private TelephonyManager setupTelephonySubscriptionManagers(int subscriptionId, 2508 String subscriberId) { 2509 when(mSubscriptionManager.getActiveSubscriptionInfoList()).thenReturn( 2510 createSubscriptionInfoList(subscriptionId)); 2511 2512 TelephonyManager subTelephonyManager; 2513 subTelephonyManager = mock(TelephonyManager.class); 2514 when(subTelephonyManager.getSubscriptionId()).thenReturn(subscriptionId); 2515 when(subTelephonyManager.getSubscriberId()).thenReturn(subscriberId); 2516 when(mTelephonyManager.createForSubscriptionId(subscriptionId)) 2517 .thenReturn(subTelephonyManager); 2518 return subTelephonyManager; 2519 } 2520 2521 /** 2522 * Creates mock {@link SubscriptionInfo} from subscription id. 2523 */ createSubscriptionInfoList(int subId)2524 private List<SubscriptionInfo> createSubscriptionInfoList(int subId) { 2525 final List<SubscriptionInfo> sub = new ArrayList<>(); 2526 sub.add(createSubscriptionInfo(subId)); 2527 return sub; 2528 } 2529 2530 /** 2531 * Creates mock {@link SubscriptionInfo} from subscription id. 2532 */ createSubscriptionInfo(int subId)2533 private SubscriptionInfo createSubscriptionInfo(int subId) { 2534 return new SubscriptionInfo(subId, null, -1, null, null, -1, -1, 2535 null, -1, null, null, null, null, false, null, null); 2536 } 2537 2538 /** 2539 * Custom Mockito answer used to verify async {@link INetworkPolicyListener} calls. 2540 * 2541 * <p>Typical usage: 2542 * <pre><code> 2543 * mPolicyListener.expect().someCallback(any()); 2544 * // do something on objects under test 2545 * mPolicyListener.waitAndVerify().someCallback(eq(expectedValue)); 2546 * </code></pre> 2547 */ 2548 final class NetworkPolicyListenerAnswer implements Answer<Void> { 2549 private CountDownLatch latch; 2550 private final INetworkPolicyListener listener; 2551 NetworkPolicyListenerAnswer(NetworkPolicyManagerService service)2552 NetworkPolicyListenerAnswer(NetworkPolicyManagerService service) { 2553 this.listener = mock(INetworkPolicyListener.class); 2554 // RemoteCallbackList needs a binder to use as key 2555 when(listener.asBinder()).thenReturn(new Binder()); 2556 service.registerListener(listener); 2557 } 2558 2559 @Override answer(InvocationOnMock invocation)2560 public Void answer(InvocationOnMock invocation) throws Throwable { 2561 Log.d(TAG, "counting down on answer: " + invocation); 2562 latch.countDown(); 2563 return null; 2564 } 2565 expect()2566 INetworkPolicyListener expect() { 2567 assertNull("expect() called before waitAndVerify()", latch); 2568 latch = new CountDownLatch(1); 2569 return doAnswer(this).when(listener); 2570 } 2571 waitAndVerify()2572 INetworkPolicyListener waitAndVerify() { 2573 assertNotNull("waitAndVerify() called before expect()", latch); 2574 try { 2575 assertTrue("callback not called in 5 seconds", latch.await(5, TimeUnit.SECONDS)); 2576 } catch (InterruptedException e) { 2577 fail("Thread interrupted before callback called"); 2578 } finally { 2579 latch = null; 2580 } 2581 return verify(listener, atLeastOnce()); 2582 } 2583 verifyNotCalled()2584 INetworkPolicyListener verifyNotCalled() { 2585 return verify(listener, never()); 2586 } 2587 2588 } 2589 setNetpolicyXml(Context context)2590 private void setNetpolicyXml(Context context) throws Exception { 2591 mPolicyDir = context.getFilesDir(); 2592 if (mPolicyDir.exists()) { 2593 FsUtil.deleteContents(mPolicyDir); 2594 } 2595 if (!TextUtils.isEmpty(mNetpolicyXml)) { 2596 final String assetPath = NETPOLICY_DIR + "/" + mNetpolicyXml; 2597 final File netConfigFile = new File(mPolicyDir, "netpolicy.xml"); 2598 Log.d(TAG, "Creating " + netConfigFile + " from asset " + assetPath); 2599 try (InputStream in = context.getResources().getAssets().open(assetPath); 2600 OutputStream out = new FileOutputStream(netConfigFile)) { 2601 Streams.copy(in, out); 2602 } 2603 } 2604 } 2605 2606 /** 2607 * Annotation used to define the relative path of the {@code netpolicy.xml} file. 2608 */ 2609 @Retention(RetentionPolicy.RUNTIME) 2610 @Target(ElementType.METHOD) 2611 public @interface NetPolicyXml { value()2612 String value() default ""; 2613 } 2614 2615 /** 2616 * Rule used to set {@code mNetPolicyXml} according to the {@link NetPolicyXml} annotation. 2617 */ 2618 public static class NetPolicyMethodRule implements MethodRule { 2619 2620 @Override apply(Statement base, FrameworkMethod method, Object target)2621 public Statement apply(Statement base, FrameworkMethod method, Object target) { 2622 for (Annotation annotation : method.getAnnotations()) { 2623 if ((annotation instanceof NetPolicyXml)) { 2624 final String path = ((NetPolicyXml) annotation).value(); 2625 if (!path.isEmpty()) { 2626 ((NetworkPolicyManagerServiceTest) target).mNetpolicyXml = path; 2627 break; 2628 } 2629 } 2630 } 2631 return base; 2632 } 2633 } 2634 } 2635