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

Prompt user to Setup a device lock if not set

Browse Source 
This add below changes on selecting private space setting:
1. Prompt user to setup device lock if not already set
2. If device lock is set authenticate user first before displaying private space settings page

Screenshot - https://screenshot.googleplex.com/4SrYHbBMJfVuoRy.png
https://screenshot.googleplex.com/6vNWm7Lg83vfnH8.png
RecordingLink - https://drive.google.com/file/d/1r4zb3ILPRqwvP5tlwfjQ9GgnDAW4vZg6/view?usp=drive_link

Bug: 289016927
Test: atest PrivateSpaceSettingsAuthenticatorTest , atest SecuritySettingsTest
Change-Id: I0e5dfb30213843c0dec60a17d01c30cd91db89b0
This commit is contained in:
josephpv
2023-10-04 18:14:20 +00:00
parent 852ec4e22d
commit 31b044ed6a
10 changed files with 416 additions and 15 deletions
Download Patch File Download Diff File Expand all files Collapse all files

98
tests/unit/src/com/android/settings/privatespace/PrivateSpaceAuthenticationActivityTest.java Normal file
View File

@@ -0,0 +1,98 @@
/*
* Copyright (C) 2023 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.privatespace;
import static com.android.settings.privatespace.PrivateSpaceSafetySource.SAFETY_SOURCE_ID;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.Mockito.doNothing;
import static org.mockito.Mockito.spy;
import static org.mockito.Mockito.verify;
import android.content.Context;
import android.content.Intent;
import android.os.Flags;
import android.platform.test.annotations.RequiresFlagsEnabled;
import android.platform.test.flag.junit.CheckFlagsRule;
import android.platform.test.flag.junit.DeviceFlagsValueProvider;
import androidx.test.core.app.ApplicationProvider;
import androidx.test.ext.junit.runners.AndroidJUnit4;
import androidx.test.platform.app.InstrumentationRegistry;
import org.junit.Before;
import org.junit.Rule;
import org.junit.Test;
import org.junit.runner.RunWith;
import org.mockito.ArgumentCaptor;
import org.mockito.Mock;
import org.mockito.MockitoAnnotations;
@RunWith(AndroidJUnit4.class)
public class PrivateSpaceAuthenticationActivityTest {
@Rule
public final CheckFlagsRule mCheckFlagsRule =
DeviceFlagsValueProvider.createCheckFlagsRule();
@Mock private PrivateSpaceMaintainer mPrivateSpaceMaintainer;
@Mock private Context mContext;
private PrivateSpaceAuthenticationActivity mPrivateSpaceAuthenticationActivity;
private Intent mDefaultIntent;
/** Required setup before a test. */
@Before
public void setUp() {
MockitoAnnotations.initMocks(this);
mContext = ApplicationProvider.getApplicationContext();
mDefaultIntent = new Intent();
mDefaultIntent.setClass(InstrumentationRegistry.getInstrumentation().getTargetContext(),
PrivateSpaceAuthenticationActivity.class);
InstrumentationRegistry.getInstrumentation().runOnMainSync(() -> {
try {
mPrivateSpaceAuthenticationActivity =
spy((PrivateSpaceAuthenticationActivity) InstrumentationRegistry
.getInstrumentation().newActivity(
getClass().getClassLoader(),
PrivateSpaceAuthenticationActivity.class.getName(),
mDefaultIntent));
} catch (Exception e) {
throw new RuntimeException(e); // nothing to do
}
});
doNothing().when(mPrivateSpaceAuthenticationActivity).startActivity(any(Intent.class));
PrivateSpaceAuthenticationActivity.Injector injector =
new PrivateSpaceAuthenticationActivity.Injector() {
@Override
PrivateSpaceMaintainer injectPrivateSpaceMaintainer(Context context) {
return mPrivateSpaceMaintainer;
}
};
mPrivateSpaceAuthenticationActivity.setPrivateSpaceMaintainer(injector);
}
/** Tests that on lock authentication Private space settings is launched. */
@Test
@RequiresFlagsEnabled(Flags.FLAG_ALLOW_PRIVATE_PROFILE)
public void deviceSecurePrivateSpaceExists() {
final ArgumentCaptor<Intent> intentCaptor = ArgumentCaptor.forClass(Intent.class);
mPrivateSpaceAuthenticationActivity.onLockAuthentication(mContext);
verify(mPrivateSpaceAuthenticationActivity).startActivity(intentCaptor.capture());
assertThat(intentCaptor.getValue().getIdentifier()).isEqualTo(SAFETY_SOURCE_ID);
}
}

11
tests/unit/src/com/android/settings/privatespace/PrivateSpaceSafetySourceTest.java
View File

@@ -18,8 +18,11 @@ package com.android.settings.privatespace;
import static android.safetycenter.SafetyEvent.SAFETY_EVENT_TYPE_DEVICE_REBOOTED;
import static com.android.settings.privatespace.PrivateSpaceSafetySource.SAFETY_SOURCE_ID;
import static com.google.common.truth.Truth.assertThat;
import static org.mockito.ArgumentMatchers.any;
import static org.mockito.ArgumentMatchers.eq;
import static org.mockito.Mockito.never;
@@ -122,9 +125,9 @@ public class PrivateSpaceSafetySourceTest {
assertThat(safetySourceStatus.isEnabled()).isTrue();
}
/** Tests that setSafetySourceData sets the PS settings page intent. */
/** Tests that setSafetySourceData sets the PS settings page authenticator intent. */
@Test
public void setSafetySourceData_setsPsIntent() {
public void setSafetySourceData_setsPsAuthenticatorIntent() {
when(mSafetyCenterManagerWrapper.isEnabled(mContext)).thenReturn(true);
mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE);
@@ -135,7 +138,7 @@ public class PrivateSpaceSafetySourceTest {
any(), eq(SAFETY_SOURCE_ID), captor.capture(), eq(EVENT_TYPE_DEVICE_REBOOTED));
SafetySourceData safetySourceData = captor.getValue();
SafetySourceStatus safetySourceStatus = safetySourceData.getStatus();
assertThat(safetySourceStatus.getPendingIntent().getIntent().getIdentifier())
.isEqualTo(SAFETY_SOURCE_ID);
assertThat(safetySourceStatus.getPendingIntent().getIntent()
.equals(PrivateSpaceAuthenticationActivity.class));
}
}