• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2021 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.car.hiddenapitest;
18 
19 import static com.android.compatibility.common.util.ShellUtils.runShellCommand;
20 
21 import static com.google.common.truth.Truth.assertThat;
22 
23 import static org.junit.Assert.assertThrows;
24 import static org.junit.Assume.assumeTrue;
25 
26 import android.app.ActivityManager;
27 import android.car.Car;
28 import android.car.content.pm.CarPackageManager;
29 import android.car.extendedapitest.testbase.CarApiTestBase;
30 import android.content.pm.PackageManager;
31 import android.os.Build;
32 
33 import androidx.test.filters.SmallTest;
34 
35 import org.junit.After;
36 import org.junit.Before;
37 import org.junit.Test;
38 
39 import java.util.List;
40 
41 @SmallTest
42 public class DrivingSafetyRegionTest extends CarApiTestBase {
43     private static final String REGION1 = "com.android.car.test.drivingsafetyregion.1";
44     private static final String REGION2 = "com.android.car.test.drivingsafetyregion.2";
45     private static final String REGION3 = "com.android.car.test.drivingsafetyregion.3";
46 
47     private static final String TEST_PACKAGE_NAME = "android.car.hiddenapitest";
48 
49     private CarPackageManager mCarPackageManager;
50     private String mOriginalDrivingSafetyRegion = null;
51 
52     private final int mCurrentUser = ActivityManager.getCurrentUser();
53 
54     @Before
setUp()55     public void setUp() {
56         mCarPackageManager = (CarPackageManager) getCar().getCarManager(Car.PACKAGE_SERVICE);
57 
58         assertThat(mCarPackageManager).isNotNull();
59 
60         mOriginalDrivingSafetyRegion = mCarPackageManager.getCurrentDrivingSafetyRegion();
61 
62         assertThat(mOriginalDrivingSafetyRegion).isNotNull();
63 
64         // cannot run this in user build as region change is not allowed in user build for shell.
65         assumeTrue(Build.IS_ENG || Build.IS_USERDEBUG);
66     }
67 
68     @After
tearDown()69     public void tearDown() {
70         if (mOriginalDrivingSafetyRegion != null) {
71             setDrivingSafetyRegion(mOriginalDrivingSafetyRegion);
72         }
73     }
74 
75     @Test
testImplicitAllRegions()76     public void testImplicitAllRegions() throws Exception {
77         doTestAllRegions(TestDrivingSafetyAllRegionActivity.class.getName());
78     }
79 
80     @Test
testExplicitAllRegions()81     public void testExplicitAllRegions() throws Exception {
82         doTestAllRegions(TestDrivingSafetyExplicitAllRegionsActivity.class.getName());
83     }
84 
doTestAllRegions(String activityClassName)85     private void doTestAllRegions(String activityClassName) throws Exception {
86         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
87                 activityClassName)).isTrue();
88 
89         List<String> regions = mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
90                 TEST_PACKAGE_NAME, activityClassName, ActivityManager.getCurrentUser());
91 
92         assertThat(regions).containsExactly(CarPackageManager.DRIVING_SAFETY_REGION_ALL);
93 
94         // all region app should be safe always regardless of bypassing / region change
95         setDrivingSafetyRegion(REGION1);
96 
97         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
98                 activityClassName)).isTrue();
99 
100         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
101                 activityClassName, true, mCurrentUser);
102 
103         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
104                 activityClassName)).isTrue();
105 
106         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
107                 activityClassName, false, mCurrentUser);
108 
109         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
110                 activityClassName)).isTrue();
111     }
112 
113     @Test
testOneRegionOnly()114     public void testOneRegionOnly() throws Exception {
115         String activityClassName = TestDrivingSafetyOneRegionActivity.class.getName();
116 
117         List<String> regions = mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
118                 TEST_PACKAGE_NAME, activityClassName, ActivityManager.getCurrentUser());
119 
120         assertThat(regions).containsExactly(REGION1);
121 
122         setDrivingSafetyRegion(REGION1);
123 
124         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
125                 activityClassName)).isTrue();
126 
127         setDrivingSafetyRegion(REGION2);
128 
129         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
130                 activityClassName)).isFalse();
131 
132         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
133                 activityClassName, true, mCurrentUser);
134 
135         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
136                 activityClassName)).isTrue();
137 
138         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
139                 activityClassName, false, mCurrentUser);
140 
141         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
142                 activityClassName)).isFalse();
143 
144         setDrivingSafetyRegion(CarPackageManager.DRIVING_SAFETY_REGION_ALL);
145 
146         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
147                 activityClassName)).isTrue();
148     }
149 
150     @Test
testTwoRegionsOnly()151     public void testTwoRegionsOnly() throws Exception {
152         String activityClassName = TestDrivingSafetyTwoRegionsActivity.class.getName();
153 
154         List<String> regions = mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
155                 TEST_PACKAGE_NAME, activityClassName, ActivityManager.getCurrentUser());
156 
157         assertThat(regions).containsExactly(REGION1, REGION2);
158 
159         setDrivingSafetyRegion(REGION1);
160 
161         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
162                 activityClassName)).isTrue();
163 
164         setDrivingSafetyRegion(REGION2);
165 
166         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
167                 activityClassName)).isTrue();
168 
169         setDrivingSafetyRegion(REGION3);
170 
171         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
172                 activityClassName)).isFalse();
173 
174         setDrivingSafetyRegion(CarPackageManager.DRIVING_SAFETY_REGION_ALL);
175 
176         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
177                 activityClassName)).isTrue();
178     }
179 
180     @Test
testRegion1OnlyActivity()181     public void testRegion1OnlyActivity() throws Exception {
182         doTestRegionOnlyOrNoRegionCase(TestDrivingSafetyRegion1OnlyActivity.class.getName());
183     }
184 
185     @Test
testRegionAllOnlyActivity()186     public void testRegionAllOnlyActivity() throws Exception {
187         doTestRegionOnlyOrNoRegionCase(TestDrivingSafetyRegionAllOnlyActivity.class.getName());
188     }
189 
190     @Test
testRegionNoMetadataActivity()191     public void testRegionNoMetadataActivity() throws Exception {
192         doTestRegionOnlyOrNoRegionCase(TestDrivingSafetyRegionNoMetadataActivity.class.getName());
193     }
194 
doTestRegionOnlyOrNoRegionCase(String activityClassName)195     private void doTestRegionOnlyOrNoRegionCase(String activityClassName) throws Exception {
196         List<String> regions = mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
197                 TEST_PACKAGE_NAME, activityClassName, ActivityManager.getCurrentUser());
198 
199         // not distraction optimized, so list should be empty.
200         assertThat(regions).isEmpty();
201 
202         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
203                 activityClassName)).isFalse();
204 
205         // should not be safe for any region.
206         setDrivingSafetyRegion(CarPackageManager.DRIVING_SAFETY_REGION_ALL);
207 
208         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
209                 activityClassName)).isFalse();
210 
211         setDrivingSafetyRegion(REGION1);
212 
213         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
214                 activityClassName)).isFalse();
215 
216         setDrivingSafetyRegion(REGION2);
217 
218         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
219                 activityClassName)).isFalse();
220 
221         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
222                 activityClassName, true, mCurrentUser);
223 
224         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
225                 activityClassName)).isTrue();
226 
227         mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(TEST_PACKAGE_NAME,
228                 activityClassName, false, mCurrentUser);
229 
230         assertThat(mCarPackageManager.isActivityDistractionOptimized(TEST_PACKAGE_NAME,
231                 activityClassName)).isFalse();
232     }
233 
234     @Test
testNoPackage()235     public void testNoPackage() {
236         String noPkg = "NoSuchPackage";
237 
238         assertThrows(PackageManager.NameNotFoundException.class,
239                 () -> mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
240                         noPkg, "", mCurrentUser));
241 
242         assertThrows(PackageManager.NameNotFoundException.class,
243                 () -> mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(
244                         noPkg, "", true, mCurrentUser));
245     }
246 
247     @Test
testNoActivity()248     public void testNoActivity() {
249         String noSuchActivity = "NoSuchActivity";
250 
251         assertThrows(PackageManager.NameNotFoundException.class,
252                 () -> mCarPackageManager.getSupportedDrivingSafetyRegionsForActivityAsUser(
253                         TEST_PACKAGE_NAME, noSuchActivity, mCurrentUser));
254 
255         assertThrows(PackageManager.NameNotFoundException.class,
256                 () -> mCarPackageManager.controlTemporaryActivityBlockingBypassingAsUser(
257                         TEST_PACKAGE_NAME, noSuchActivity, true, mCurrentUser));
258     }
259 
260     @Test
testResetEmptyRegion()261     public void testResetEmptyRegion() {
262         setDrivingSafetyRegion(REGION1);
263 
264         assertThat(mCarPackageManager.getCurrentDrivingSafetyRegion()).isEqualTo(REGION1);
265 
266         // no arg means all
267         runShellCommand("cmd car_service set-drivingsafety-region");
268 
269         assertThat(mCarPackageManager.getCurrentDrivingSafetyRegion()).isEqualTo(
270                 CarPackageManager.DRIVING_SAFETY_REGION_ALL);
271     }
272 
setDrivingSafetyRegion(String region)273     private void setDrivingSafetyRegion(String region) {
274         runShellCommand("cmd car_service set-drivingsafety-region  " + region);
275     }
276 }
277