| /* |
| * Copyright (C) 2021 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package android.os.cts |
| |
| import android.app.ActivityManager |
| import android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_GONE |
| import android.app.ActivityManager.RunningAppProcessInfo.IMPORTANCE_TOP_SLEEPING |
| import android.app.Instrumentation |
| import android.apphibernation.AppHibernationManager |
| import android.content.Context |
| import android.content.Intent |
| import android.content.pm.ApplicationInfo |
| import android.content.pm.PackageManager |
| import android.net.Uri |
| import android.os.Build |
| import android.permission.PermissionControllerManager |
| import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_ELIGIBLE |
| import android.permission.PermissionControllerManager.HIBERNATION_ELIGIBILITY_UNKNOWN |
| import android.platform.test.annotations.AppModeFull |
| import android.provider.DeviceConfig |
| import android.provider.DeviceConfig.NAMESPACE_APP_HIBERNATION |
| import android.provider.Settings |
| import android.support.test.uiautomator.By |
| import android.support.test.uiautomator.BySelector |
| import android.support.test.uiautomator.UiDevice |
| import android.support.test.uiautomator.UiObject2 |
| import android.support.test.uiautomator.UiScrollable |
| import android.support.test.uiautomator.UiSelector |
| import androidx.test.InstrumentationRegistry |
| import androidx.test.filters.SdkSuppress |
| import androidx.test.runner.AndroidJUnit4 |
| import com.android.compatibility.common.util.DisableAnimationRule |
| import com.android.compatibility.common.util.FreezeRotationRule |
| import com.android.compatibility.common.util.SystemUtil |
| import com.android.compatibility.common.util.SystemUtil.eventually |
| import com.android.compatibility.common.util.SystemUtil.runShellCommandOrThrow |
| import com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity |
| import com.android.compatibility.common.util.SystemUtil.callWithShellPermissionIdentity |
| import com.android.compatibility.common.util.UiAutomatorUtils |
| import org.hamcrest.CoreMatchers |
| import org.hamcrest.Matchers |
| import org.junit.After |
| import org.junit.Assert.assertEquals |
| import org.junit.Assert.assertFalse |
| import org.junit.Assert.assertNotNull |
| import org.junit.Assert.assertThat |
| import org.junit.Assert.assertTrue |
| import org.junit.Assume.assumeFalse |
| import org.junit.Before |
| import org.junit.Rule |
| import org.junit.Test |
| import org.junit.runner.RunWith |
| import java.util.concurrent.CountDownLatch |
| import java.util.concurrent.TimeUnit |
| |
| /** |
| * Integration test for app hibernation. |
| */ |
| @RunWith(AndroidJUnit4::class) |
| @AppModeFull(reason = "Instant apps cannot access app hibernation") |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.S, codeName = "S") |
| class AppHibernationIntegrationTest { |
| companion object { |
| const val LOG_TAG = "AppHibernationIntegrationTest" |
| const val WAIT_TIME_MS = 1000L |
| const val TIMEOUT_TIME_MS = 5000L |
| const val MAX_SCROLL_ATTEMPTS = 3 |
| const val TEST_UNUSED_THRESHOLD = 1L |
| const val HIBERNATION_ENABLED_KEY = "app_hibernation_enabled" |
| |
| const val CMD_KILL = "am kill %s" |
| } |
| private val context: Context = InstrumentationRegistry.getTargetContext() |
| private val instrumentation: Instrumentation = InstrumentationRegistry.getInstrumentation() |
| |
| private lateinit var packageManager: PackageManager |
| private lateinit var permissionControllerManager: PermissionControllerManager |
| private var oldHibernationValue: String? = null |
| |
| @get:Rule |
| val disableAnimationRule = DisableAnimationRule() |
| |
| @get:Rule |
| val freezeRotationRule = FreezeRotationRule() |
| |
| @Before |
| fun setup() { |
| oldHibernationValue = callWithShellPermissionIdentity { |
| DeviceConfig.getProperty(NAMESPACE_APP_HIBERNATION, HIBERNATION_ENABLED_KEY) |
| } |
| runWithShellPermissionIdentity { |
| DeviceConfig.setProperty(NAMESPACE_APP_HIBERNATION, HIBERNATION_ENABLED_KEY, "true", |
| false /* makeDefault */) |
| } |
| packageManager = context.packageManager |
| permissionControllerManager = |
| context.getSystemService(PermissionControllerManager::class.java)!! |
| |
| // Collapse notifications |
| assertThat( |
| runShellCommandOrThrow("cmd statusbar collapse"), |
| CoreMatchers.equalTo("")) |
| |
| // Wake up the device |
| runShellCommandOrThrow("input keyevent KEYCODE_WAKEUP") |
| runShellCommandOrThrow("input keyevent 82") |
| } |
| |
| @After |
| fun cleanUp() { |
| goHome() |
| runWithShellPermissionIdentity { |
| DeviceConfig.setProperty(NAMESPACE_APP_HIBERNATION, HIBERNATION_ENABLED_KEY, |
| oldHibernationValue, false /* makeDefault */) |
| } |
| } |
| |
| @Test |
| fun testUnusedApp_getsForceStopped() { |
| withUnusedThresholdMs(TEST_UNUSED_THRESHOLD) { |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| // Use app |
| startApp(APK_PACKAGE_NAME_S_APP) |
| leaveApp(APK_PACKAGE_NAME_S_APP) |
| killApp(APK_PACKAGE_NAME_S_APP) |
| |
| // Wait for the unused threshold time to pass |
| Thread.sleep(TEST_UNUSED_THRESHOLD) |
| |
| // Run job |
| runAppHibernationJob(context, LOG_TAG) |
| |
| // Verify |
| val ai = |
| packageManager.getApplicationInfo(APK_PACKAGE_NAME_S_APP, 0 /* flags */) |
| val stopped = ((ai.flags and ApplicationInfo.FLAG_STOPPED) != 0) |
| assertTrue(stopped) |
| |
| if (hasFeatureTV()) { |
| // Skip checking unused apps screen because it may be unavailable on TV |
| return |
| } |
| openUnusedAppsNotification() |
| waitFindObject(By.text(APK_PACKAGE_NAME_S_APP)) |
| } |
| } |
| } |
| |
| @Test |
| fun testPreSVersionUnusedApp_doesntGetForceStopped() { |
| assumeFalse( |
| "TV may have different behaviour for Pre-S version apps", |
| hasFeatureTV()) |
| withUnusedThresholdMs(TEST_UNUSED_THRESHOLD) { |
| withApp(APK_PATH_R_APP, APK_PACKAGE_NAME_R_APP) { |
| // Use app |
| startApp(APK_PACKAGE_NAME_R_APP) |
| leaveApp(APK_PACKAGE_NAME_R_APP) |
| killApp(APK_PACKAGE_NAME_R_APP) |
| |
| // Wait for the unused threshold time to pass |
| Thread.sleep(TEST_UNUSED_THRESHOLD) |
| |
| // Run job |
| runAppHibernationJob(context, LOG_TAG) |
| |
| // Verify |
| val ai = |
| packageManager.getApplicationInfo(APK_PACKAGE_NAME_R_APP, 0 /* flags */) |
| val stopped = ((ai.flags and ApplicationInfo.FLAG_STOPPED) != 0) |
| assertFalse(stopped) |
| } |
| } |
| } |
| |
| @Test |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.TIRAMISU, codeName = "Tiramisu") |
| fun testUnusedAppCount() { |
| withUnusedThresholdMs(TEST_UNUSED_THRESHOLD) { |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| // Use app |
| startApp(APK_PACKAGE_NAME_S_APP) |
| leaveApp(APK_PACKAGE_NAME_S_APP) |
| killApp(APK_PACKAGE_NAME_S_APP) |
| |
| // Wait for the unused threshold time to pass |
| Thread.sleep(TEST_UNUSED_THRESHOLD) |
| |
| // Run job |
| runAppHibernationJob(context, LOG_TAG) |
| |
| // Verify unused app count pulled correctly |
| val countDownLatch = CountDownLatch(1) |
| var unusedAppCount = -1 |
| runWithShellPermissionIdentity { |
| permissionControllerManager.getUnusedAppCount({ r -> r.run() }, |
| { res -> |
| unusedAppCount = res |
| countDownLatch.countDown() |
| }) |
| |
| assertTrue("Timed out waiting for unused app count", |
| countDownLatch.await(TIMEOUT_TIME_MS, TimeUnit.MILLISECONDS)) |
| assertTrue("Expected non-zero unused app count but is $unusedAppCount", |
| unusedAppCount > 0) |
| } |
| } |
| } |
| } |
| |
| @Test |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.TIRAMISU, codeName = "Tiramisu") |
| fun testGetHibernationEligibility_eligibleByDefault() { |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| // Verify app is eligible for hibernation |
| val countDownLatch = CountDownLatch(1) |
| var hibernationEligibility = HIBERNATION_ELIGIBILITY_UNKNOWN |
| runWithShellPermissionIdentity { |
| permissionControllerManager.getHibernationEligibility(APK_PACKAGE_NAME_S_APP, |
| { r -> r.run() }, |
| { res -> |
| hibernationEligibility = res |
| countDownLatch.countDown() |
| }) |
| |
| assertTrue("Timed out waiting for hibernation eligibility", |
| countDownLatch.await(TIMEOUT_TIME_MS, TimeUnit.MILLISECONDS)) |
| assertEquals("Expected test app to be eligible for hibernation but wasn't.", |
| HIBERNATION_ELIGIBILITY_ELIGIBLE, hibernationEligibility) |
| } |
| } |
| } |
| |
| @Test |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.TIRAMISU, codeName = "Tiramisu") |
| fun testGetHibernationStatsForUser_getsStatsForIndividualPackages() { |
| val appHibernationManager = context.getSystemService(AppHibernationManager::class.java)!! |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| runWithShellPermissionIdentity { |
| val stats = |
| appHibernationManager.getHibernationStatsForUser( |
| setOf(APK_PACKAGE_NAME_S_APP)) |
| |
| assertNotNull(stats[APK_PACKAGE_NAME_S_APP]) |
| assertTrue(stats[APK_PACKAGE_NAME_S_APP]!!.diskBytesSaved >= 0) |
| } |
| } |
| } |
| |
| @Test |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.TIRAMISU, codeName = "Tiramisu") |
| fun testGetHibernationStatsForUser_getsStatsForAllPackages() { |
| val appHibernationManager = context.getSystemService(AppHibernationManager::class.java)!! |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| runWithShellPermissionIdentity { |
| val stats = appHibernationManager.getHibernationStatsForUser() |
| |
| assertFalse("Expected non-empty list of hibernation stats", stats.isEmpty()) |
| assertTrue("Expected test package to be in list of returned savings but wasn't", |
| stats.containsKey(APK_PACKAGE_NAME_S_APP)) |
| } |
| } |
| } |
| |
| @Test |
| fun testAppInfo_RemovePermissionsAndFreeUpSpaceToggleExists() { |
| assumeFalse( |
| "Remove permissions and free up space toggle may be unavailable on TV", |
| hasFeatureTV()) |
| withApp(APK_PATH_S_APP, APK_PACKAGE_NAME_S_APP) { |
| // Open app info |
| val intent = Intent(Settings.ACTION_APPLICATION_DETAILS_SETTINGS) |
| val uri = Uri.fromParts("package", APK_PACKAGE_NAME_S_APP, null /* fragment */) |
| intent.data = uri |
| intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK) |
| context.startActivity(intent) |
| |
| waitForIdle() |
| UiAutomatorUtils.getUiDevice() |
| |
| val packageManager = context.packageManager |
| val settingsPackage = intent.resolveActivity(packageManager).packageName |
| val res = packageManager.getResourcesForApplication(settingsPackage) |
| val title = res.getString( |
| res.getIdentifier("unused_apps_switch", "string", settingsPackage)) |
| |
| // Settings can have multiple scrollable containers so all of them should be |
| // searched. |
| var toggleFound = UiDevice.getInstance(instrumentation) |
| .findObject(UiSelector().text(title)) |
| .waitForExists(WAIT_TIME_MS) |
| var i = 0 |
| var scrollableObject = UiScrollable(UiSelector().scrollable(true).instance(i)) |
| while (!toggleFound && scrollableObject.waitForExists(WAIT_TIME_MS)) { |
| toggleFound = scrollableObject.scrollTextIntoView(title) |
| scrollableObject = UiScrollable(UiSelector().scrollable(true).instance(++i)) |
| } |
| |
| assertTrue("Remove permissions and free up space toggle not found", toggleFound) |
| } |
| } |
| |
| private fun leaveApp(packageName: String) { |
| eventually { |
| goHome() |
| SystemUtil.runWithShellPermissionIdentity { |
| val packageImportance = context |
| .getSystemService(ActivityManager::class.java)!! |
| .getPackageImportance(packageName) |
| assertThat(packageImportance, Matchers.greaterThan(IMPORTANCE_TOP_SLEEPING)) |
| } |
| } |
| } |
| |
| private fun killApp(packageName: String) { |
| eventually { |
| SystemUtil.runWithShellPermissionIdentity { |
| runShellCommandOrThrow(String.format(CMD_KILL, packageName)) |
| val packageImportance = context |
| .getSystemService(ActivityManager::class.java)!! |
| .getPackageImportance(packageName) |
| assertThat(packageImportance, Matchers.equalTo(IMPORTANCE_GONE)) |
| } |
| } |
| } |
| |
| private fun waitFindObject(selector: BySelector): UiObject2 { |
| return waitFindObject(instrumentation.uiAutomation, selector) |
| } |
| } |
