| /* |
| * Copyright (C) 2018 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.app.role.cts; |
| |
| import static com.android.compatibility.common.util.SystemUtil.callWithShellPermissionIdentity; |
| import static com.android.compatibility.common.util.SystemUtil.runShellCommand; |
| import static com.android.compatibility.common.util.SystemUtil.runWithShellPermissionIdentity; |
| import static com.android.compatibility.common.util.UiAutomatorUtils.waitFindObject; |
| import static com.android.compatibility.common.util.UiAutomatorUtils.waitFindObjectOrNull; |
| |
| import static com.google.common.truth.Truth.assertThat; |
| |
| import static org.junit.Assert.assertThrows; |
| import static org.junit.Assert.fail; |
| import static org.junit.Assume.assumeTrue; |
| |
| import android.app.Activity; |
| import android.app.Instrumentation; |
| import android.app.role.OnRoleHoldersChangedListener; |
| import android.app.role.RoleManager; |
| import android.content.ComponentName; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.pm.PackageManager; |
| import android.content.pm.PermissionInfo; |
| import android.os.Build; |
| import android.os.Process; |
| import android.os.UserHandle; |
| import android.provider.Settings; |
| import android.provider.Telephony; |
| import android.support.test.uiautomator.By; |
| import android.support.test.uiautomator.BySelector; |
| import android.support.test.uiautomator.UiObject2; |
| import android.support.test.uiautomator.UiObjectNotFoundException; |
| import android.util.Pair; |
| |
| import androidx.annotation.NonNull; |
| import androidx.annotation.Nullable; |
| import androidx.test.InstrumentationRegistry; |
| import androidx.test.filters.SdkSuppress; |
| import androidx.test.rule.ActivityTestRule; |
| 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.TestUtils; |
| import com.android.compatibility.common.util.ThrowingRunnable; |
| import com.android.compatibility.common.util.UiAutomatorUtils; |
| |
| import org.junit.After; |
| import org.junit.Before; |
| import org.junit.Rule; |
| import org.junit.Test; |
| import org.junit.runner.RunWith; |
| |
| import java.io.IOException; |
| import java.util.Collections; |
| import java.util.List; |
| import java.util.Objects; |
| import java.util.concurrent.CompletableFuture; |
| import java.util.concurrent.TimeUnit; |
| import java.util.concurrent.TimeoutException; |
| import java.util.function.Consumer; |
| |
| /** |
| * Tests {@link RoleManager}. |
| */ |
| @RunWith(AndroidJUnit4.class) |
| public class RoleManagerTest { |
| |
| private static final long TIMEOUT_MILLIS = 15 * 1000; |
| |
| private static final long UNEXPECTED_TIMEOUT_MILLIS = 1000; |
| |
| private static final String ROLE_NAME = RoleManager.ROLE_BROWSER; |
| private static final String ROLE_SHORT_LABEL = "Browser app"; |
| |
| private static final String APP_APK_PATH = "/data/local/tmp/cts/role/CtsRoleTestApp.apk"; |
| private static final String APP_PACKAGE_NAME = "android.app.role.cts.app"; |
| private static final String APP_LABEL = "CtsRoleTestApp"; |
| private static final String APP_IS_ROLE_HELD_ACTIVITY_NAME = APP_PACKAGE_NAME |
| + ".IsRoleHeldActivity"; |
| private static final String APP_IS_ROLE_HELD_EXTRA_IS_ROLE_HELD = APP_PACKAGE_NAME |
| + ".extra.IS_ROLE_HELD"; |
| private static final String APP_REQUEST_ROLE_ACTIVITY_NAME = APP_PACKAGE_NAME |
| + ".RequestRoleActivity"; |
| private static final String APP_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME = APP_PACKAGE_NAME |
| + ".ChangeDefaultDialerActivity"; |
| private static final String APP_CHANGE_DEFAULT_SMS_ACTIVITY_NAME = APP_PACKAGE_NAME |
| + ".ChangeDefaultSmsActivity"; |
| |
| private static final String APP_28_APK_PATH = "/data/local/tmp/cts/role/CtsRoleTestApp28.apk"; |
| private static final String APP_28_PACKAGE_NAME = "android.app.role.cts.app28"; |
| private static final String APP_28_LABEL = "CtsRoleTestApp28"; |
| private static final String APP_28_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME = APP_28_PACKAGE_NAME |
| + ".ChangeDefaultDialerActivity"; |
| private static final String APP_28_CHANGE_DEFAULT_SMS_ACTIVITY_NAME = APP_28_PACKAGE_NAME |
| + ".ChangeDefaultSmsActivity"; |
| |
| private static final String APP_33_WITHOUT_INCALLSERVICE_APK_PATH = |
| "/data/local/tmp/cts/role/CtsRoleTestApp33WithoutInCallService.apk"; |
| private static final String APP_33_WITHOUT_INCALLSERVICE_PACKAGE_NAME = |
| "android.app.role.cts.app33WithoutInCallService"; |
| |
| private static final String PERMISSION_MANAGE_ROLES_FROM_CONTROLLER = |
| "com.android.permissioncontroller.permission.MANAGE_ROLES_FROM_CONTROLLER"; |
| |
| private static final Instrumentation sInstrumentation = |
| InstrumentationRegistry.getInstrumentation(); |
| private static final Context sContext = InstrumentationRegistry.getTargetContext(); |
| private static final PackageManager sPackageManager = sContext.getPackageManager(); |
| private static final RoleManager sRoleManager = sContext.getSystemService(RoleManager.class); |
| |
| @Rule |
| public DisableAnimationRule mDisableAnimationRule = new DisableAnimationRule(); |
| |
| @Rule |
| public FreezeRotationRule mFreezeRotationRule = new FreezeRotationRule(); |
| |
| @Rule |
| public ActivityTestRule<WaitForResultActivity> mActivityRule = |
| new ActivityTestRule<>(WaitForResultActivity.class); |
| |
| private String mRoleHolder; |
| |
| @Before |
| public void saveRoleHolder() throws Exception { |
| List<String> roleHolders = getRoleHolders(ROLE_NAME); |
| mRoleHolder = !roleHolders.isEmpty() ? roleHolders.get(0) : null; |
| |
| if (Objects.equals(mRoleHolder, APP_PACKAGE_NAME)) { |
| removeRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| mRoleHolder = null; |
| } |
| } |
| |
| @After |
| public void restoreRoleHolder() throws Exception { |
| removeRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| if (mRoleHolder != null) { |
| addRoleHolder(ROLE_NAME, mRoleHolder); |
| } |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Before |
| public void installApp() throws Exception { |
| installPackage(APP_APK_PATH); |
| installPackage(APP_28_APK_PATH); |
| installPackage(APP_33_WITHOUT_INCALLSERVICE_APK_PATH); |
| } |
| |
| @After |
| public void uninstallApp() throws Exception { |
| uninstallPackage(APP_PACKAGE_NAME); |
| uninstallPackage(APP_28_PACKAGE_NAME); |
| uninstallPackage(APP_33_WITHOUT_INCALLSERVICE_PACKAGE_NAME); |
| } |
| |
| @Before |
| public void wakeUpScreen() throws IOException { |
| runShellCommand(sInstrumentation, "input keyevent KEYCODE_WAKEUP"); |
| } |
| |
| @Before |
| public void closeNotificationShade() { |
| sContext.sendBroadcast(new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS)); |
| } |
| |
| @Test |
| public void requestRoleIntentHasPermissionControllerPackage() throws Exception { |
| Intent intent = sRoleManager.createRequestRoleIntent(ROLE_NAME); |
| |
| assertThat(intent.getPackage()).isEqualTo( |
| sPackageManager.getPermissionControllerPackageName()); |
| } |
| |
| @Test |
| public void requestRoleIntentHasExtraRoleName() throws Exception { |
| Intent intent = sRoleManager.createRequestRoleIntent(ROLE_NAME); |
| |
| assertThat(intent.getStringExtra(Intent.EXTRA_ROLE_NAME)).isEqualTo(ROLE_NAME); |
| } |
| |
| @Test |
| public void requestRoleAndDenyThenIsNotRoleHolder() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void requestRoleAndAllowThenIsRoleHolder() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(true); |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, true); |
| } |
| |
| @Test |
| public void requestRoleFirstTimeNoDontAskAgain() throws Exception { |
| requestRole(ROLE_NAME); |
| UiObject2 dontAskAgainCheck = findDontAskAgainCheck(false); |
| |
| assertThat(dontAskAgainCheck).isNull(); |
| |
| respondToRoleRequest(false); |
| } |
| |
| @Test |
| public void requestRoleAndDenyThenHasDontAskAgain() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| requestRole(ROLE_NAME); |
| UiObject2 dontAskAgainCheck = findDontAskAgainCheck(); |
| |
| assertThat(dontAskAgainCheck).isNotNull(); |
| |
| respondToRoleRequest(false); |
| } |
| |
| @Test |
| public void requestRoleAndDenyWithDontAskAgainReturnsCanceled() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| requestRole(ROLE_NAME); |
| findDontAskAgainCheck().click(); |
| Pair<Integer, Intent> result = clickButtonAndWaitForResult(true); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void requestRoleAndDenyWithDontAskAgainThenDeniedAutomatically() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| requestRole(ROLE_NAME); |
| findDontAskAgainCheck().click(); |
| clickButtonAndWaitForResult(true); |
| |
| requestRole(ROLE_NAME); |
| Pair<Integer, Intent> result = waitForResult(); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void requestRoleAndDenyWithDontAskAgainAndClearDataThenShowsUiWithoutDontAskAgain() |
| throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| requestRole(ROLE_NAME); |
| findDontAskAgainCheck().click(); |
| clickButtonAndWaitForResult(true); |
| // Wait for the RequestRoleActivity inside the test app to be removed from our task so that |
| // when the test app is force stopped, our task isn't force finished and our |
| // WaitForResultActivity can survive. |
| Thread.sleep(5000); |
| |
| clearPackageData(APP_PACKAGE_NAME); |
| // Wait for the don't ask again to be forgotten. |
| Thread.sleep(5000); |
| |
| TestUtils.waitUntil("Find and respond to request role UI", () -> { |
| requestRole(ROLE_NAME); |
| UiObject2 cancelButton = waitFindObjectOrNull(By.res("android:id/button2")); |
| if (cancelButton == null) { |
| // Dialog not found, try again later. |
| return false; |
| } |
| UiObject2 dontAskAgainCheck = findDontAskAgainCheck(false); |
| |
| assertThat(dontAskAgainCheck).isNull(); |
| |
| respondToRoleRequest(false); |
| return true; |
| }); |
| } |
| |
| @Test |
| public void requestRoleAndDenyWithDontAskAgainAndReinstallThenShowsUiWithoutDontAskAgain() |
| throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(false); |
| |
| requestRole(ROLE_NAME); |
| findDontAskAgainCheck().click(); |
| clickButtonAndWaitForResult(true); |
| // Wait for the RequestRoleActivity inside the test app to be removed from our task so that |
| // when the test app is uninstalled, our task isn't force finished and our |
| // WaitForResultActivity can survive. |
| Thread.sleep(5000); |
| |
| uninstallPackage(APP_PACKAGE_NAME); |
| // Wait for the don't ask again to be forgotten. |
| Thread.sleep(5000); |
| installPackage(APP_APK_PATH); |
| |
| TestUtils.waitUntil("Find and respond to request role UI", () -> { |
| requestRole(ROLE_NAME); |
| UiObject2 cancelButton = waitFindObjectOrNull(By.res("android:id/button2")); |
| if (cancelButton == null) { |
| // Dialog not found, try again later. |
| return false; |
| } |
| UiObject2 dontAskAgainCheck = findDontAskAgainCheck(false); |
| |
| assertThat(dontAskAgainCheck).isNull(); |
| |
| respondToRoleRequest(false); |
| return true; |
| }); |
| } |
| |
| @Test |
| public void requestInvalidRoleThenDeniedAutomatically() throws Exception { |
| requestRole("invalid"); |
| Pair<Integer, Intent> result = waitForResult(); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void requestUnqualifiedRoleThenDeniedAutomatically() throws Exception { |
| requestRole(RoleManager.ROLE_HOME); |
| Pair<Integer, Intent> result = waitForResult(); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void requestAssistantRoleThenDeniedAutomatically() throws Exception { |
| requestRole(RoleManager.ROLE_ASSISTANT); |
| Pair<Integer, Intent> result = waitForResult(); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void requestHoldingRoleThenAllowedAutomatically() throws Exception { |
| requestRole(ROLE_NAME); |
| respondToRoleRequest(true); |
| |
| requestRole(ROLE_NAME); |
| Pair<Integer, Intent> result = waitForResult(); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_OK); |
| } |
| |
| private void requestRole(@NonNull String roleName) { |
| Intent intent = new Intent() |
| .setComponent(new ComponentName(APP_PACKAGE_NAME, APP_REQUEST_ROLE_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_ROLE_NAME, roleName); |
| mActivityRule.getActivity().startActivityToWaitForResult(intent); |
| } |
| |
| private void respondToRoleRequest(boolean allow) |
| throws InterruptedException, UiObjectNotFoundException { |
| if (allow) { |
| waitFindObject(By.text(APP_LABEL)).click(); |
| } |
| Pair<Integer, Intent> result = clickButtonAndWaitForResult(allow); |
| int expectedResult = allow ? Activity.RESULT_OK : Activity.RESULT_CANCELED; |
| |
| assertThat(result.first).isEqualTo(expectedResult); |
| } |
| |
| @Nullable |
| private UiObject2 findDontAskAgainCheck(boolean expected) throws UiObjectNotFoundException { |
| BySelector selector = By.res("com.android.permissioncontroller:id/dont_ask_again"); |
| return expected |
| ? waitFindObject(selector) |
| : waitFindObjectOrNull(selector, UNEXPECTED_TIMEOUT_MILLIS); |
| } |
| |
| @Nullable |
| private UiObject2 findDontAskAgainCheck() throws UiObjectNotFoundException { |
| return findDontAskAgainCheck(true); |
| } |
| |
| @NonNull |
| private Pair<Integer, Intent> clickButtonAndWaitForResult(boolean positive) |
| throws InterruptedException, UiObjectNotFoundException { |
| waitFindObject(By.res(positive ? "android:id/button1" : "android:id/button2")).click(); |
| return waitForResult(); |
| } |
| |
| @NonNull |
| private Pair<Integer, Intent> waitForResult() throws InterruptedException { |
| return mActivityRule.getActivity().waitForActivityResult(TIMEOUT_MILLIS); |
| } |
| |
| private void clearPackageData(@NonNull String packageName) { |
| runShellCommand("pm clear --user " + Process.myUserHandle().getIdentifier() + " " |
| + packageName); |
| } |
| |
| private void installPackage(@NonNull String apkPath) { |
| runShellCommand("pm install -r --user " + Process.myUserHandle().getIdentifier() + " " |
| + apkPath); |
| } |
| |
| private void uninstallPackage(@NonNull String packageName) { |
| runShellCommand("pm uninstall --user " + Process.myUserHandle().getIdentifier() + " " |
| + packageName); |
| } |
| |
| @Test |
| public void targetCurrentSdkAndChangeDefaultDialerThenDeniedAutomatically() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER)); |
| |
| WaitForResultActivity activity = mActivityRule.getActivity(); |
| activity.startActivityToWaitForResult(new Intent() |
| .setComponent(new ComponentName(APP_PACKAGE_NAME, |
| APP_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME)); |
| Pair<Integer, Intent> result = activity.waitForActivityResult(TIMEOUT_MILLIS); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void targetCurrentSdkAndChangeDefaultSmsThenDeniedAutomatically() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| WaitForResultActivity activity = mActivityRule.getActivity(); |
| activity.startActivityToWaitForResult(new Intent() |
| .setComponent(new ComponentName(APP_PACKAGE_NAME, |
| APP_CHANGE_DEFAULT_SMS_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME)); |
| Pair<Integer, Intent> result = activity.waitForActivityResult(TIMEOUT_MILLIS); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void targetSdk28AndChangeDefaultDialerAndAllowThenIsDefaultDialer() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER)); |
| |
| sContext.startActivity(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_28_PACKAGE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); |
| waitFindObject(By.text(APP_28_LABEL)).click(); |
| waitFindObject(By.res("android:id/button1")).click(); |
| |
| // TODO(b/149037075): Use TelecomManager.getDefaultDialerPackage() once the bug is fixed. |
| //TelecomManager telecomManager = sContext.getSystemService(TelecomManager.class); |
| //TestUtils.waitUntil("App is not set as default dialer app", () -> Objects.equals( |
| // telecomManager.getDefaultDialerPackage(), APP_28_PACKAGE_NAME)); |
| TestUtils.waitUntil("App is not set as default dialer app", () -> |
| getRoleHolders(RoleManager.ROLE_DIALER).contains(APP_28_PACKAGE_NAME)); |
| } |
| |
| @Test |
| public void targetSdk28AndChangeDefaultSmsAndAllowThenIsDefaultSms() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| sContext.startActivity(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_SMS_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_28_PACKAGE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); |
| waitFindObject(By.text(APP_28_LABEL)).click(); |
| waitFindObject(By.res("android:id/button1")).click(); |
| |
| TestUtils.waitUntil("App is not set as default sms app", () -> Objects.equals( |
| Telephony.Sms.getDefaultSmsPackage(sContext), APP_28_PACKAGE_NAME)); |
| } |
| |
| @Test |
| public void targetSdk28AndChangeDefaultDialerForAnotherAppThenDeniedAutomatically() |
| throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER)); |
| |
| WaitForResultActivity activity = mActivityRule.getActivity(); |
| activity.startActivityToWaitForResult(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME)); |
| Pair<Integer, Intent> result = activity.waitForActivityResult(TIMEOUT_MILLIS); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void targetSdk28AndChangeDefaultSmsForAnotherAppThenDeniedAutomatically() |
| throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| WaitForResultActivity activity = mActivityRule.getActivity(); |
| activity.startActivityToWaitForResult(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_SMS_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME)); |
| Pair<Integer, Intent> result = activity.waitForActivityResult(TIMEOUT_MILLIS); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_CANCELED); |
| } |
| |
| @Test |
| public void |
| targetSdk28AndChangeDefaultDialerForAnotherAppAsHolderAndAllowThenTheOtherAppIsDefaultDialer() |
| throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER)); |
| |
| addRoleHolder(RoleManager.ROLE_DIALER, APP_28_PACKAGE_NAME); |
| sContext.startActivity(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_DIALER_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); |
| waitFindObject(By.text(APP_LABEL)).click(); |
| waitFindObject(By.res("android:id/button1")).click(); |
| |
| // TODO(b/149037075): Use TelecomManager.getDefaultDialerPackage() once the bug is fixed. |
| //TelecomManager telecomManager = sContext.getSystemService(TelecomManager.class); |
| //TestUtils.waitUntil("App is not set as default dialer app", () -> Objects.equals( |
| // telecomManager.getDefaultDialerPackage(), APP_PACKAGE_NAME)); |
| TestUtils.waitUntil("App is not set as default dialer app", () -> |
| getRoleHolders(RoleManager.ROLE_DIALER).contains(APP_PACKAGE_NAME)); |
| } |
| |
| @Test |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.TIRAMISU, codeName = "Tiramisu") |
| public void testHoldDialerRoleRequirementWithInCallServiceAndSdk() |
| throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER)); |
| // target below sdk 33 without InCallService component can hold dialer role |
| addRoleHolder( |
| RoleManager.ROLE_DIALER, APP_28_PACKAGE_NAME, true); |
| assertIsRoleHolder( |
| RoleManager.ROLE_DIALER, APP_28_PACKAGE_NAME, true); |
| // target sdk 33 without InCallService component cannot hold dialer role |
| addRoleHolder( |
| RoleManager.ROLE_DIALER, APP_33_WITHOUT_INCALLSERVICE_PACKAGE_NAME, false); |
| assertIsRoleHolder( |
| RoleManager.ROLE_DIALER, APP_33_WITHOUT_INCALLSERVICE_PACKAGE_NAME, false); |
| // target sdk 33 with InCallService component can hold dialer role |
| addRoleHolder( |
| RoleManager.ROLE_DIALER, APP_PACKAGE_NAME, true); |
| assertIsRoleHolder( |
| RoleManager.ROLE_DIALER, APP_PACKAGE_NAME, true); |
| } |
| |
| @Test |
| public void |
| targetSdk28AndChangeDefaultSmsForAnotherAppAsHolderAndAllowThenTheOtherAppIsDefaultSms() |
| throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| addRoleHolder(RoleManager.ROLE_SMS, APP_28_PACKAGE_NAME); |
| sContext.startActivity(new Intent() |
| .setComponent(new ComponentName(APP_28_PACKAGE_NAME, |
| APP_28_CHANGE_DEFAULT_SMS_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_PACKAGE_NAME, APP_PACKAGE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)); |
| waitFindObject(By.text(APP_LABEL)).click(); |
| waitFindObject(By.res("android:id/button1")).click(); |
| |
| TestUtils.waitUntil("App is not set as default sms app", () -> Objects.equals( |
| Telephony.Sms.getDefaultSmsPackage(sContext), APP_PACKAGE_NAME)); |
| } |
| |
| @Test |
| public void openDefaultAppDetailsThenIsNotDefaultApp() throws Exception { |
| runWithShellPermissionIdentity(() -> sContext.startActivity(new Intent( |
| Intent.ACTION_MANAGE_DEFAULT_APP) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .putExtra(Intent.EXTRA_ROLE_NAME, ROLE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
| | Intent.FLAG_ACTIVITY_CLEAR_TASK))); |
| |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))); |
| |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppDetailsAndSetDefaultAppThenIsDefaultApp() throws Exception { |
| runWithShellPermissionIdentity(() -> sContext.startActivity(new Intent( |
| Intent.ACTION_MANAGE_DEFAULT_APP) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .putExtra(Intent.EXTRA_ROLE_NAME, ROLE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
| | Intent.FLAG_ACTIVITY_CLEAR_TASK))); |
| waitForIdle(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))).click(); |
| |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(true)) |
| .hasDescendant(By.text(APP_LABEL))); |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, true); |
| |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppDetailsAndSetDefaultAppAndSetAnotherThenIsNotDefaultApp() |
| throws Exception { |
| runWithShellPermissionIdentity(() -> sContext.startActivity(new Intent( |
| Intent.ACTION_MANAGE_DEFAULT_APP) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .putExtra(Intent.EXTRA_ROLE_NAME, ROLE_NAME) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
| | Intent.FLAG_ACTIVITY_CLEAR_TASK))); |
| waitForIdle(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))).click(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(true)) |
| .hasDescendant(By.text(APP_LABEL))); |
| waitForIdle(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false))).click(); |
| |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))); |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppListThenHasDefaultApp() throws Exception { |
| sContext.startActivity(new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK)); |
| |
| waitFindObject(By.text(ROLE_SHORT_LABEL)); |
| |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppListThenIsNotDefaultAppInList() throws Exception { |
| sContext.startActivity(new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK)); |
| |
| assertThat(waitFindObjectOrNull(By.text(APP_LABEL), UNEXPECTED_TIMEOUT_MILLIS)) |
| .isNull(); |
| |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppListAndSetDefaultAppThenIsDefaultApp() throws Exception { |
| sContext.startActivity(new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK)); |
| waitForIdle(); |
| waitFindObject(By.text(ROLE_SHORT_LABEL)).click(); |
| waitForIdle(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))).click(); |
| |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(true)) |
| .hasDescendant(By.text(APP_LABEL))); |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, true); |
| |
| pressBack(); |
| pressBack(); |
| } |
| |
| @Test |
| public void openDefaultAppListAndSetDefaultAppThenIsDefaultAppInList() throws Exception { |
| sContext.startActivity(new Intent(Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS) |
| .addCategory(Intent.CATEGORY_DEFAULT) |
| .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TASK)); |
| waitForIdle(); |
| waitFindObject(By.text(ROLE_SHORT_LABEL)).click(); |
| waitForIdle(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(false)) |
| .hasDescendant(By.text(APP_LABEL))).click(); |
| waitFindObject(By.clickable(true).hasDescendant(By.checkable(true).checked(true)) |
| .hasDescendant(By.text(APP_LABEL))); |
| pressBack(); |
| |
| waitFindObject(By.text(APP_LABEL)); |
| |
| pressBack(); |
| } |
| |
| private static void waitForIdle() { |
| UiAutomatorUtils.getUiDevice().waitForIdle(); |
| } |
| |
| private static void pressBack() { |
| UiAutomatorUtils.getUiDevice().pressBack(); |
| waitForIdle(); |
| } |
| |
| @Test |
| public void roleIsAvailable() { |
| assertThat(sRoleManager.isRoleAvailable(ROLE_NAME)).isTrue(); |
| } |
| |
| @Test |
| public void dontAddRoleHolderThenRoleIsNotHeld() throws Exception { |
| assertRoleIsHeld(ROLE_NAME, false); |
| } |
| |
| @Test |
| public void addRoleHolderThenRoleIsHeld() throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertRoleIsHeld(ROLE_NAME, true); |
| } |
| |
| @Test |
| public void addAndRemoveRoleHolderThenRoleIsNotHeld() throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| removeRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertRoleIsHeld(ROLE_NAME, false); |
| } |
| |
| private void assertRoleIsHeld(@NonNull String roleName, boolean isHeld) |
| throws InterruptedException { |
| Intent intent = new Intent() |
| .setComponent(new ComponentName(APP_PACKAGE_NAME, APP_IS_ROLE_HELD_ACTIVITY_NAME)) |
| .putExtra(Intent.EXTRA_ROLE_NAME, roleName); |
| WaitForResultActivity activity = mActivityRule.getActivity(); |
| activity.startActivityToWaitForResult(intent); |
| Pair<Integer, Intent> result = activity.waitForActivityResult(TIMEOUT_MILLIS); |
| |
| assertThat(result.first).isEqualTo(Activity.RESULT_OK); |
| assertThat(result.second).isNotNull(); |
| assertThat(result.second.hasExtra(APP_IS_ROLE_HELD_EXTRA_IS_ROLE_HELD)).isTrue(); |
| assertThat(result.second.getBooleanExtra(APP_IS_ROLE_HELD_EXTRA_IS_ROLE_HELD, false)) |
| .isEqualTo(isHeld); |
| } |
| |
| @Test |
| public void dontAddRoleHolderThenIsNotRoleHolder() throws Exception { |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void addRoleHolderThenIsRoleHolder() throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, true); |
| } |
| |
| @Test |
| public void addAndRemoveRoleHolderThenIsNotRoleHolder() throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| removeRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void addAndClearRoleHoldersThenIsNotRoleHolder() throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| clearRoleHolders(ROLE_NAME); |
| |
| assertIsRoleHolder(ROLE_NAME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void addInvalidRoleHolderThenFails() throws Exception { |
| addRoleHolder("invalid", APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void addUnqualifiedRoleHolderThenFails() throws Exception { |
| addRoleHolder(RoleManager.ROLE_HOME, APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void removeInvalidRoleHolderThenFails() throws Exception { |
| removeRoleHolder("invalid", APP_PACKAGE_NAME, false); |
| } |
| |
| @Test |
| public void clearInvalidRoleHoldersThenFails() throws Exception { |
| clearRoleHolders("invalid", false); |
| } |
| |
| @Test |
| public void addOnRoleHoldersChangedListenerAndAddRoleHolderThenIsNotified() throws Exception { |
| assertOnRoleHoldersChangedListenerIsNotified(() -> addRoleHolder(ROLE_NAME, |
| APP_PACKAGE_NAME)); |
| } |
| |
| @Test |
| public void addOnRoleHoldersChangedListenerAndRemoveRoleHolderThenIsNotified() |
| throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertOnRoleHoldersChangedListenerIsNotified(() -> removeRoleHolder(ROLE_NAME, |
| APP_PACKAGE_NAME)); |
| } |
| |
| @Test |
| public void addOnRoleHoldersChangedListenerAndClearRoleHoldersThenIsNotified() |
| throws Exception { |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| assertOnRoleHoldersChangedListenerIsNotified(() -> clearRoleHolders(ROLE_NAME)); |
| } |
| |
| private void assertOnRoleHoldersChangedListenerIsNotified(@NonNull ThrowingRunnable runnable) |
| throws Exception { |
| ListenerFuture future = new ListenerFuture(); |
| UserHandle user = Process.myUserHandle(); |
| runWithShellPermissionIdentity(() -> sRoleManager.addOnRoleHoldersChangedListenerAsUser( |
| sContext.getMainExecutor(), future, user)); |
| Pair<String, UserHandle> result; |
| try { |
| runnable.run(); |
| result = future.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS); |
| } finally { |
| runWithShellPermissionIdentity(() -> |
| sRoleManager.removeOnRoleHoldersChangedListenerAsUser(future, user)); |
| } |
| |
| assertThat(result.first).isEqualTo(ROLE_NAME); |
| assertThat(result.second).isEqualTo(user); |
| } |
| |
| @Test |
| public void addAndRemoveOnRoleHoldersChangedListenerAndAddRoleHolderThenIsNotNotified() |
| throws Exception { |
| ListenerFuture future = new ListenerFuture(); |
| UserHandle user = Process.myUserHandle(); |
| runWithShellPermissionIdentity(() -> { |
| sRoleManager.addOnRoleHoldersChangedListenerAsUser(sContext.getMainExecutor(), future, |
| user); |
| sRoleManager.removeOnRoleHoldersChangedListenerAsUser(future, user); |
| }); |
| addRoleHolder(ROLE_NAME, APP_PACKAGE_NAME); |
| |
| try { |
| future.get(UNEXPECTED_TIMEOUT_MILLIS, TimeUnit.MILLISECONDS); |
| } catch (TimeoutException e) { |
| // Expected |
| return; |
| } |
| throw new AssertionError("OnRoleHoldersChangedListener was notified after removal"); |
| } |
| |
| @Test |
| public void setRoleNamesFromControllerShouldRequireManageRolesFromControllerPermission() { |
| assertRequiresManageRolesFromControllerPermission( |
| () -> sRoleManager.setRoleNamesFromController(Collections.emptyList()), |
| "setRoleNamesFromController"); |
| } |
| |
| @Test |
| public void addRoleHolderFromControllerShouldRequireManageRolesFromControllerPermission() { |
| assertRequiresManageRolesFromControllerPermission( |
| () -> sRoleManager.addRoleHolderFromController(ROLE_NAME, APP_PACKAGE_NAME), |
| "addRoleHolderFromController"); |
| } |
| |
| @Test |
| public void removeRoleHolderFromControllerShouldRequireManageRolesFromControllerPermission() { |
| assertRequiresManageRolesFromControllerPermission( |
| () -> sRoleManager.removeRoleHolderFromController(ROLE_NAME, APP_PACKAGE_NAME), |
| "removeRoleHolderFromController"); |
| } |
| |
| @Test |
| public void getHeldRolesFromControllerShouldRequireManageRolesFromControllerPermission() { |
| assertRequiresManageRolesFromControllerPermission( |
| () -> sRoleManager.getHeldRolesFromController(APP_PACKAGE_NAME), |
| "getHeldRolesFromController"); |
| } |
| |
| private void assertRequiresManageRolesFromControllerPermission(@NonNull Runnable runnable, |
| @NonNull String methodName) { |
| try { |
| runnable.run(); |
| } catch (SecurityException e) { |
| if (e.getMessage().contains(PERMISSION_MANAGE_ROLES_FROM_CONTROLLER)) { |
| // Expected |
| return; |
| } |
| throw e; |
| } |
| fail("RoleManager." + methodName + "() should require " |
| + PERMISSION_MANAGE_ROLES_FROM_CONTROLLER); |
| } |
| |
| @Test |
| public void manageRolesFromControllerPermissionShouldBeDeclaredByPermissionController() |
| throws PackageManager.NameNotFoundException { |
| PermissionInfo permissionInfo = sPackageManager.getPermissionInfo( |
| PERMISSION_MANAGE_ROLES_FROM_CONTROLLER, 0); |
| |
| assertThat(permissionInfo.packageName).isEqualTo( |
| sPackageManager.getPermissionControllerPackageName()); |
| assertThat(permissionInfo.getProtection()).isEqualTo(PermissionInfo.PROTECTION_SIGNATURE); |
| assertThat(permissionInfo.getProtectionFlags()).isEqualTo(0); |
| } |
| |
| @Test |
| public void smsRoleHasHolder() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| assertThat(getRoleHolders(RoleManager.ROLE_SMS)).isNotEmpty(); |
| } |
| |
| @Test |
| public void addSmsRoleHolderThenPermissionIsGranted() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| addRoleHolder(RoleManager.ROLE_SMS, APP_PACKAGE_NAME); |
| |
| assertThat(sPackageManager.checkPermission(android.Manifest.permission.SEND_SMS, |
| APP_PACKAGE_NAME)).isEqualTo(PackageManager.PERMISSION_GRANTED); |
| } |
| |
| @Test |
| public void removeSmsRoleHolderThenPermissionIsRevoked() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| String smsRoleHolder = getRoleHolders(RoleManager.ROLE_SMS).get(0); |
| addRoleHolder(RoleManager.ROLE_SMS, APP_PACKAGE_NAME); |
| addRoleHolder(RoleManager.ROLE_SMS, smsRoleHolder); |
| |
| assertThat(sPackageManager.checkPermission(android.Manifest.permission.SEND_SMS, |
| APP_PACKAGE_NAME)).isEqualTo(PackageManager.PERMISSION_DENIED); |
| } |
| |
| @Test |
| public void removeSmsRoleHolderThenDialerRolePermissionIsRetained() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_DIALER) |
| && sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| addRoleHolder(RoleManager.ROLE_DIALER, APP_PACKAGE_NAME); |
| String smsRoleHolder = getRoleHolders(RoleManager.ROLE_SMS).get(0); |
| addRoleHolder(RoleManager.ROLE_SMS, APP_PACKAGE_NAME); |
| addRoleHolder(RoleManager.ROLE_SMS, smsRoleHolder); |
| |
| assertThat(sPackageManager.checkPermission(android.Manifest.permission.SEND_SMS, |
| APP_PACKAGE_NAME)).isEqualTo(PackageManager.PERMISSION_GRANTED); |
| } |
| |
| @Test |
| public void packageManagerGetDefaultBrowserBackedByRole() throws Exception { |
| addRoleHolder(RoleManager.ROLE_BROWSER, APP_PACKAGE_NAME); |
| |
| assertThat(sPackageManager.getDefaultBrowserPackageNameAsUser(UserHandle.myUserId())) |
| .isEqualTo(APP_PACKAGE_NAME); |
| } |
| |
| @Test |
| public void packageManagerSetDefaultBrowserBackedByRole() throws Exception { |
| callWithShellPermissionIdentity(() -> sPackageManager.setDefaultBrowserPackageNameAsUser( |
| APP_PACKAGE_NAME, UserHandle.myUserId())); |
| |
| assertIsRoleHolder(RoleManager.ROLE_BROWSER, APP_PACKAGE_NAME, true); |
| } |
| |
| @Test |
| public void telephonySmsGetDefaultSmsPackageBackedByRole() throws Exception { |
| assumeTrue(sRoleManager.isRoleAvailable(RoleManager.ROLE_SMS)); |
| |
| addRoleHolder(RoleManager.ROLE_SMS, APP_PACKAGE_NAME); |
| |
| assertThat(Telephony.Sms.getDefaultSmsPackage(sContext)).isEqualTo(APP_PACKAGE_NAME); |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.S, codeName = "S") |
| @Test |
| public void cannotBypassRoleQualificationWithoutPermission() throws Exception { |
| assertThrows(SecurityException.class, () -> |
| sRoleManager.setBypassingRoleQualification(true)); |
| } |
| |
| @SdkSuppress(minSdkVersion = Build.VERSION_CODES.S, codeName = "S") |
| @Test |
| public void bypassRoleQualificationThenCanAddUnqualifiedRoleHolder() throws Exception { |
| assertThat(sRoleManager.isRoleAvailable(RoleManager.ROLE_SYSTEM_ACTIVITY_RECOGNIZER)) |
| .isTrue(); |
| |
| runWithShellPermissionIdentity(() -> sRoleManager.setBypassingRoleQualification(true)); |
| try { |
| assertThat(callWithShellPermissionIdentity(() -> |
| sRoleManager.isBypassingRoleQualification())).isTrue(); |
| |
| // The System Activity Recognizer role requires a system app, so this won't succeed |
| // without bypassing role qualification. |
| addRoleHolder(RoleManager.ROLE_SYSTEM_ACTIVITY_RECOGNIZER, APP_PACKAGE_NAME); |
| |
| assertThat(getRoleHolders(RoleManager.ROLE_SYSTEM_ACTIVITY_RECOGNIZER)) |
| .contains(APP_PACKAGE_NAME); |
| } finally { |
| runWithShellPermissionIdentity(() -> sRoleManager.setBypassingRoleQualification(false)); |
| } |
| assertThat(callWithShellPermissionIdentity(() -> |
| sRoleManager.isBypassingRoleQualification())).isFalse(); |
| } |
| |
| @NonNull |
| private List<String> getRoleHolders(@NonNull String roleName) throws Exception { |
| return callWithShellPermissionIdentity(() -> sRoleManager.getRoleHolders(roleName)); |
| } |
| |
| private void assertIsRoleHolder(@NonNull String roleName, @NonNull String packageName, |
| boolean shouldBeRoleHolder) throws Exception { |
| List<String> packageNames = getRoleHolders(roleName); |
| |
| if (shouldBeRoleHolder) { |
| assertThat(packageNames).contains(packageName); |
| } else { |
| assertThat(packageNames).doesNotContain(packageName); |
| } |
| } |
| |
| private void addRoleHolder(@NonNull String roleName, @NonNull String packageName, |
| boolean expectSuccess) throws Exception { |
| CallbackFuture future = new CallbackFuture(); |
| runWithShellPermissionIdentity(() -> sRoleManager.addRoleHolderAsUser(roleName, |
| packageName, 0, Process.myUserHandle(), sContext.getMainExecutor(), future)); |
| assertThat(future.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)).isEqualTo(expectSuccess); |
| } |
| |
| private void addRoleHolder(@NonNull String roleName, @NonNull String packageName) |
| throws Exception { |
| addRoleHolder(roleName, packageName, true); |
| } |
| |
| private void removeRoleHolder(@NonNull String roleName, @NonNull String packageName, |
| boolean expectSuccess) throws Exception { |
| CallbackFuture future = new CallbackFuture(); |
| runWithShellPermissionIdentity(() -> sRoleManager.removeRoleHolderAsUser(roleName, |
| packageName, 0, Process.myUserHandle(), sContext.getMainExecutor(), future)); |
| assertThat(future.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)).isEqualTo(expectSuccess); |
| } |
| |
| private void removeRoleHolder(@NonNull String roleName, @NonNull String packageName) |
| throws Exception { |
| removeRoleHolder(roleName, packageName, true); |
| } |
| |
| private void clearRoleHolders(@NonNull String roleName, boolean expectSuccess) |
| throws Exception { |
| CallbackFuture future = new CallbackFuture(); |
| runWithShellPermissionIdentity(() -> sRoleManager.clearRoleHoldersAsUser(roleName, 0, |
| Process.myUserHandle(), sContext.getMainExecutor(), future)); |
| assertThat(future.get(TIMEOUT_MILLIS, TimeUnit.MILLISECONDS)).isEqualTo(expectSuccess); |
| } |
| |
| private void clearRoleHolders(@NonNull String roleName) throws Exception { |
| clearRoleHolders(roleName, true); |
| } |
| |
| private static class ListenerFuture extends CompletableFuture<Pair<String, UserHandle>> |
| implements OnRoleHoldersChangedListener { |
| |
| @Override |
| public void onRoleHoldersChanged(@NonNull String roleName, @NonNull UserHandle user) { |
| complete(new Pair<>(roleName, user)); |
| } |
| } |
| |
| private static class CallbackFuture extends CompletableFuture<Boolean> |
| implements Consumer<Boolean> { |
| |
| @Override |
| public void accept(Boolean successful) { |
| complete(successful); |
| } |
| } |
| } |
