• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2022 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 android.devicepolicy.cts;
18 
19 import static android.app.admin.DevicePolicyIdentifiers.APPLICATION_HIDDEN_POLICY;
20 import static android.app.admin.TargetUser.LOCAL_USER_ID;
21 import static android.content.Intent.ACTION_PACKAGE_ADDED;
22 import static android.content.Intent.ACTION_PACKAGE_REMOVED;
23 import static android.devicepolicy.cts.utils.PolicyEngineUtils.TRUE_MORE_RESTRICTIVE;
24 
25 import static com.google.common.truth.Truth.assertThat;
26 import static com.google.common.truth.Truth.assertWithMessage;
27 
28 import static org.testng.Assert.assertThrows;
29 
30 import android.app.admin.PackagePolicyKey;
31 import android.app.admin.PolicyState;
32 import android.app.admin.PolicyUpdateResult;
33 import android.content.Intent;
34 import android.content.IntentFilter;
35 import android.devicepolicy.cts.utils.PolicyEngineUtils;
36 import android.devicepolicy.cts.utils.PolicySetResultUtils;
37 import android.os.Bundle;
38 import android.stats.devicepolicy.EventId;
39 import android.util.Log;
40 
41 import com.android.bedstead.harrier.BedsteadJUnit4;
42 import com.android.bedstead.harrier.DeviceState;
43 import com.android.bedstead.harrier.annotations.EnsureTestAppInstalled;
44 import com.android.bedstead.harrier.annotations.Postsubmit;
45 import com.android.bedstead.enterprise.annotations.CanSetPolicyTest;
46 import com.android.bedstead.enterprise.annotations.CannotSetPolicyTest;
47 import com.android.bedstead.enterprise.annotations.EnsureHasDeviceOwner;
48 import com.android.bedstead.enterprise.annotations.PolicyAppliesTest;
49 import com.android.bedstead.enterprise.annotations.PolicyDoesNotApplyTest;
50 import com.android.bedstead.enterprise.annotations.RequireHasPolicyExemptApps;
51 import com.android.bedstead.harrier.policies.ApplicationHidden;
52 import com.android.bedstead.harrier.policies.ApplicationHiddenSystemOnly;
53 import com.android.bedstead.metricsrecorder.EnterpriseMetricsRecorder;
54 import com.android.bedstead.metricsrecorder.truth.MetricQueryBuilderSubject;
55 import com.android.bedstead.nene.TestApis;
56 import com.android.bedstead.nene.packages.Package;
57 import com.android.compatibility.common.util.ApiTest;
58 import com.android.bedstead.nene.utils.BlockingBroadcastReceiver;
59 
60 import org.junit.Before;
61 import org.junit.ClassRule;
62 import org.junit.Ignore;
63 import org.junit.Rule;
64 import org.junit.Test;
65 import org.junit.runner.RunWith;
66 
67 import java.util.Set;
68 import java.util.function.Function;
69 
70 @RunWith(BedsteadJUnit4.class)
71 public class ApplicationHiddenTest {
72     @ClassRule @Rule
73     public static final DeviceState sDeviceState = new DeviceState();
74 
75     private static final String LOG_TAG = ApplicationHiddenTest.class.getName();
76 
77     private static final Package SYSTEM_PACKAGE =
78             TestApis.packages().find("com.android.keychain");
79     private static final Package NON_EXISTING_PACKAGE =
80             TestApis.packages().find("non.existing.package");
81 
82     // TODO: All references to isApplicationHidden and setApplicationHidden which are not part of
83     //  the "act" step of the test should run through a Nene API, once those APIs are permission
84     //  accessible
85 
86     private static final IntentFilter sPackageAddedIntentFilter = new IntentFilter();
87     private static final IntentFilter sPackageRemovedIntentFilter = new IntentFilter();
88     static {
89         sPackageAddedIntentFilter.addAction(ACTION_PACKAGE_ADDED);
90         sPackageRemovedIntentFilter.addAction(ACTION_PACKAGE_REMOVED);
91         sPackageAddedIntentFilter.addDataScheme("package");
92         sPackageRemovedIntentFilter.addDataScheme("package");
93     }
94 
95     @Before
ensureSystemPackageInstalled()96     public void ensureSystemPackageInstalled() {
97         SYSTEM_PACKAGE.installExisting(TestApis.users().instrumented());
98         try {
99             SYSTEM_PACKAGE.installExisting(sDeviceState.dpc().user());
100         } catch (Exception e) {
101             // expected for non DPC states
102         }
103     }
104 
105     @CanSetPolicyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
isApplicationHidden_systemApp_isHidden_returnsTrue()106     public void isApplicationHidden_systemApp_isHidden_returnsTrue() {
107         try {
108             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
109                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
110                     true);
111 
112             assertThat(sDeviceState.dpc().devicePolicyManager().isApplicationHidden(
113                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName())).isTrue();
114         } finally {
115             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
116                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
117                     false);
118         }
119     }
120 
121     @CanSetPolicyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
isApplicationHidden_systemApp_isNotHidden_returnsFalse()122     public void isApplicationHidden_systemApp_isNotHidden_returnsFalse() {
123         try {
124             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
125                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
126                     false);
127 
128             assertThat(sDeviceState.dpc().devicePolicyManager().isApplicationHidden(
129                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName())).isFalse();
130         } finally {
131             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
132                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
133                     false);
134         }
135     }
136 
137     @CanSetPolicyTest(policy = ApplicationHiddenSystemOnly.class)
138     @EnsureTestAppInstalled
isApplicationHidden_notSystemApp_throwsException()139     public void isApplicationHidden_notSystemApp_throwsException() {
140         // Could be SecurityException or IllegalArgumentException
141         assertThrows(Exception.class, () -> sDeviceState.dpc().devicePolicyManager()
142                 .isApplicationHidden(sDeviceState.dpc().componentName(),
143                         sDeviceState.testApp().packageName()));
144     }
145 
146     @CannotSetPolicyTest(policy = ApplicationHidden.class)
147     @EnsureTestAppInstalled
isApplicationHidden_notPermitted_throwsException()148     public void isApplicationHidden_notPermitted_throwsException() {
149         // Could be SecurityException or IllegalArgumentException
150         assertThrows(Exception.class, () -> sDeviceState.dpc().devicePolicyManager()
151                 .isApplicationHidden(sDeviceState.dpc().componentName(),
152                         sDeviceState.testApp().packageName()));
153     }
154 
155     @CanSetPolicyTest(policy = ApplicationHidden.class)
156     @EnsureTestAppInstalled
isApplicationHidden_notSystemApp_isHidden_returnsTrue()157     public void isApplicationHidden_notSystemApp_isHidden_returnsTrue() {
158         try {
159             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
160                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
161                     true);
162 
163             assertThat(sDeviceState.dpc().devicePolicyManager().isApplicationHidden(
164                     sDeviceState.dpc().componentName(),
165                     sDeviceState.testApp().packageName())).isTrue();
166         } finally {
167             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
168                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
169                     false);
170         }
171     }
172 
173     @CanSetPolicyTest(policy = ApplicationHidden.class)
174     @EnsureTestAppInstalled
isApplicationHidden_notSystemApp_isNotHidden_returnsFalse()175     public void isApplicationHidden_notSystemApp_isNotHidden_returnsFalse() {
176         try {
177             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
178                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
179                     false);
180 
181             assertThat(sDeviceState.dpc().devicePolicyManager().isApplicationHidden(
182                     sDeviceState.dpc().componentName(),
183                     sDeviceState.testApp().packageName())).isFalse();
184         } finally {
185             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
186                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
187                     false);
188         }
189     }
190 
191     @PolicyAppliesTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
setApplicationHidden_systemApp_true_hidesApplication()192     public void setApplicationHidden_systemApp_true_hidesApplication() throws Exception {
193         try {
194             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
195                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
196                     false);
197 
198             try (BlockingBroadcastReceiver broadcastReceiver =
199                          sDeviceState.registerBroadcastReceiverForAllUsers(
200                                  sPackageRemovedIntentFilter,
201                                  isSchemeSpecificPart(SYSTEM_PACKAGE.packageName()))) {
202                 boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
203                         sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
204                         true);
205 
206                 assertThat(result).isTrue();
207                 broadcastReceiver.awaitForBroadcastOrFail();
208             }
209 
210             assertThat(SYSTEM_PACKAGE.installedOnUser()).isFalse();
211             assertThat(SYSTEM_PACKAGE.exists()).isTrue();
212         } finally {
213             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
214                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
215                     false);
216         }
217     }
218 
219     @PolicyDoesNotApplyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
setApplicationHidden_systemApp_true_applicationIsNotHidden()220     public void setApplicationHidden_systemApp_true_applicationIsNotHidden() throws Exception {
221         try {
222             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
223                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
224                     true);
225 
226             assertThat(SYSTEM_PACKAGE.installedOnUser()).isTrue();
227         } finally {
228             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
229                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
230                     false);
231         }
232     }
233 
234     @PolicyAppliesTest(policy = ApplicationHidden.class)
235     @EnsureTestAppInstalled
setApplicationHidden_nonSystemApp_true_hidesApplication()236     public void setApplicationHidden_nonSystemApp_true_hidesApplication() throws Exception {
237         try {
238             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
239                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
240                     false);
241 
242             try (BlockingBroadcastReceiver broadcastReceiver =
243                          sDeviceState.registerBroadcastReceiverForAllUsers(
244                                  sPackageRemovedIntentFilter,
245                                  isSchemeSpecificPart(sDeviceState.testApp().packageName()))) {
246 
247                 boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
248                         sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
249                         true);
250 
251                 assertThat(result).isTrue();
252                 broadcastReceiver.awaitForBroadcastOrFail();
253             }
254 
255             assertThat(sDeviceState.testApp().testApp().pkg().installedOnUser()).isFalse();
256             assertThat(sDeviceState.testApp().testApp().pkg().exists()).isTrue();
257         } finally {
258             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
259                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
260                     false);
261         }
262     }
263 
264     @PolicyAppliesTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
setApplicationHidden_systemApp_false_unHidesApplication()265     public void setApplicationHidden_systemApp_false_unHidesApplication() throws Exception {
266         try {
267             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
268                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
269                     true);
270 
271             try (BlockingBroadcastReceiver broadcastReceiver =
272                          sDeviceState.registerBroadcastReceiverForAllUsers(
273                                  sPackageAddedIntentFilter,
274                                  isSchemeSpecificPart(SYSTEM_PACKAGE.packageName()))) {
275 
276                 boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
277                         sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
278                         false);
279 
280                 assertThat(result).isTrue();
281                 broadcastReceiver.awaitForBroadcastOrFail();
282             }
283 
284             assertThat(SYSTEM_PACKAGE.installedOnUser()).isTrue();
285         } finally {
286             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
287                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
288                     false);
289         }
290     }
291 
292     @PolicyAppliesTest(policy = ApplicationHidden.class)
293     @EnsureTestAppInstalled
setApplicationHidden_nonSystemApp_false_unHidesApplication()294     public void setApplicationHidden_nonSystemApp_false_unHidesApplication() throws Exception {
295         try {
296             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
297                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
298                     true);
299 
300             try (BlockingBroadcastReceiver broadcastReceiver =
301                          sDeviceState.registerBroadcastReceiverForAllUsers(
302                                  sPackageAddedIntentFilter,
303                                  isSchemeSpecificPart(sDeviceState.testApp().packageName()))) {
304 
305                 boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
306                         sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
307                         false);
308 
309                 assertThat(result).isTrue();
310                 broadcastReceiver.awaitForBroadcastOrFail();
311             }
312 
313             assertThat(sDeviceState.testApp().testApp().pkg().installedOnUser()).isTrue();
314         } finally {
315             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
316                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
317                     false);
318         }
319     }
320 
321     @CanSetPolicyTest(policy = ApplicationHidden.class)
322     @RequireHasPolicyExemptApps
setApplicationHidden_nonSystemApp_policyExempt_doesNotHideApplication()323     public void setApplicationHidden_nonSystemApp_policyExempt_doesNotHideApplication() throws Exception {
324         Set<String> policyExemptApps = TestApis.devicePolicy().getPolicyExemptApps();
325 
326         for (String packageName : policyExemptApps) {
327             if (!TestApis.packages().find(packageName).installedOnUser()) {
328                 Log.i(LOG_TAG, "Skipping " + packageName + " as not installed on user");
329                 continue;
330             }
331             try {
332                 boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
333                         sDeviceState.dpc().componentName(), packageName,
334                         true);
335 
336                 assertWithMessage(
337                         "Should return false when trying to hide policy exempt app " + packageName)
338                         .that(result).isFalse();
339                 assertWithMessage(
340                         "Policy exempt app " + packageName + " should appear as installed")
341                         .that(TestApis.packages().find(packageName).installedOnUser()).isTrue();
342             } finally {
343                 sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
344                         sDeviceState.dpc().componentName(), packageName,
345                         false);
346             }
347         }
348     }
349 
350     @CannotSetPolicyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class}
351             , includeNonDeviceAdminStates = false)
setApplicationHidden_systemApp_notAllowed_throwsException()352     public void setApplicationHidden_systemApp_notAllowed_throwsException() {
353         try {
354             assertThrows(SecurityException.class,
355                     () -> sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
356                             sDeviceState.dpc().componentName(),
357                             SYSTEM_PACKAGE.packageName(), true));
358         } finally {
359             try {
360                 sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
361                         sDeviceState.dpc().componentName(),
362                         SYSTEM_PACKAGE.packageName(), false);
363             } catch (SecurityException ex) {
364                 // Expected on successful tests
365             }
366         }
367     }
368 
369     @CanSetPolicyTest(policy = ApplicationHiddenSystemOnly.class)
370     @EnsureTestAppInstalled
setApplicationHidden_nonSystemApp_throwsException()371     public void setApplicationHidden_nonSystemApp_throwsException() {
372         try {
373             // Could be SecurityException or IllegalArgumentException
374             assertThrows(Exception.class,
375                     () -> sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
376                             sDeviceState.dpc().componentName(),
377                             sDeviceState.testApp().packageName(), true));
378         } finally {
379             try {
380                 sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
381                                 sDeviceState.dpc().componentName(),
382                                 sDeviceState.testApp().packageName(), false);
383             } catch (Exception ex) {
384                 // Expected on success case
385             }
386         }
387     }
388 
389     @CanSetPolicyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
setApplicationHidden_true_logsEvent()390     public void setApplicationHidden_true_logsEvent() {
391         try (EnterpriseMetricsRecorder metrics = EnterpriseMetricsRecorder.create()) {
392             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
393                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
394                     true);
395 
396             MetricQueryBuilderSubject.assertThat(metrics.query()
397                     .whereType().isEqualTo(EventId.SET_APPLICATION_HIDDEN_VALUE)
398                     .whereAdminPackageName().isEqualTo(sDeviceState.dpc().packageName())
399                     .whereBoolean().isEqualTo(sDeviceState.dpc().isDelegate())
400                     .whereStrings().contains(SYSTEM_PACKAGE.packageName())
401                     .whereStrings().contains("hidden")
402                     .whereStrings().contains(sDeviceState.dpc().isParentInstance() ? "calledFromParent" : "notCalledFromParent")
403             ).wasLogged();
404         } finally {
405             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
406                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
407                     false);
408         }
409     }
410 
411     @CanSetPolicyTest(policy = {ApplicationHidden.class, ApplicationHiddenSystemOnly.class})
setApplicationHidden_false_logsEvent()412     public void setApplicationHidden_false_logsEvent() {
413         try (EnterpriseMetricsRecorder metrics = EnterpriseMetricsRecorder.create()) {
414             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
415                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
416                     false);
417 
418             MetricQueryBuilderSubject.assertThat(metrics.query()
419                             .whereType().isEqualTo(EventId.SET_APPLICATION_HIDDEN_VALUE)
420                             .whereAdminPackageName().isEqualTo(sDeviceState.dpc().packageName())
421                             .whereBoolean().isEqualTo(sDeviceState.dpc().isDelegate())
422                             .whereStrings().contains(SYSTEM_PACKAGE.packageName())
423                             .whereStrings().contains("not_hidden")
424                             .whereStrings().contains(sDeviceState.dpc().isParentInstance() ? "calledFromParent" : "notCalledFromParent")
425             ).wasLogged();
426         } finally {
427             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
428                     sDeviceState.dpc().componentName(), SYSTEM_PACKAGE.packageName(),
429                     false);
430         }
431     }
432 
433     @CanSetPolicyTest(policy = {ApplicationHidden.class})
setApplicationHidden_notInstalledPackage_returnsFalse()434     public void setApplicationHidden_notInstalledPackage_returnsFalse() {
435         try {
436             boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
437                     sDeviceState.dpc().componentName(), NON_EXISTING_PACKAGE.packageName(),
438                     true);
439 
440             assertThat(result).isFalse();
441         } finally {
442             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
443                     sDeviceState.dpc().componentName(), NON_EXISTING_PACKAGE.packageName(),
444                     false);
445         }
446     }
447 
448     @CanSetPolicyTest(policy = {ApplicationHidden.class})
449     @Ignore // No longer applicable for non-admins - need to add a permission/exemption
setApplicationHidden_deviceAdmin_returnsFalse()450     public void setApplicationHidden_deviceAdmin_returnsFalse() {
451         try {
452             boolean result = sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
453                     sDeviceState.dpc().componentName(), sDeviceState.dpcOnly().packageName(),
454                     true);
455 
456             assertThat(result).isFalse();
457         } finally {
458             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
459                     sDeviceState.dpc().componentName(), sDeviceState.dpcOnly().packageName(),
460                     false);
461         }
462     }
463 
464     @Test
465     @Postsubmit(reason = "new test")
466     @ApiTest(apis = {"android.app.admin.DevicePolicyManager#setApplicationHidden",
467             "android.app.admin.DevicePolicyManager#isApplicationHidden",
468             "android.app.admin.DevicePolicyManager#getDevicePolicyState"})
469     @PolicyAppliesTest(policy = ApplicationHidden.class)
470     @EnsureTestAppInstalled
getDevicePolicyState_setApplicationHidden_returnsPolicy()471     public void getDevicePolicyState_setApplicationHidden_returnsPolicy() {
472         try {
473             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
474                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
475                     /* applicationHidden= */ true);
476 
477             PolicyState<Boolean> policyState = PolicyEngineUtils.getBooleanPolicyState(
478                     new PackagePolicyKey(
479                             APPLICATION_HIDDEN_POLICY, sDeviceState.testApp().packageName()),
480                     TestApis.users().instrumented().userHandle());
481 
482             assertThat(policyState.getCurrentResolvedPolicy()).isTrue();
483         } finally {
484             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
485                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
486                     /* applicationHidden= */ false);
487         }
488     }
489 
490     @Test
491     @Postsubmit(reason = "new test")
492     @ApiTest(apis = {"android.app.admin.DevicePolicyManager#setApplicationHidden",
493             "android.app.admin.DevicePolicyManager#isApplicationHidden"})
494     // TODO: enable after adding the broadcast receiver to relevant test apps.
495 //    @PolicyAppliesTest(policy = ApplicationHidden.class)
496     @EnsureHasDeviceOwner(isPrimary = true)
497     @EnsureTestAppInstalled
policyUpdateReceiver_setApplicationHidden_receivedPolicySetBroadcast()498     public void policyUpdateReceiver_setApplicationHidden_receivedPolicySetBroadcast() {
499         try {
500             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
501                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
502                     /* applicationHidden= */ true);
503 
504             PolicySetResultUtils.assertPolicySetResultReceived(sDeviceState,
505                     APPLICATION_HIDDEN_POLICY,
506                     PolicyUpdateResult.RESULT_POLICY_SET, LOCAL_USER_ID, new Bundle());
507         } finally {
508             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
509                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
510                     /* applicationHidden= */ false);
511         }
512     }
513 
514     @Test
515     @Postsubmit(reason = "new test")
516     @ApiTest(apis = {"android.app.admin.DevicePolicyManager#setApplicationHidden",
517             "android.app.admin.DevicePolicyManager#isApplicationHidden",
518             "android.app.admin.DevicePolicyManager#getDevicePolicyState"})
519     @CanSetPolicyTest(policy = ApplicationHidden.class, singleTestOnly = true)
520     @EnsureTestAppInstalled
getDevicePolicyState_setApplicationHidden_returnsCorrectResolutionMechanism()521     public void getDevicePolicyState_setApplicationHidden_returnsCorrectResolutionMechanism() {
522         try {
523             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
524                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
525                     /* applicationHidden= */ true);
526 
527             PolicyState<Boolean> policyState = PolicyEngineUtils.getBooleanPolicyState(
528                     new PackagePolicyKey(
529                             APPLICATION_HIDDEN_POLICY, sDeviceState.testApp().packageName()),
530                     TestApis.users().instrumented().userHandle());
531 
532             assertThat(PolicyEngineUtils.getMostRestrictiveBooleanMechanism(policyState)
533                     .getMostToLeastRestrictiveValues()).isEqualTo(TRUE_MORE_RESTRICTIVE);
534         } finally {
535             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
536                     sDeviceState.dpc().componentName(), sDeviceState.testApp().packageName(),
537                     /* applicationHidden= */ false);
538         }
539     }
540 
541     @CanSetPolicyTest(policy = {ApplicationHidden.class})
542     @Ignore // Currently failing for admins as well, but also longer applicable for non-admins -
543     // need to add a permission/exemption
setApplicationHidden_deviceAdmin_notAddedToDevicePolicyState()544     public void setApplicationHidden_deviceAdmin_notAddedToDevicePolicyState() {
545         try {
546             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
547                     sDeviceState.dpc().componentName(), sDeviceState.dpcOnly().packageName(),
548                     true);
549 
550             PolicyState<Boolean> policyState = PolicyEngineUtils.getBooleanPolicyState(
551                     new PackagePolicyKey(
552                             APPLICATION_HIDDEN_POLICY, sDeviceState.dpcOnly().packageName()),
553                     TestApis.users().instrumented().userHandle());
554 
555             assertThat(policyState).isNull();
556         } finally {
557             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
558                     sDeviceState.dpc().componentName(), sDeviceState.dpcOnly().packageName(),
559                     false);
560         }
561     }
562 
563     @CanSetPolicyTest(policy = {ApplicationHidden.class})
564     @Ignore
setApplicationHidden_notInstalledPackage_notAddedToDevicePolicyState()565     public void setApplicationHidden_notInstalledPackage_notAddedToDevicePolicyState() {
566         try {
567             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
568                     sDeviceState.dpc().componentName(), NON_EXISTING_PACKAGE.packageName(),
569                     true);
570 
571             PolicyState<Boolean> policyState = PolicyEngineUtils.getBooleanPolicyState(
572                     new PackagePolicyKey(
573                             APPLICATION_HIDDEN_POLICY, NON_EXISTING_PACKAGE.packageName()),
574                     TestApis.users().instrumented().userHandle());
575 
576             assertThat(policyState).isNull();
577         } finally {
578             sDeviceState.dpc().devicePolicyManager().setApplicationHidden(
579                     sDeviceState.dpc().componentName(), NON_EXISTING_PACKAGE.packageName(),
580                     false);
581         }
582     }
583 
isSchemeSpecificPart(String part)584     private Function<Intent, Boolean> isSchemeSpecificPart(String part) {
585         return (intent) -> intent.getData() != null
586                 && intent.getData().getSchemeSpecificPart().equals(part);
587     }
588 }
589