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