• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2023 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.settings.privatespace;
18 
19 import static android.provider.Settings.Secure.LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS;
20 import static android.provider.Settings.Secure.PRIVATE_SPACE_AUTO_LOCK;
21 
22 import static com.android.settings.privatespace.PrivateSpaceMaintainer.HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL;
23 import static com.android.settings.privatespace.PrivateSpaceMaintainer.HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL;
24 import static com.android.settings.privatespace.PrivateSpaceMaintainer.HIDE_PRIVATE_SPACE_SENSITIVE_NOTIFICATIONS_DISABLED_VAL;
25 import static com.android.settings.privatespace.PrivateSpaceMaintainer.PRIVATE_SPACE_CREATE_AUTO_LOCK_VAL;
26 
27 import static com.google.common.truth.Truth.assertThat;
28 
29 import static org.junit.Assume.assumeFalse;
30 import static org.junit.Assume.assumeTrue;
31 import static org.mockito.Mockito.spy;
32 import static org.mockito.Mockito.when;
33 
34 import android.app.ActivityManager;
35 import android.app.IActivityManager;
36 import android.content.ComponentName;
37 import android.content.ContentResolver;
38 import android.content.Context;
39 import android.content.Intent;
40 import android.content.pm.PackageManager;
41 import android.os.Flags;
42 import android.os.RemoteException;
43 import android.os.UserHandle;
44 import android.os.UserManager;
45 import android.platform.test.flag.junit.SetFlagsRule;
46 import android.provider.Settings;
47 
48 import androidx.test.core.app.ApplicationProvider;
49 import androidx.test.ext.junit.runners.AndroidJUnit4;
50 
51 import com.android.compatibility.common.util.BlockingBroadcastReceiver;
52 import com.android.settings.privatespace.PrivateSpaceMaintainer.ErrorDeletingPrivateSpace;
53 
54 import org.junit.After;
55 import org.junit.Assert;
56 import org.junit.Before;
57 import org.junit.Ignore;
58 import org.junit.Rule;
59 import org.junit.Test;
60 import org.junit.runner.RunWith;
61 import org.mockito.MockitoAnnotations;
62 
63 import java.util.Objects;
64 import java.util.concurrent.TimeUnit;
65 
66 @RunWith(AndroidJUnit4.class)
67 public class PrivateSpaceMaintainerTest {
68     private static final String TAG = "PSMaintainerTest";
69     private Context mContext;
70     private ContentResolver mContentResolver;
71     @Rule public final SetFlagsRule mSetFlagsRule = new SetFlagsRule();
72 
73     /** Required setup before a test. */
74     @Before
setUp()75     public void setUp() {
76         MockitoAnnotations.initMocks(this);
77         mContext = ApplicationProvider.getApplicationContext();
78         mContentResolver = mContext.getContentResolver();
79     }
80 
81     @After
tearDown()82     public void tearDown() {
83         PrivateSpaceMaintainer privateSpaceMaintainer =
84                 PrivateSpaceMaintainer.getInstance(mContext);
85         privateSpaceMaintainer.deletePrivateSpace();
86     }
87 
88     /** Tests that {@link PrivateSpaceMaintainer#deletePrivateSpace()} deletes PS when PS exists. */
89     @Test
deletePrivateSpace_psExists_deletesPS()90     public void deletePrivateSpace_psExists_deletesPS() {
91         mSetFlagsRule.enableFlags(
92                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
93         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
94         PrivateSpaceMaintainer privateSpaceMaintainer =
95                 PrivateSpaceMaintainer.getInstance(mContext);
96         privateSpaceMaintainer.createPrivateSpace();
97         ErrorDeletingPrivateSpace errorDeletingPrivateSpace =
98                 privateSpaceMaintainer.deletePrivateSpace();
99         assertThat(errorDeletingPrivateSpace)
100                 .isEqualTo(ErrorDeletingPrivateSpace.DELETE_PS_ERROR_NONE);
101         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
102     }
103 
104     /**
105      * Tests that {@link PrivateSpaceMaintainer#deletePrivateSpace()} returns error when PS does not
106      * exist.
107      */
108     @Test
deletePrivateSpace_psDoesNotExist_returnsNoPSError()109     public void deletePrivateSpace_psDoesNotExist_returnsNoPSError() {
110         mSetFlagsRule.enableFlags(
111                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
112         PrivateSpaceMaintainer privateSpaceMaintainer =
113                 PrivateSpaceMaintainer.getInstance(mContext);
114         privateSpaceMaintainer.deletePrivateSpace();
115         ErrorDeletingPrivateSpace errorDeletingPrivateSpace =
116                 privateSpaceMaintainer.deletePrivateSpace();
117         assertThat(errorDeletingPrivateSpace)
118                 .isEqualTo(ErrorDeletingPrivateSpace.DELETE_PS_ERROR_NO_PRIVATE_SPACE);
119         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
120     }
121 
122     /** Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when PS exists creates PS. */
123     @Test
createPrivateSpace_psDoesNotExist_createsPS()124     public void createPrivateSpace_psDoesNotExist_createsPS() {
125         mSetFlagsRule.enableFlags(
126                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
127         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
128         PrivateSpaceMaintainer privateSpaceMaintainer =
129                 PrivateSpaceMaintainer.getInstance(mContext);
130         privateSpaceMaintainer.deletePrivateSpace();
131         assertThat(privateSpaceMaintainer.createPrivateSpace()).isTrue();
132         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
133     }
134 
135     /**
136      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when PS exists still returns
137      * true.
138      */
139     @Test
createPrivateSpace_psExists_returnsFalse()140     public void createPrivateSpace_psExists_returnsFalse() {
141         mSetFlagsRule.enableFlags(
142                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
143         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
144         PrivateSpaceMaintainer privateSpaceMaintainer =
145                 PrivateSpaceMaintainer.getInstance(mContext);
146         privateSpaceMaintainer.deletePrivateSpace();
147         assertThat(privateSpaceMaintainer.createPrivateSpace()).isTrue();
148         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
149         assertThat(privateSpaceMaintainer.createPrivateSpace()).isTrue();
150     }
151 
152     /**
153      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when no PS exists resets hide
154      * PS Settings.
155      */
156     @Test
createPrivateSpace_psDoesNotExist_resetsHidePSSettings()157     public void createPrivateSpace_psDoesNotExist_resetsHidePSSettings() {
158         mSetFlagsRule.enableFlags(
159                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
160         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
161         PrivateSpaceMaintainer privateSpaceMaintainer =
162                 PrivateSpaceMaintainer.getInstance(mContext);
163         Settings.Secure.putInt(
164                 mContentResolver,
165                 Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT,
166                 HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL);
167 
168         privateSpaceMaintainer.deletePrivateSpace();
169         privateSpaceMaintainer.createPrivateSpace();
170         assertThat(privateSpaceMaintainer.getHidePrivateSpaceEntryPointSetting())
171                 .isEqualTo(HIDE_PRIVATE_SPACE_ENTRY_POINT_DISABLED_VAL);
172     }
173 
174     /**
175      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} sets the PS sensitive
176      * notifications to hidden by default.
177      */
178     @Test
createPrivateSpace_psDoesNotExist_setsDefaultPsSensitiveNotificationsValue()179     public void createPrivateSpace_psDoesNotExist_setsDefaultPsSensitiveNotificationsValue() {
180         mSetFlagsRule.enableFlags(
181                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
182                 android.multiuser.Flags.FLAG_ENABLE_PS_SENSITIVE_NOTIFICATIONS_TOGGLE,
183                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
184         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
185         PrivateSpaceMaintainer privateSpaceMaintainer =
186                 PrivateSpaceMaintainer.getInstance(mContext);
187         privateSpaceMaintainer.deletePrivateSpace();
188         privateSpaceMaintainer.createPrivateSpace();
189         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
190         assertThat(getPsSensitiveNotificationsValue(privateSpaceMaintainer))
191                 .isEqualTo(HIDE_PRIVATE_SPACE_SENSITIVE_NOTIFICATIONS_DISABLED_VAL);
192     }
193 
194     /**
195      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when PS exist does not reset
196      * hide PS Settings.
197      */
198     @Test
createPrivateSpace_psExists_doesNotResetHidePSSettings()199     public void createPrivateSpace_psExists_doesNotResetHidePSSettings() {
200         mSetFlagsRule.enableFlags(
201                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
202         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
203         PrivateSpaceMaintainer privateSpaceMaintainer =
204                 PrivateSpaceMaintainer.getInstance(mContext);
205         privateSpaceMaintainer.createPrivateSpace();
206         Settings.Secure.putInt(
207                 mContentResolver,
208                 Settings.Secure.HIDE_PRIVATESPACE_ENTRY_POINT,
209                 HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL);
210 
211         privateSpaceMaintainer.createPrivateSpace();
212         assertThat(privateSpaceMaintainer.getHidePrivateSpaceEntryPointSetting())
213                 .isEqualTo(HIDE_PRIVATE_SPACE_ENTRY_POINT_ENABLED_VAL);
214     }
215 
216     @Test
createPrivateSpace_psDoesNotExist_registersTheBroadcastReceiver()217     public void createPrivateSpace_psDoesNotExist_registersTheBroadcastReceiver() {
218         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
219                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
220         PrivateSpaceMaintainer privateSpaceMaintainer =
221                 PrivateSpaceMaintainer.getInstance(mContext);
222         privateSpaceMaintainer.deletePrivateSpace();
223         privateSpaceMaintainer.createPrivateSpace();
224         // test that no exception is thrown, which would indicate that the receiver was registered.
225         mContext.unregisterReceiver(privateSpaceMaintainer.getProfileBroadcastReceiver());
226         privateSpaceMaintainer.resetBroadcastReceiver();
227     }
228 
229     @Test
deletePrivateSpace_psExists_unregistersTheBroadcastReceiver()230     public void deletePrivateSpace_psExists_unregistersTheBroadcastReceiver() {
231         mSetFlagsRule.enableFlags(Flags.FLAG_ALLOW_PRIVATE_PROFILE,
232                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
233         PrivateSpaceMaintainer privateSpaceMaintainer =
234                 PrivateSpaceMaintainer.getInstance(mContext);
235         privateSpaceMaintainer.createPrivateSpace();
236         privateSpaceMaintainer.deletePrivateSpace();
237         assertThat(privateSpaceMaintainer.getProfileBroadcastReceiver()).isNull();
238     }
239 
240     /**
241      * Tests that {@link PrivateSpaceMaintainer#lockPrivateSpace()} when PS exists and is running
242      * locks the private profile.
243      */
244     @Ignore("Flaky pre-submit b/378392936")
245     @Test
lockPrivateSpace_psExistsAndPrivateProfileRunning_locksCreatedPrivateSpace()246     public void lockPrivateSpace_psExistsAndPrivateProfileRunning_locksCreatedPrivateSpace() {
247         mSetFlagsRule.enableFlags(
248                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
249         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
250         PrivateSpaceMaintainer privateSpaceMaintainer =
251                 PrivateSpaceMaintainer.getInstance(mContext);
252         privateSpaceMaintainer.createPrivateSpace();
253         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
254         assertThat(privateSpaceMaintainer.isPrivateProfileRunning()).isTrue();
255         assertThat(privateSpaceMaintainer.isPrivateSpaceLocked()).isFalse();
256         assertThat(privateSpaceMaintainer.lockPrivateSpace()).isTrue();
257         assertThat(privateSpaceMaintainer.isPrivateSpaceLocked()).isTrue();
258     }
259 
260     /**
261      * Tests that {@link PrivateSpaceMaintainer#lockPrivateSpace()} when PS exist and private
262      * profile not running returns false.
263      */
264     @Ignore("Flaky pre-submit b/378392936")
265     @Test
lockPrivateSpace_psExistsAndPrivateProfileNotRunning_returnsFalse()266     public void lockPrivateSpace_psExistsAndPrivateProfileNotRunning_returnsFalse() {
267         mSetFlagsRule.enableFlags(
268                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
269         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
270         PrivateSpaceMaintainer privateSpaceMaintainer =
271                 PrivateSpaceMaintainer.getInstance(mContext);
272         privateSpaceMaintainer.createPrivateSpace();
273         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
274         assertThat(privateSpaceMaintainer.isPrivateProfileRunning()).isTrue();
275         IActivityManager am = ActivityManager.getService();
276         try {
277             am.stopProfile(privateSpaceMaintainer.getPrivateProfileHandle().getIdentifier());
278         } catch (RemoteException e) {
279             Assert.fail("Stop profile failed with exception " + e.getMessage());
280         }
281         assertThat(privateSpaceMaintainer.isPrivateProfileRunning()).isFalse();
282         assertThat(privateSpaceMaintainer.lockPrivateSpace()).isFalse();
283     }
284 
285     /**
286      * Tests that {@link PrivateSpaceMaintainer#lockPrivateSpace()} when no PS exists returns false.
287      */
288     @Test
lockPrivateSpace_psDoesNotExist_returnsFalse()289     public void lockPrivateSpace_psDoesNotExist_returnsFalse() {
290         mSetFlagsRule.enableFlags(
291                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
292         PrivateSpaceMaintainer privateSpaceMaintainer =
293                 PrivateSpaceMaintainer.getInstance(mContext);
294         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
295         assertThat(privateSpaceMaintainer.lockPrivateSpace()).isFalse();
296     }
297 
298     /**
299      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when no PS exists sets
300      * USER_SETUP_COMPLETE setting.
301      */
302     @Test
createPrivateSpace_psDoesNotExist_setsUserSetupComplete()303     public void createPrivateSpace_psDoesNotExist_setsUserSetupComplete() {
304         mSetFlagsRule.enableFlags(
305                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
306         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
307         PrivateSpaceMaintainer privateSpaceMaintainer =
308                 PrivateSpaceMaintainer.getInstance(mContext);
309         privateSpaceMaintainer.createPrivateSpace();
310         assertThat(getSecureUserSetupComplete()).isEqualTo(1);
311     }
312 
313     /**
314      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when PS exists does not change
315      * USER_SETUP_COMPLETE setting.
316      */
317     @Test
createPrivateSpace_pSExists_doesNotChangeUserSetupSetting()318     public void createPrivateSpace_pSExists_doesNotChangeUserSetupSetting() {
319         mSetFlagsRule.enableFlags(
320                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
321         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
322         PrivateSpaceMaintainer privateSpaceMaintainer =
323                 PrivateSpaceMaintainer.getInstance(mContext);
324         privateSpaceMaintainer.createPrivateSpace();
325         assertThat(getSecureUserSetupComplete()).isEqualTo(1);
326         privateSpaceMaintainer.createPrivateSpace();
327         assertThat(getSecureUserSetupComplete()).isEqualTo(1);
328     }
329 
330     /**
331      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when no PS exists resets PS
332      * auto lock Settings.
333      */
334     @Test
createPrivateSpace_psDoesNotExist_resetsPSAutoLockSettings()335     public void createPrivateSpace_psDoesNotExist_resetsPSAutoLockSettings() {
336         mSetFlagsRule.enableFlags(
337                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
338                 android.multiuser.Flags.FLAG_SUPPORT_AUTOLOCK_FOR_PRIVATE_SPACE,
339                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
340         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
341         final int autoLockOption = 2;
342         PrivateSpaceMaintainer privateSpaceMaintainer =
343                 PrivateSpaceMaintainer.getInstance(mContext);
344         Settings.Secure.putInt(
345                 mContentResolver, Settings.Secure.PRIVATE_SPACE_AUTO_LOCK, autoLockOption);
346 
347         privateSpaceMaintainer.deletePrivateSpace();
348         privateSpaceMaintainer.createPrivateSpace();
349         assertThat(privateSpaceMaintainer.getPrivateSpaceAutoLockSetting())
350                 .isEqualTo(PRIVATE_SPACE_CREATE_AUTO_LOCK_VAL);
351         assertThat(Settings.Secure.getInt(mContentResolver, PRIVATE_SPACE_AUTO_LOCK, -1))
352                 .isEqualTo(PRIVATE_SPACE_CREATE_AUTO_LOCK_VAL);
353     }
354 
355     /**
356      * Tests that {@link PrivateSpaceMaintainer#createPrivateSpace()} when PS exist does not reset
357      * PS auto lock setting.
358      */
359     @Test
createPrivateSpace_psExists_doesNotResetPSAutoLockSettings()360     public void createPrivateSpace_psExists_doesNotResetPSAutoLockSettings() {
361         mSetFlagsRule.enableFlags(
362                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
363                 android.multiuser.Flags.FLAG_SUPPORT_AUTOLOCK_FOR_PRIVATE_SPACE,
364                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
365         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
366         final int privateSpaceAutLockValue = 1;
367         PrivateSpaceMaintainer privateSpaceMaintainer =
368                 PrivateSpaceMaintainer.getInstance(mContext);
369         privateSpaceMaintainer.createPrivateSpace();
370         Settings.Secure.putInt(
371                 mContentResolver,
372                 Settings.Secure.PRIVATE_SPACE_AUTO_LOCK,
373                 privateSpaceAutLockValue);
374 
375         privateSpaceMaintainer.createPrivateSpace();
376         assertThat(privateSpaceMaintainer.getPrivateSpaceAutoLockSetting())
377                 .isEqualTo(privateSpaceAutLockValue);
378     }
379 
380     @Test
isPrivateSpaceEntryPointEnabled_psExistCanAddProfileTrue_returnsTrue()381     public void isPrivateSpaceEntryPointEnabled_psExistCanAddProfileTrue_returnsTrue() {
382         mSetFlagsRule.enableFlags(
383                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
384                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
385         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
386         PrivateSpaceMaintainer privateSpaceMaintainer =
387                 PrivateSpaceMaintainer.getInstance(mContext);
388         privateSpaceMaintainer.createPrivateSpace();
389         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
390 
391         assertThat(privateSpaceMaintainer.isPrivateSpaceEntryPointEnabled()).isTrue();
392     }
393 
394     @Test
isPrivateSpaceEntryPointEnabled_psNotExistsCanAddProfileTrue_returnsTrue()395     public void isPrivateSpaceEntryPointEnabled_psNotExistsCanAddProfileTrue_returnsTrue() {
396         mSetFlagsRule.enableFlags(
397                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
398                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
399         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
400         PrivateSpaceMaintainer privateSpaceMaintainer =
401                 PrivateSpaceMaintainer.getInstance(mContext);
402         privateSpaceMaintainer.deletePrivateSpace();
403         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
404 
405         assertThat(privateSpaceMaintainer.isPrivateSpaceEntryPointEnabled()).isTrue();
406     }
407 
408     @Test
isPrivateSpaceEntryPointEnabled_psExistsCanAddProfileFalse_returnsTrue()409     public void isPrivateSpaceEntryPointEnabled_psExistsCanAddProfileFalse_returnsTrue() {
410         mSetFlagsRule.enableFlags(
411                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
412                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
413         assumeFalse(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
414         PrivateSpaceMaintainer privateSpaceMaintainer =
415                 spy(PrivateSpaceMaintainer.getInstance(mContext));
416         when(privateSpaceMaintainer.doesPrivateSpaceExist()).thenReturn(true);
417 
418         assertThat(privateSpaceMaintainer.isPrivateSpaceEntryPointEnabled()).isTrue();
419     }
420 
421     @Test
isPrivateSpaceEntryPointEnabled_psNotExistsCanAddProfileFalse_returnsFalse()422     public void isPrivateSpaceEntryPointEnabled_psNotExistsCanAddProfileFalse_returnsFalse() {
423         mSetFlagsRule.enableFlags(
424                 Flags.FLAG_ALLOW_PRIVATE_PROFILE,
425                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
426         assumeFalse(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
427         PrivateSpaceMaintainer privateSpaceMaintainer =
428                 PrivateSpaceMaintainer.getInstance(mContext);
429         privateSpaceMaintainer.deletePrivateSpace();
430         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
431 
432         assertThat(privateSpaceMaintainer.isPrivateSpaceEntryPointEnabled()).isFalse();
433     }
434 
435     @Test
createPrivateSpace_psDoesNotExist_setsSkipFirstUseHints()436     public void createPrivateSpace_psDoesNotExist_setsSkipFirstUseHints() {
437         mSetFlagsRule.enableFlags(
438                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
439         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
440         PrivateSpaceMaintainer privateSpaceMaintainer =
441                 PrivateSpaceMaintainer.getInstance(mContext);
442         privateSpaceMaintainer.createPrivateSpace();
443         assertThat(getSecureSkipFirstUseHints()).isEqualTo(1);
444     }
445 
446     @Test
createPrivateSpace_psDoesNotExist_setsPrivateSpaceSettingsComponentDisabled()447     public void createPrivateSpace_psDoesNotExist_setsPrivateSpaceSettingsComponentDisabled() {
448         mSetFlagsRule.enableFlags(
449                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
450         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
451         PrivateSpaceMaintainer privateSpaceMaintainer =
452                 PrivateSpaceMaintainer.getInstance(mContext);
453         privateSpaceMaintainer.createPrivateSpace();
454         assertThat(privateSpaceMaintainer.getPrivateProfileHandle()).isNotNull();
455         Context privateSpaceUserContext = mContext.createContextAsUser(
456                 privateSpaceMaintainer.getPrivateProfileHandle(),
457                 /* flags */ 0);
458 
459         // Assert that private space settings launcher app icon is disabled
460         ComponentName settingsComponentName = new ComponentName(privateSpaceUserContext,
461                 com.android.settings.Settings.class);
462         int settingsComponentEnabledSetting = privateSpaceUserContext.getPackageManager()
463                 .getComponentEnabledSetting(settingsComponentName);
464         assertThat(settingsComponentEnabledSetting)
465                 .isEqualTo(PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
466 
467         // Assert that private space settings create shortcut activity is disabled
468         ComponentName shortcutPickerComponentName = new ComponentName(privateSpaceUserContext,
469                 com.android.settings.Settings.CreateShortcutActivity.class);
470         int settingsShortcutPickerEnabledSetting = privateSpaceUserContext.getPackageManager()
471                 .getComponentEnabledSetting(shortcutPickerComponentName);
472         assertThat(settingsShortcutPickerEnabledSetting)
473                 .isEqualTo(PackageManager.COMPONENT_ENABLED_STATE_DISABLED);
474     }
475 
476     @Test
createPrivateSpace_pSExists_doesNotChangeSkipFirstUseHints()477     public void createPrivateSpace_pSExists_doesNotChangeSkipFirstUseHints() {
478         mSetFlagsRule.enableFlags(
479                 android.multiuser.Flags.FLAG_ENABLE_PRIVATE_SPACE_FEATURES);
480         assumeTrue(mContext.getSystemService(UserManager.class).canAddPrivateProfile());
481         PrivateSpaceMaintainer privateSpaceMaintainer =
482                 PrivateSpaceMaintainer.getInstance(mContext);
483         privateSpaceMaintainer.createPrivateSpace();
484         assertThat(getSecureSkipFirstUseHints()).isEqualTo(1);
485         privateSpaceMaintainer.createPrivateSpace();
486         assertThat(getSecureSkipFirstUseHints()).isEqualTo(1);
487     }
488 
getSecureUserSetupComplete()489     private int getSecureUserSetupComplete() {
490         PrivateSpaceMaintainer privateSpaceMaintainer =
491                 PrivateSpaceMaintainer.getInstance(mContext);
492         return Settings.Secure.getIntForUser(
493                 mContentResolver,
494                 Settings.Secure.USER_SETUP_COMPLETE,
495                 0,
496                 privateSpaceMaintainer.getPrivateProfileHandle().getIdentifier());
497     }
498 
getSecureSkipFirstUseHints()499     private int getSecureSkipFirstUseHints() {
500         PrivateSpaceMaintainer privateSpaceMaintainer =
501                 PrivateSpaceMaintainer.getInstance(mContext);
502         return Settings.Secure.getIntForUser(
503                 mContentResolver,
504                 Settings.Secure.SKIP_FIRST_USE_HINTS,
505                 0,
506                 privateSpaceMaintainer.getPrivateProfileHandle().getIdentifier());
507     }
508 
getPsSensitiveNotificationsValue(PrivateSpaceMaintainer privateSpaceMaintainer)509     private int getPsSensitiveNotificationsValue(PrivateSpaceMaintainer privateSpaceMaintainer) {
510         return Settings.Secure.getIntForUser(mContentResolver,
511                 LOCK_SCREEN_ALLOW_PRIVATE_NOTIFICATIONS,
512                 /* enabled */ 1,
513                 privateSpaceMaintainer.getPrivateProfileHandle().getIdentifier());
514     }
515 
516     @Test
profileRemovedFromUserManager_privateSpaceNoLongerExists()517     public void profileRemovedFromUserManager_privateSpaceNoLongerExists() {
518         PrivateSpaceMaintainer privateSpaceMaintainer = PrivateSpaceMaintainer.getInstance(
519                 mContext);
520         privateSpaceMaintainer.createPrivateSpace();
521         UserHandle privateSpaceUserHandle = privateSpaceMaintainer.getPrivateProfileHandle();
522         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isTrue();
523         Intent removedIntent = new Intent(Intent.ACTION_PROFILE_REMOVED);
524         assertThat(privateSpaceUserHandle).isNotNull();
525         final BlockingBroadcastReceiver receiver = new BlockingBroadcastReceiver(mContext,
526                 removedIntent.getAction());
527         receiver.register();
528 
529         Objects.requireNonNull(mContext.getSystemService(UserManager.class)).removeUser(
530                 privateSpaceUserHandle);
531 
532         receiver.awaitForBroadcast(TimeUnit.SECONDS.toMillis(10));
533         assertThat(privateSpaceMaintainer.doesPrivateSpaceExist()).isFalse();
534     }
535 
536 }
537