PawletOS/app_Settings
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Snap for 9556973 from a50ca10f33 to tm-qpr3-release

Browse Source 
Change-Id: Ib79d7b101f55f2c0a09d70d7c98bcbe1a29e0f14
This commit is contained in:
Android Build Coastguard Worker
2023-02-03 00:26:07 +00:00
parent 9419f1918a a50ca10f33
commit 3c6b05ad9d
6 changed files with 384 additions and 37 deletions
Download Patch File Download Diff File Expand all files Collapse all files

1
res/raw-sw600dp/lottie_button_nav_menu.json Normal file
View File

File diff suppressed because one or more lines are too long

1
res/xml/button_navigation_settings.xml
View File

@@ -26,6 +26,7 @@
<com.android.settingslib.widget.IllustrationPreference
android:key="gesture_power_menu_video"
settings:searchable="false"
settings:dynamicColor="true"
settings:lottie_imageAssetsFolder="button_nav_menu"
settings:lottie_rawRes="@raw/lottie_button_nav_menu"/>

80
src/com/android/settings/biometrics/MultiBiometricEnrollHelper.java
View File

@@ -24,8 +24,11 @@ import android.hardware.fingerprint.FingerprintManager;
import androidx.annotation.NonNull;
import androidx.fragment.app.FragmentActivity;
import com.android.internal.annotations.VisibleForTesting;
import com.android.settings.password.ChooseLockSettingsHelper;
import java.util.function.Function;
/**
* Helper for {@link BiometricEnrollActivity} when multiple sensors exist on a device.
*/
@@ -45,14 +48,39 @@ public class MultiBiometricEnrollHelper {
private final int mUserId;
private final boolean mRequestEnrollFace;
private final boolean mRequestEnrollFingerprint;
private final FingerprintManager mFingerprintManager;
private final FaceManager mFaceManager;
private final Intent mFingerprintEnrollIntroductionIntent;
private final Intent mFaceEnrollIntroductionIntent;
private Function<Long, byte[]> mGatekeeperHatSupplier;
@VisibleForTesting
MultiBiometricEnrollHelper(@NonNull FragmentActivity activity, int userId,
boolean enrollFace, boolean enrollFingerprint, long gkPwHandle) {
boolean enrollFace, boolean enrollFingerprint, long gkPwHandle,
FingerprintManager fingerprintManager,
FaceManager faceManager, Intent fingerprintEnrollIntroductionIntent,
Intent faceEnrollIntroductionIntent, Function<Long, byte[]> gatekeeperHatSupplier) {
mActivity = activity;
mUserId = userId;
mGkPwHandle = gkPwHandle;
mRequestEnrollFace = enrollFace;
mRequestEnrollFingerprint = enrollFingerprint;
mFingerprintManager = fingerprintManager;
mFaceManager = faceManager;
mFingerprintEnrollIntroductionIntent = fingerprintEnrollIntroductionIntent;
mFaceEnrollIntroductionIntent = faceEnrollIntroductionIntent;
mGatekeeperHatSupplier = gatekeeperHatSupplier;
}
MultiBiometricEnrollHelper(@NonNull FragmentActivity activity, int userId,
boolean enrollFace, boolean enrollFingerprint, long gkPwHandle) {
this(activity, userId, enrollFace, enrollFingerprint, gkPwHandle,
activity.getSystemService(FingerprintManager.class),
activity.getSystemService(FaceManager.class),
BiometricUtils.getFingerprintIntroIntent(activity, activity.getIntent()),
BiometricUtils.getFaceIntroIntent(activity, activity.getIntent()),
(challenge) -> BiometricUtils.requestGatekeeperHat(activity, gkPwHandle,
userId, challenge));
}
void startNextStep() {
@@ -67,45 +95,39 @@ public class MultiBiometricEnrollHelper {
}
private void launchFaceEnroll() {
final FaceManager faceManager = mActivity.getSystemService(FaceManager.class);
faceManager.generateChallenge(mUserId, (sensorId, userId, challenge) -> {
final byte[] hardwareAuthToken = BiometricUtils.requestGatekeeperHat(mActivity,
mGkPwHandle, mUserId, challenge);
final Intent faceIntent = BiometricUtils.getFaceIntroIntent(mActivity,
mActivity.getIntent());
faceIntent.putExtra(BiometricEnrollBase.EXTRA_KEY_SENSOR_ID, sensorId);
faceIntent.putExtra(BiometricEnrollBase.EXTRA_KEY_CHALLENGE, challenge);
BiometricUtils.launchEnrollForResult(mActivity, faceIntent, REQUEST_FACE_ENROLL,
hardwareAuthToken, mGkPwHandle, mUserId);
mFaceManager.generateChallenge(mUserId, (sensorId, userId, challenge) -> {
final byte[] hardwareAuthToken = mGatekeeperHatSupplier.apply(challenge);
mFaceEnrollIntroductionIntent.putExtra(
BiometricEnrollBase.EXTRA_KEY_SENSOR_ID, sensorId);
mFaceEnrollIntroductionIntent.putExtra(
BiometricEnrollBase.EXTRA_KEY_CHALLENGE, challenge);
BiometricUtils.launchEnrollForResult(mActivity, mFaceEnrollIntroductionIntent,
REQUEST_FACE_ENROLL, hardwareAuthToken, mGkPwHandle, mUserId);
});
}
private void launchFingerprintEnroll() {
final FingerprintManager fingerprintManager = mActivity
.getSystemService(FingerprintManager.class);
fingerprintManager.generateChallenge(mUserId, ((sensorId, userId, challenge) -> {
final byte[] hardwareAuthToken = BiometricUtils.requestGatekeeperHat(mActivity,
mGkPwHandle, mUserId, challenge);
final Intent intent = BiometricUtils.getFingerprintIntroIntent(mActivity,
mActivity.getIntent());
intent.putExtra(BiometricEnrollBase.EXTRA_KEY_SENSOR_ID, sensorId);
intent.putExtra(BiometricEnrollBase.EXTRA_KEY_CHALLENGE, challenge);
mFingerprintManager.generateChallenge(mUserId, ((sensorId, userId, challenge) -> {
final byte[] hardwareAuthToken = mGatekeeperHatSupplier.apply(challenge);
mFingerprintEnrollIntroductionIntent.putExtra(
BiometricEnrollBase.EXTRA_KEY_SENSOR_ID, sensorId);
mFingerprintEnrollIntroductionIntent.putExtra(
BiometricEnrollBase.EXTRA_KEY_CHALLENGE, challenge);
if (mRequestEnrollFace) {
// Give FingerprintEnroll a pendingIntent pointing to face enrollment, so that it
// can be started when user skips or finishes fingerprint enrollment.
// FLAG_UPDATE_CURRENT ensures it is launched with the most recent values.
final Intent faceIntent = BiometricUtils.getFaceIntroIntent(mActivity,
mActivity.getIntent());
faceIntent.putExtra(Intent.EXTRA_USER_ID, mUserId);
faceIntent.putExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE,
mGkPwHandle);
mFaceEnrollIntroductionIntent.putExtra(Intent.EXTRA_USER_ID, mUserId);
mFaceEnrollIntroductionIntent.putExtra(
ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE, mGkPwHandle);
final PendingIntent faceAfterFp = PendingIntent.getActivity(mActivity,
0 /* requestCode */, faceIntent,
0 /* requestCode */, mFaceEnrollIntroductionIntent,
PendingIntent.FLAG_IMMUTABLE | PendingIntent.FLAG_UPDATE_CURRENT);
intent.putExtra(EXTRA_ENROLL_AFTER_FINGERPRINT, faceAfterFp);
mFingerprintEnrollIntroductionIntent.putExtra(EXTRA_ENROLL_AFTER_FINGERPRINT,
faceAfterFp);
}
BiometricUtils.launchEnrollForResult(mActivity, intent, REQUEST_FINGERPRINT_ENROLL,
hardwareAuthToken, mGkPwHandle, mUserId);
BiometricUtils.launchEnrollForResult(mActivity, mFingerprintEnrollIntroductionIntent,
REQUEST_FINGERPRINT_ENROLL, hardwareAuthToken, mGkPwHandle, mUserId);
}));
}
}

19
src/com/android/settings/localepicker/AppLocalePickerActivity.java
View File

@@ -19,6 +19,7 @@ package com.android.settings.localepicker;
import android.app.FragmentTransaction;
import android.app.LocaleManager;
import android.content.Context;
import android.content.pm.PackageManager;
import android.net.Uri;
import android.os.Bundle;
import android.os.LocaleList;
@@ -34,6 +35,7 @@ import com.android.internal.app.LocalePickerWithRegion;
import com.android.internal.app.LocaleStore;
import com.android.settings.R;
import com.android.settings.applications.AppInfoBase;
import com.android.settings.applications.AppLocaleUtil;
import com.android.settings.applications.appinfo.AppLocaleDetails;
import com.android.settings.core.SettingsBaseActivity;
@@ -64,12 +66,17 @@ public class AppLocalePickerActivity extends SettingsBaseActivity
}
mContextAsUser = this;
if (getIntent().hasExtra(AppInfoBase.ARG_PACKAGE_UID)) {
int userId = getIntent().getIntExtra(AppInfoBase.ARG_PACKAGE_UID, -1);
if (userId != -1) {
UserHandle userHandle = UserHandle.getUserHandleForUid(userId);
int uid = getIntent().getIntExtra(AppInfoBase.ARG_PACKAGE_UID, -1);
if (uid != -1) {
UserHandle userHandle = UserHandle.getUserHandleForUid(uid);
mContextAsUser = createContextAsUser(userHandle, 0);
}
}
if (!canDisplayLocaleUi() || mContextAsUser.getUserId() != UserHandle.myUserId()) {
Log.w(TAG, "Not allow to display Locale Settings UI.");
finish();
return;
}
setTitle(R.string.app_locale_picker_title);
getActionBar().setDisplayHomeAsUpEnabled(true);
@@ -160,4 +167,10 @@ public class AppLocalePickerActivity extends SettingsBaseActivity
.replace(R.id.content_frame, mLocalePickerWithRegion)
.commit();
}
private boolean canDisplayLocaleUi() {
return AppLocaleUtil.canDisplayLocaleUi(mContextAsUser, mPackageName,
mContextAsUser.getPackageManager().queryIntentActivities(
AppLocaleUtil.LAUNCHER_ENTRY_INTENT, PackageManager.GET_META_DATA));
}
}

148
tests/robotests/src/com/android/settings/biometrics/MultiBiometricEnrollHelperTest.java Normal file
View File

@@ -0,0 +1,148 @@
/*
* Copyright (C) 2022 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 com.android.settings.biometrics;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.anyInt;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.verify;
import static org.robolectric.Shadows.shadowOf;
import android.content.Context;
import android.content.Intent;
import android.content.pm.PackageManager;
import android.hardware.face.FaceManager;
import android.hardware.fingerprint.FingerprintManager;
import android.os.RemoteException;
import androidx.fragment.app.FragmentActivity;
import com.android.settings.biometrics.face.FaceEnrollIntroduction;
import com.android.settings.biometrics.fingerprint.FingerprintEnrollIntroduction;
import com.android.settings.password.ChooseLockSettingsHelper;
import com.android.settings.testutils.shadow.ShadowLockPatternUtils;
import com.android.settings.testutils.shadow.ShadowRestrictedLockUtilsInternal;
import com.android.settings.testutils.shadow.ShadowSensorPrivacyManager;
import com.android.settings.testutils.shadow.ShadowUserManager;
import com.android.settings.testutils.shadow.ShadowUtils;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Captor;
import org.mockito.Mock;
import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
import org.robolectric.shadows.ShadowPackageManager;
@RunWith(RobolectricTestRunner.class)
@Config(shadows = {
ShadowUtils.class,
ShadowUserManager.class,
ShadowRestrictedLockUtilsInternal.class,
ShadowSensorPrivacyManager.class,
ShadowLockPatternUtils.class
})
public class MultiBiometricEnrollHelperTest {
@Rule
public final MockitoRule mockito = MockitoJUnit.rule();
@Mock
private FragmentActivity mActivity;
@Mock
private FingerprintManager mFingerprintManager;
@Mock
private FaceManager mFaceManager;
private Context mContext;
@Captor
private ArgumentCaptor<FingerprintManager.GenerateChallengeCallback> mFingerprintCaptor;
private final int mUserId = 10;
private final long mChallenge = 0L;
private final int mSensorId = 0;
private final long mGkPwHandle = 0L;
private MultiBiometricEnrollHelper mMultiBiometricEnrollHelper;
private Intent mFingerprintIntent;
private Intent mFaceIntent;
@Before
public void setUp() throws RemoteException {
mContext = RuntimeEnvironment.application.getApplicationContext();
mFingerprintIntent = new Intent(mContext, FingerprintEnrollIntroduction.class);
mFaceIntent = new Intent(mContext, FaceEnrollIntroduction.class);
mMultiBiometricEnrollHelper = new MultiBiometricEnrollHelper(
mActivity, mUserId, true /* enrollFace */, true /* enrollFingerprint */,
mGkPwHandle, mFingerprintManager, mFaceManager, mFingerprintIntent, mFaceIntent,
(challenge) -> null);
}
@Test
public void launchFaceAndFingerprintEnroll_testFingerprint() {
mMultiBiometricEnrollHelper.startNextStep();
verify(mFingerprintManager).generateChallenge(anyInt(), mFingerprintCaptor.capture());
FingerprintManager.GenerateChallengeCallback generateChallengeCallback =
mFingerprintCaptor.getValue();
generateChallengeCallback.onChallengeGenerated(mSensorId, mUserId, mChallenge);
assertThat(mFingerprintIntent.hasExtra(
MultiBiometricEnrollHelper.EXTRA_ENROLL_AFTER_FINGERPRINT)).isTrue();
assertThat(mFingerprintIntent.getExtra(BiometricEnrollBase.EXTRA_KEY_SENSOR_ID,
-1 /* defaultValue */)).isEqualTo(mSensorId);
assertThat(mFingerprintIntent.getExtra(BiometricEnrollBase.EXTRA_KEY_CHALLENGE,
-1 /* defaultValue */)).isEqualTo(mChallenge);
assertThat(mFingerprintIntent.getExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE,
-1 /* defaultValue */)).isEqualTo(mGkPwHandle);
}
@Test
public void launchFaceAndFingerprintEnroll_testFace() {
mMultiBiometricEnrollHelper.startNextStep();
verify(mFingerprintManager).generateChallenge(anyInt(), mFingerprintCaptor.capture());
FingerprintManager.GenerateChallengeCallback fingerprintGenerateChallengeCallback =
mFingerprintCaptor.getValue();
fingerprintGenerateChallengeCallback.onChallengeGenerated(
mSensorId, mUserId, mChallenge);
assertThat(mFaceIntent.getExtra(ChooseLockSettingsHelper.EXTRA_KEY_GK_PW_HANDLE,
-1 /* defaultValue */)).isEqualTo(mGkPwHandle);
assertThat(mFaceIntent.getIntExtra(Intent.EXTRA_USER_ID, -1 /* defaultValue */))
.isEqualTo(mUserId);
final ShadowPackageManager shadowPackageManager = shadowOf(mContext.getPackageManager());
shadowPackageManager.setSystemFeature(PackageManager.FEATURE_FACE, true);
ShadowUtils.setFaceManager(mFaceManager);
ActivityController.of(new FaceEnrollIntroduction(), mFaceIntent)
.create(mFaceIntent.getExtras()).get();
verify(mFaceManager).generateChallenge(eq(mUserId), any());
}
}

172
tests/robotests/src/com/android/settings/localepicker/AppLocalePickerActivityTest.java
View File

@@ -18,25 +18,35 @@ package com.android.settings.localepicker;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.times;
import static org.mockito.Mockito.verify;
import static org.mockito.Mockito.when;
import android.annotation.Nullable;
import android.app.Activity;
import android.app.ApplicationPackageManager;
import android.app.LocaleConfig;
import android.content.Context;
import android.content.Intent;
import android.content.pm.ApplicationInfo;
import android.content.pm.InstallSourceInfo;
import android.content.pm.PackageInfo;
import android.content.pm.ResolveInfo;
import android.content.res.Resources;
import android.net.Uri;
import android.os.LocaleList;
import android.os.Process;
import android.os.UserHandle;
import android.telephony.TelephonyManager;
import androidx.annotation.ArrayRes;
import com.android.internal.app.LocaleStore;
import com.android.settings.applications.AppInfoBase;
import java.util.Locale;
import org.junit.After;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
@@ -45,17 +55,26 @@ import org.mockito.junit.MockitoJUnit;
import org.mockito.junit.MockitoRule;
import org.robolectric.Robolectric;
import org.robolectric.RobolectricTestRunner;
import org.robolectric.RuntimeEnvironment;
import org.robolectric.Shadows;
import org.robolectric.android.controller.ActivityController;
import org.robolectric.annotation.Config;
import org.robolectric.annotation.Implementation;
import org.robolectric.annotation.Implements;
import org.robolectric.shadows.ShadowPackageManager;
import org.robolectric.shadows.ShadowTelephonyManager;
import java.util.ArrayList;
import java.util.List;
import java.util.Locale;
@RunWith(RobolectricTestRunner.class)
@Config(
shadows = {
AppLocalePickerActivityTest.ShadowApplicationPackageManager.class,
AppLocalePickerActivityTest.ShadowResources.class,
AppLocalePickerActivityTest.ShadowUserHandle.class,
AppLocalePickerActivityTest.ShadowLocaleConfig.class,
})
public class AppLocalePickerActivityTest {
private static final String TEST_PACKAGE_NAME = "com.android.settings";
@@ -67,21 +86,99 @@ public class AppLocalePickerActivityTest {
@Rule
public MockitoRule rule = MockitoJUnit.rule();
private Context mContext;
private ShadowPackageManager mPackageManager;
@Before
public void setUp() {
mContext = spy(RuntimeEnvironment.application);
mPackageManager = Shadows.shadowOf(mContext.getPackageManager());
}
@After
public void tearDown() {
mPackageManager.removePackage(TEST_PACKAGE_NAME);
ShadowResources.setDisAllowPackage(false);
ShadowApplicationPackageManager.setNoLaunchEntry(false);
ShadowUserHandle.setUserId(0);
ShadowLocaleConfig.setStatus(LocaleConfig.STATUS_SUCCESS);
}
@Test
public void launchAppLocalePickerActivity_hasPackageName_success() {
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isFalse();
}
@Test
public void launchAppLocalePickerActivity_appNoLocaleConfig_failed() {
ShadowLocaleConfig.setStatus(LocaleConfig.STATUS_NOT_SPECIFIED);
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
}
@Test
public void launchAppLocalePickerActivity_appSignPlatformKey_failed() {
final ApplicationInfo applicationInfo = new ApplicationInfo();
applicationInfo.privateFlags |= ApplicationInfo.PRIVATE_FLAG_SIGNED_WITH_PLATFORM_KEY;
applicationInfo.packageName = TEST_PACKAGE_NAME;
final PackageInfo packageInfo = new PackageInfo();
packageInfo.packageName = TEST_PACKAGE_NAME;
packageInfo.applicationInfo = applicationInfo;
mPackageManager.installPackage(packageInfo);
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
}
@Test
public void launchAppLocalePickerActivity_appMatchDisallowedPackage_failed() {
ShadowResources.setDisAllowPackage(true);
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
}
@Test
public void launchAppLocalePickerActivity_appNoLaunchEntry_failed() {
ShadowApplicationPackageManager.setNoLaunchEntry(true);
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
}
@Test
public void launchAppLocalePickerActivity_modifyAppLocalesOfAnotherUser_failed() {
ShadowUserHandle.setUserId(10);
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(true);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
}
@Test
public void launchAppLocalePickerActivity_intentWithoutPackageName_failed() {
ActivityController<TestAppLocalePickerActivity> controller =
initActivityController(false);
controller.create();
assertThat(controller.get().isFinishing()).isTrue();
@@ -125,7 +222,7 @@ public class AppLocalePickerActivityTest {
if (hasPackageName) {
data.setData(TEST_PACKAGE_URI);
}
data.putExtra(AppInfoBase.ARG_PACKAGE_UID, UserHandle.getUserId(Process.myUid()));
data.putExtra(AppInfoBase.ARG_PACKAGE_UID, Process.myUid());
ActivityController<TestAppLocalePickerActivity> activityController =
Robolectric.buildActivity(TestAppLocalePickerActivity.class, data);
Activity activity = activityController.get();
@@ -149,10 +246,75 @@ public class AppLocalePickerActivityTest {
@Implements(ApplicationPackageManager.class)
public static class ShadowApplicationPackageManager extends
org.robolectric.shadows.ShadowApplicationPackageManager {
private static boolean sNoLaunchEntry = false;
@Implementation
protected Object getInstallSourceInfo(String packageName) {
return new InstallSourceInfo("", null, null, "");
}
@Implementation
protected List<ResolveInfo> queryIntentActivities(Intent intent, int flags) {
if (sNoLaunchEntry) {
return new ArrayList();
} else {
return super.queryIntentActivities(intent, flags);
}
}
private static void setNoLaunchEntry(boolean noLaunchEntry) {
sNoLaunchEntry = noLaunchEntry;
}
}
@Implements(Resources.class)
public static class ShadowResources extends
org.robolectric.shadows.ShadowResources {
private static boolean sDisAllowPackage = false;
@Implementation
public String[] getStringArray(@ArrayRes int id) {
if (sDisAllowPackage) {
return new String[]{TEST_PACKAGE_NAME};
} else {
return new String[0];
}
}
private static void setDisAllowPackage(boolean disAllowPackage) {
sDisAllowPackage = disAllowPackage;
}
}
@Implements(UserHandle.class)
public static class ShadowUserHandle {
private static int sUserId = 0;
private static void setUserId(int userId) {
sUserId = userId;
}
@Implementation
public static int getUserId(int userId) {
return sUserId;
}
}
@Implements(LocaleConfig.class)
public static class ShadowLocaleConfig {
private static int sStatus = 0;
@Implementation
public @Nullable LocaleList getSupportedLocales() {
return LocaleList.forLanguageTags("en-US");
}
private static void setStatus(@LocaleConfig.Status int status) {
sStatus = status;
}
@Implementation
public @LocaleConfig.Status int getStatus() {
return sStatus;
}
}
}