• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2015 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.server.pm.permission;
18 
19 import static android.os.Process.FIRST_APPLICATION_UID;
20 
21 import android.Manifest;
22 import android.annotation.NonNull;
23 import android.annotation.Nullable;
24 import android.annotation.UserIdInt;
25 import android.app.ActivityManager;
26 import android.app.DownloadManager;
27 import android.app.SearchManager;
28 import android.app.admin.DevicePolicyManager;
29 import android.content.Context;
30 import android.content.Intent;
31 import android.content.pm.ApplicationInfo;
32 import android.content.pm.PackageInfo;
33 import android.content.pm.PackageManager;
34 import android.content.pm.PackageManager.NameNotFoundException;
35 import android.content.pm.PackageManagerInternal;
36 import android.content.pm.PermissionInfo;
37 import android.content.pm.ProviderInfo;
38 import android.content.pm.ResolveInfo;
39 import android.health.connect.HealthPermissions;
40 import android.media.RingtoneManager;
41 import android.media.midi.MidiManager;
42 import android.net.Uri;
43 import android.os.Build;
44 import android.os.Environment;
45 import android.os.Handler;
46 import android.os.HandlerThread;
47 import android.os.Message;
48 import android.os.Process;
49 import android.os.UserHandle;
50 import android.os.storage.StorageManager;
51 import android.permission.PermissionManager;
52 import android.permission.flags.Flags;
53 import android.print.PrintManager;
54 import android.provider.CalendarContract;
55 import android.provider.ContactsContract;
56 import android.provider.MediaStore;
57 import android.provider.Telephony.Sms.Intents;
58 import android.security.Credentials;
59 import android.speech.RecognitionService;
60 import android.telephony.TelephonyManager;
61 import android.util.ArrayMap;
62 import android.util.ArraySet;
63 import android.util.Log;
64 import android.util.Slog;
65 import android.util.SparseArray;
66 import android.util.Xml;
67 
68 import com.android.internal.R;
69 import com.android.internal.pm.pkg.parsing.ParsingPackageUtils;
70 import com.android.internal.util.ArrayUtils;
71 import com.android.internal.util.XmlUtils;
72 import com.android.modules.utils.TypedXmlPullParser;
73 import com.android.server.LocalServices;
74 import com.android.server.ServiceThread;
75 import com.android.server.pm.KnownPackages;
76 import com.android.server.pm.permission.LegacyPermissionManagerInternal.PackagesProvider;
77 import com.android.server.pm.permission.LegacyPermissionManagerInternal.SyncAdapterPackagesProvider;
78 
79 import libcore.util.HexEncoding;
80 
81 import org.xmlpull.v1.XmlPullParser;
82 import org.xmlpull.v1.XmlPullParserException;
83 
84 import java.io.File;
85 import java.io.FileInputStream;
86 import java.io.IOException;
87 import java.io.InputStream;
88 import java.util.ArrayList;
89 import java.util.Arrays;
90 import java.util.Collections;
91 import java.util.List;
92 import java.util.Map;
93 import java.util.Objects;
94 import java.util.Set;
95 
96 /**
97  * This class is the policy for granting runtime permissions to
98  * platform components and default handlers in the system such
99  * that the device is usable out-of-the-box. For example, the
100  * shell UID is a part of the system and the Phone app should
101  * have phone related permission by default.
102  * <p>
103  * NOTE: This class is at the wrong abstraction level. It is a part of the package manager
104  * service but knows about lots of higher level subsystems. The correct way to do this is
105  * to have an interface defined in the package manager but have the impl next to other
106  * policy stuff like PhoneWindowManager
107  */
108 final class DefaultPermissionGrantPolicy {
109     private static final String TAG = "DefaultPermGrantPolicy"; // must be <= 23 chars
110     private static final boolean DEBUG = false;
111 
112     @PackageManager.ResolveInfoFlagsBits
113     private static final int DEFAULT_INTENT_QUERY_FLAGS =
114             PackageManager.MATCH_DIRECT_BOOT_AWARE | PackageManager.MATCH_DIRECT_BOOT_UNAWARE
115                     | PackageManager.MATCH_UNINSTALLED_PACKAGES;
116 
117     @PackageManager.PackageInfoFlagsBits
118     private static final int DEFAULT_PACKAGE_INFO_QUERY_FLAGS =
119             PackageManager.MATCH_UNINSTALLED_PACKAGES
120                     | PackageManager.MATCH_DISABLED_UNTIL_USED_COMPONENTS
121                     | PackageManager.MATCH_HIDDEN_UNTIL_INSTALLED_COMPONENTS
122                     | PackageManager.GET_PERMISSIONS;
123 
124     private static final String AUDIO_MIME_TYPE = "audio/mpeg";
125 
126     private static final String TAG_EXCEPTIONS = "exceptions";
127     private static final String TAG_EXCEPTION = "exception";
128     private static final String TAG_PERMISSION = "permission";
129     private static final String ATTR_PACKAGE = "package";
130     private static final String ATTR_NAME = "name";
131     private static final String ATTR_FIXED = "fixed";
132     private static final String ATTR_WHITELISTED = "whitelisted";
133     private static final String ATTR_CERT = "cert";
134 
135     private static final Set<String> PHONE_PERMISSIONS = new ArraySet<>();
136 
137 
138     static {
139         PHONE_PERMISSIONS.add(Manifest.permission.READ_PHONE_STATE);
140         PHONE_PERMISSIONS.add(Manifest.permission.CALL_PHONE);
141         PHONE_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);
142         PHONE_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);
143         PHONE_PERMISSIONS.add(Manifest.permission.ADD_VOICEMAIL);
144         PHONE_PERMISSIONS.add(Manifest.permission.USE_SIP);
145         PHONE_PERMISSIONS.add(Manifest.permission.PROCESS_OUTGOING_CALLS);
146     }
147 
148     private static final Set<String> CONTACTS_PERMISSIONS = new ArraySet<>();
149     static {
150         CONTACTS_PERMISSIONS.add(Manifest.permission.READ_CONTACTS);
151         CONTACTS_PERMISSIONS.add(Manifest.permission.WRITE_CONTACTS);
152         CONTACTS_PERMISSIONS.add(Manifest.permission.GET_ACCOUNTS);
153     }
154 
155     private static final Set<String> CALL_LOG_PERMISSIONS = new ArraySet<>();
156     static {
157         CALL_LOG_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);
158         CALL_LOG_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);
159     }
160 
161 
162     private static final Set<String> ALWAYS_LOCATION_PERMISSIONS = new ArraySet<>();
163     static {
164         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
165         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
166         ALWAYS_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_BACKGROUND_LOCATION);
167     }
168 
169     private static final Set<String> FOREGROUND_LOCATION_PERMISSIONS = new ArraySet<>();
170     static {
171         FOREGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
172         FOREGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
173     }
174 
175     private static final Set<String> COARSE_BACKGROUND_LOCATION_PERMISSIONS = new ArraySet<>();
176     static {
177         COARSE_BACKGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
178         COARSE_BACKGROUND_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_BACKGROUND_LOCATION);
179     }
180 
181     private static final Set<String> FINE_LOCATION_PERMISSIONS = new ArraySet<>();
182     static {
183         FINE_LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
184     }
185 
186     private static final Set<String> ACTIVITY_RECOGNITION_PERMISSIONS = new ArraySet<>();
187     static {
188         ACTIVITY_RECOGNITION_PERMISSIONS.add(Manifest.permission.ACTIVITY_RECOGNITION);
189     }
190 
191     private static final Set<String> CALENDAR_PERMISSIONS = new ArraySet<>();
192     static {
193         CALENDAR_PERMISSIONS.add(Manifest.permission.READ_CALENDAR);
194         CALENDAR_PERMISSIONS.add(Manifest.permission.WRITE_CALENDAR);
195     }
196 
197     private static final Set<String> SMS_PERMISSIONS = new ArraySet<>();
198     static {
199         SMS_PERMISSIONS.add(Manifest.permission.SEND_SMS);
200         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_SMS);
201         SMS_PERMISSIONS.add(Manifest.permission.READ_SMS);
202         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_WAP_PUSH);
203         SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_MMS);
204         SMS_PERMISSIONS.add(Manifest.permission.READ_CELL_BROADCASTS);
205     }
206 
207     private static final Set<String> MICROPHONE_PERMISSIONS = new ArraySet<>();
208     static {
209         MICROPHONE_PERMISSIONS.add(Manifest.permission.RECORD_AUDIO);
210     }
211 
212     private static final Set<String> CAMERA_PERMISSIONS = new ArraySet<>();
213     static {
214         CAMERA_PERMISSIONS.add(Manifest.permission.CAMERA);
215     }
216 
217     private static final Set<String> SENSORS_PERMISSIONS = new ArraySet<>();
218     static {
219         SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS);
220         SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS_BACKGROUND);
221 
222         if (Flags.replaceBodySensorPermissionEnabled()) {
223             SENSORS_PERMISSIONS.add(HealthPermissions.READ_HEART_RATE);
224             SENSORS_PERMISSIONS.add(HealthPermissions.READ_HEALTH_DATA_IN_BACKGROUND);
225         }
226     }
227 
228     private static final Set<String> STORAGE_PERMISSIONS = new ArraySet<>();
229     static {
230         STORAGE_PERMISSIONS.add(Manifest.permission.READ_EXTERNAL_STORAGE);
231         STORAGE_PERMISSIONS.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
232         STORAGE_PERMISSIONS.add(Manifest.permission.ACCESS_MEDIA_LOCATION);
233         STORAGE_PERMISSIONS.add(Manifest.permission.READ_MEDIA_AUDIO);
234         STORAGE_PERMISSIONS.add(Manifest.permission.READ_MEDIA_VIDEO);
235         STORAGE_PERMISSIONS.add(Manifest.permission.READ_MEDIA_IMAGES);
236         STORAGE_PERMISSIONS.add(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED);
237     }
238 
239     private static final Set<String> NEARBY_DEVICES_PERMISSIONS = new ArraySet<>();
240     static {
241         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_ADVERTISE);
242         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_CONNECT);
243         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.BLUETOOTH_SCAN);
244         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.UWB_RANGING);
245         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.NEARBY_WIFI_DEVICES);
246         NEARBY_DEVICES_PERMISSIONS.add(Manifest.permission.RANGING);
247     }
248 
249     private static final Set<String> NOTIFICATION_PERMISSIONS = new ArraySet<>();
250     static {
251         NOTIFICATION_PERMISSIONS.add(Manifest.permission.POST_NOTIFICATIONS);
252     }
253 
254     private static final int MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS = 1;
255 
256     private static final String ACTION_TRACK = "com.android.fitness.TRACK";
257 
258     private final Handler mHandler;
259 
260     private PackagesProvider mLocationPackagesProvider;
261     private PackagesProvider mLocationExtraPackagesProvider;
262     private PackagesProvider mVoiceInteractionPackagesProvider;
263     private PackagesProvider mSmsAppPackagesProvider;
264     private PackagesProvider mDialerAppPackagesProvider;
265     private PackagesProvider mSimCallManagerPackagesProvider;
266     private PackagesProvider mUseOpenWifiAppPackagesProvider;
267     private SyncAdapterPackagesProvider mSyncAdapterPackagesProvider;
268 
269     private ArrayMap<String, List<DefaultPermissionGrant>> mGrantExceptions;
270     private final Context mContext;
271     private final Object mLock = new Object();
272     private final PackageManagerInternal mServiceInternal;
273 
274     /** Directly interact with the PackageManger */
275     private final PackageManagerWrapper NO_PM_CACHE = new PackageManagerWrapper() {
276         @Override
277         public int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
278                 @NonNull UserHandle user) {
279             return mContext.getPackageManager().getPermissionFlags(permission, pkg.packageName,
280                     user);
281         }
282 
283         @Override
284         public void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
285                 int flagMask, int flagValues, @NonNull UserHandle user) {
286             mContext.getPackageManager().updatePermissionFlags(permission, pkg.packageName,
287                     flagMask, flagValues, user);
288         }
289 
290         @Override
291         public void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
292                 @NonNull UserHandle user) {
293             mContext.getPackageManager().grantRuntimePermission(pkg.packageName, permission,
294                     user);
295         }
296 
297         @Override
298         public void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
299                 @NonNull UserHandle user) {
300             mContext.getPackageManager().revokeRuntimePermission(pkg.packageName, permission,
301                     user);
302         }
303 
304         @Override
305         public boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
306                 @NonNull UserHandle user) {
307             return mContext.createContextAsUser(user, 0).getPackageManager().checkPermission(
308                     permission, pkg.packageName) == PackageManager.PERMISSION_GRANTED;
309         }
310 
311         @Override
312         public @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName) {
313             if (permissionName == null) {
314                 return null;
315             }
316 
317             try {
318                 return mContext.getPackageManager().getPermissionInfo(permissionName, 0);
319             } catch (NameNotFoundException e) {
320                 Slog.w(TAG, "Permission not found: " + permissionName);
321                 return null;
322             }
323         }
324 
325         @Override
326         public @Nullable PackageInfo getPackageInfo(@NonNull String pkg) {
327             if (pkg == null) {
328                 return null;
329             }
330 
331             try {
332                 return mContext.getPackageManager().getPackageInfo(pkg,
333                         DEFAULT_PACKAGE_INFO_QUERY_FLAGS);
334             } catch (NameNotFoundException e) {
335                 Slog.e(TAG, "Package not found: " + pkg);
336                 return null;
337             }
338         }
339     };
340 
DefaultPermissionGrantPolicy(@onNull Context context)341     DefaultPermissionGrantPolicy(@NonNull Context context) {
342         mContext = context;
343         HandlerThread handlerThread = new ServiceThread(TAG,
344                 Process.THREAD_PRIORITY_BACKGROUND, true /*allowIo*/);
345         handlerThread.start();
346         mHandler = new Handler(handlerThread.getLooper()) {
347             @Override
348             public void handleMessage(Message msg) {
349                 if (msg.what == MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS) {
350                     synchronized (mLock) {
351                         if (mGrantExceptions == null) {
352                             mGrantExceptions = readDefaultPermissionExceptionsLocked(NO_PM_CACHE);
353                         }
354                     }
355                 }
356             }
357         };
358         mServiceInternal = LocalServices.getService(PackageManagerInternal.class);
359     }
360 
setLocationPackagesProvider(PackagesProvider provider)361     public void setLocationPackagesProvider(PackagesProvider provider) {
362         synchronized (mLock) {
363             mLocationPackagesProvider = provider;
364         }
365     }
366 
367     /** Sets the provider for loction extra packages. */
setLocationExtraPackagesProvider(PackagesProvider provider)368     public void setLocationExtraPackagesProvider(PackagesProvider provider) {
369         synchronized (mLock) {
370             mLocationExtraPackagesProvider = provider;
371         }
372     }
373 
setVoiceInteractionPackagesProvider(PackagesProvider provider)374     public void setVoiceInteractionPackagesProvider(PackagesProvider provider) {
375         synchronized (mLock) {
376             mVoiceInteractionPackagesProvider = provider;
377         }
378     }
379 
setSmsAppPackagesProvider(PackagesProvider provider)380     public void setSmsAppPackagesProvider(PackagesProvider provider) {
381         synchronized (mLock) {
382             mSmsAppPackagesProvider = provider;
383         }
384     }
385 
setDialerAppPackagesProvider(PackagesProvider provider)386     public void setDialerAppPackagesProvider(PackagesProvider provider) {
387         synchronized (mLock) {
388             mDialerAppPackagesProvider = provider;
389         }
390     }
391 
setSimCallManagerPackagesProvider(PackagesProvider provider)392     public void setSimCallManagerPackagesProvider(PackagesProvider provider) {
393         synchronized (mLock) {
394             mSimCallManagerPackagesProvider = provider;
395         }
396     }
397 
setUseOpenWifiAppPackagesProvider(PackagesProvider provider)398     public void setUseOpenWifiAppPackagesProvider(PackagesProvider provider) {
399         synchronized (mLock) {
400             mUseOpenWifiAppPackagesProvider = provider;
401         }
402     }
403 
setSyncAdapterPackagesProvider(SyncAdapterPackagesProvider provider)404     public void setSyncAdapterPackagesProvider(SyncAdapterPackagesProvider provider) {
405         synchronized (mLock) {
406             mSyncAdapterPackagesProvider = provider;
407         }
408     }
409 
grantDefaultPermissions(int userId)410     public void grantDefaultPermissions(int userId) {
411         DelayingPackageManagerCache pm = new DelayingPackageManagerCache();
412 
413         grantPermissionsToSysComponentsAndPrivApps(pm, userId);
414         grantDefaultSystemHandlerPermissions(pm, userId);
415         grantSignatureAppsNotificationPermissions(pm, userId);
416         grantDefaultPermissionExceptions(pm, userId);
417 
418         // Apply delayed state
419         pm.apply();
420     }
421 
grantSignatureAppsNotificationPermissions(PackageManagerWrapper pm, int userId)422     private void grantSignatureAppsNotificationPermissions(PackageManagerWrapper pm, int userId) {
423         Log.i(TAG, "Granting Notification permissions to platform signature apps for user "
424                 + userId);
425         List<PackageInfo> packages = mContext.getPackageManager().getInstalledPackagesAsUser(
426                 DEFAULT_PACKAGE_INFO_QUERY_FLAGS, UserHandle.USER_SYSTEM);
427         for (PackageInfo pkg : packages) {
428             if (pkg == null || !pkg.applicationInfo.isSystemApp()
429                     || !pkg.applicationInfo.isSignedWithPlatformKey()) {
430                 continue;
431             }
432             grantRuntimePermissionsForSystemPackage(pm, userId, pkg, NOTIFICATION_PERMISSIONS);
433         }
434 
435     }
436 
grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm, int userId, PackageInfo pkg)437     private void grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm,
438             int userId, PackageInfo pkg) {
439         grantRuntimePermissionsForSystemPackage(pm, userId, pkg, null);
440     }
441 
grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm, int userId, PackageInfo pkg, Set<String> filterPermissions)442     private void grantRuntimePermissionsForSystemPackage(PackageManagerWrapper pm,
443             int userId, PackageInfo pkg, Set<String> filterPermissions) {
444         if (ArrayUtils.isEmpty(pkg.requestedPermissions)) {
445             return;
446         }
447         Set<String> permissions = new ArraySet<>();
448         for (String permission : pkg.requestedPermissions) {
449             final PermissionInfo perm = pm.getPermissionInfo(permission);
450             if (perm == null
451                     || (filterPermissions != null && !filterPermissions.contains(permission))) {
452                 continue;
453             }
454             if (perm.isRuntime()) {
455                 permissions.add(permission);
456             }
457         }
458         if (!permissions.isEmpty()) {
459             grantRuntimePermissions(pm, pkg, permissions, true /*systemFixed*/, userId);
460         }
461     }
462 
scheduleReadDefaultPermissionExceptions()463     public void scheduleReadDefaultPermissionExceptions() {
464         mHandler.sendEmptyMessage(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);
465     }
466 
grantPermissionsToSysComponentsAndPrivApps(DelayingPackageManagerCache pm, int userId)467     private void grantPermissionsToSysComponentsAndPrivApps(DelayingPackageManagerCache pm,
468             int userId) {
469         Log.i(TAG, "Granting permissions to platform components for user " + userId);
470         List<PackageInfo> packages = mContext.getPackageManager().getInstalledPackagesAsUser(
471                 DEFAULT_PACKAGE_INFO_QUERY_FLAGS, UserHandle.USER_SYSTEM);
472         for (PackageInfo pkg : packages) {
473             if (pkg == null) {
474                 continue;
475             }
476 
477             // Package info is already loaded, cache it
478             pm.addPackageInfo(pkg.packageName, pkg);
479 
480             if (!pm.isSysComponentOrPersistentPlatformSignedPrivApp(pkg)
481                     || !doesPackageSupportRuntimePermissions(pkg)
482                     || ArrayUtils.isEmpty(pkg.requestedPermissions)) {
483                 continue;
484             }
485             grantRuntimePermissionsForSystemPackage(pm, userId, pkg);
486         }
487 
488         // Re-grant READ_PHONE_STATE as non-fixed to all system apps that have
489         // READ_PRIVILEGED_PHONE_STATE and READ_PHONE_STATE granted -- this is to undo the fixed
490         // grant from R.
491         for (PackageInfo pkg : packages) {
492             if (pkg == null
493                     || !doesPackageSupportRuntimePermissions(pkg)
494                     || ArrayUtils.isEmpty(pkg.requestedPermissions)
495                     || !pm.isGranted(Manifest.permission.READ_PRIVILEGED_PHONE_STATE,
496                             pkg, UserHandle.of(userId))
497                     || !pm.isGranted(Manifest.permission.READ_PHONE_STATE, pkg,
498                             UserHandle.of(userId))
499                     || pm.isSysComponentOrPersistentPlatformSignedPrivApp(pkg)) {
500                 continue;
501             }
502 
503             pm.updatePermissionFlags(Manifest.permission.READ_PHONE_STATE, pkg,
504                     PackageManager.FLAG_PERMISSION_SYSTEM_FIXED,
505                     0,
506                     UserHandle.of(userId));
507         }
508 
509     }
510 
511     @SafeVarargs
grantIgnoringSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)512     private final void grantIgnoringSystemPackage(PackageManagerWrapper pm, String packageName,
513             int userId, Set<String>... permissionGroups) {
514         grantPermissionsToPackage(pm, packageName, userId, true /* ignoreSystemPackage */,
515                 true /*whitelistRestrictedPermissions*/, permissionGroups);
516     }
517 
518     @SafeVarargs
grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)519     private final void grantSystemFixedPermissionsToSystemPackage(PackageManagerWrapper pm,
520             String packageName, int userId, Set<String>... permissionGroups) {
521         grantPermissionsToSystemPackage(pm, packageName, userId, true /* systemFixed */,
522                 permissionGroups);
523     }
524 
525     @SafeVarargs
grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, Set<String>... permissionGroups)526     private final void grantPermissionsToSystemPackage(PackageManagerWrapper pm,
527             String packageName, int userId, Set<String>... permissionGroups) {
528         grantPermissionsToSystemPackage(pm, packageName, userId, false /* systemFixed */,
529                 permissionGroups);
530     }
531 
532     @SafeVarargs
grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName, int userId, boolean systemFixed, Set<String>... permissionGroups)533     private final void grantPermissionsToSystemPackage(PackageManagerWrapper pm, String packageName,
534             int userId, boolean systemFixed, Set<String>... permissionGroups) {
535         if (!pm.isSystemPackage(packageName)) {
536             return;
537         }
538         grantPermissionsToPackage(pm, pm.getSystemPackageInfo(packageName),
539                 userId, systemFixed, false /* ignoreSystemPackage */,
540                 true /*whitelistRestrictedPermissions*/, permissionGroups);
541     }
542 
543     @SafeVarargs
grantPermissionsToPackage(PackageManagerWrapper pm, String packageName, int userId, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, Set<String>... permissionGroups)544     private final void grantPermissionsToPackage(PackageManagerWrapper pm, String packageName,
545             int userId, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions,
546             Set<String>... permissionGroups) {
547         grantPermissionsToPackage(pm, pm.getPackageInfo(packageName),
548                 userId, false /* systemFixed */, ignoreSystemPackage,
549                 whitelistRestrictedPermissions, permissionGroups);
550     }
551 
552     @SafeVarargs
grantPermissionsToPackage(PackageManagerWrapper pm, PackageInfo packageInfo, int userId, boolean systemFixed, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, Set<String>... permissionGroups)553     private final void grantPermissionsToPackage(PackageManagerWrapper pm, PackageInfo packageInfo,
554             int userId, boolean systemFixed, boolean ignoreSystemPackage,
555             boolean whitelistRestrictedPermissions, Set<String>... permissionGroups) {
556         if (packageInfo == null) {
557             return;
558         }
559         if (doesPackageSupportRuntimePermissions(packageInfo)) {
560             for (Set<String> permissionGroup : permissionGroups) {
561                 grantRuntimePermissions(pm, packageInfo, permissionGroup, systemFixed,
562                         ignoreSystemPackage, whitelistRestrictedPermissions, userId);
563             }
564         }
565     }
566 
grantDefaultSystemHandlerPermissions(PackageManagerWrapper pm, int userId)567     private void grantDefaultSystemHandlerPermissions(PackageManagerWrapper pm, int userId) {
568         Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);
569 
570         final PackagesProvider locationPackagesProvider;
571         final PackagesProvider locationExtraPackagesProvider;
572         final PackagesProvider voiceInteractionPackagesProvider;
573         final PackagesProvider smsAppPackagesProvider;
574         final PackagesProvider dialerAppPackagesProvider;
575         final PackagesProvider simCallManagerPackagesProvider;
576         final PackagesProvider useOpenWifiAppPackagesProvider;
577         final SyncAdapterPackagesProvider syncAdapterPackagesProvider;
578 
579         synchronized (mLock) {
580             locationPackagesProvider = mLocationPackagesProvider;
581             locationExtraPackagesProvider = mLocationExtraPackagesProvider;
582             voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;
583             smsAppPackagesProvider = mSmsAppPackagesProvider;
584             dialerAppPackagesProvider = mDialerAppPackagesProvider;
585             simCallManagerPackagesProvider = mSimCallManagerPackagesProvider;
586             useOpenWifiAppPackagesProvider = mUseOpenWifiAppPackagesProvider;
587             syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;
588         }
589 
590         String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)
591                 ? voiceInteractionPackagesProvider.getPackages(userId) : null;
592         String[] locationPackageNames = (locationPackagesProvider != null)
593                 ? locationPackagesProvider.getPackages(userId) : null;
594         String[] locationExtraPackageNames = (locationExtraPackagesProvider != null)
595                 ? locationExtraPackagesProvider.getPackages(userId) : null;
596         String[] smsAppPackageNames = (smsAppPackagesProvider != null)
597                 ? smsAppPackagesProvider.getPackages(userId) : null;
598         String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)
599                 ? dialerAppPackagesProvider.getPackages(userId) : null;
600         String[] simCallManagerPackageNames = (simCallManagerPackagesProvider != null)
601                 ? simCallManagerPackagesProvider.getPackages(userId) : null;
602         String[] useOpenWifiAppPackageNames = (useOpenWifiAppPackagesProvider != null)
603                 ? useOpenWifiAppPackagesProvider.getPackages(userId) : null;
604         String[] contactsSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
605                 syncAdapterPackagesProvider.getPackages(ContactsContract.AUTHORITY, userId) : null;
606         String[] calendarSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
607                 syncAdapterPackagesProvider.getPackages(CalendarContract.AUTHORITY, userId) : null;
608 
609         // PermissionController
610         grantSystemFixedPermissionsToSystemPackage(pm,
611                 mContext.getPackageManager().getPermissionControllerPackageName(), userId,
612                 NOTIFICATION_PERMISSIONS);
613 
614         // Installer
615         grantSystemFixedPermissionsToSystemPackage(pm,
616                 ArrayUtils.firstOrNull(getKnownPackages(
617                         KnownPackages.PACKAGE_INSTALLER, userId)),
618                 userId, STORAGE_PERMISSIONS, NOTIFICATION_PERMISSIONS);
619 
620         // Verifier
621         final String verifier = ArrayUtils.firstOrNull(getKnownPackages(
622                 KnownPackages.PACKAGE_VERIFIER, userId));
623         grantSystemFixedPermissionsToSystemPackage(pm, verifier, userId, STORAGE_PERMISSIONS);
624         grantPermissionsToSystemPackage(pm, verifier, userId, PHONE_PERMISSIONS, SMS_PERMISSIONS,
625                 NOTIFICATION_PERMISSIONS);
626 
627         // SetupWizard
628         final String setupWizardPackage = ArrayUtils.firstOrNull(getKnownPackages(
629                 KnownPackages.PACKAGE_SETUP_WIZARD, userId));
630         grantPermissionsToSystemPackage(pm, setupWizardPackage, userId, PHONE_PERMISSIONS,
631                 CONTACTS_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS, CAMERA_PERMISSIONS,
632                 NEARBY_DEVICES_PERMISSIONS);
633         grantSystemFixedPermissionsToSystemPackage(pm, setupWizardPackage, userId,
634                 NOTIFICATION_PERMISSIONS);
635 
636         // SearchSelector
637         grantPermissionsToSystemPackage(pm, getDefaultSearchSelectorPackage(), userId,
638                 NOTIFICATION_PERMISSIONS);
639 
640         // Captive Portal Login
641         grantPermissionsToSystemPackage(pm, getDefaultCaptivePortalLoginPackage(), userId,
642                 NOTIFICATION_PERMISSIONS);
643 
644         // Dock Manager
645         grantPermissionsToSystemPackage(pm, getDefaultDockManagerPackage(), userId,
646                 NOTIFICATION_PERMISSIONS);
647 
648         // Camera
649         grantPermissionsToSystemPackage(pm,
650                 getDefaultSystemHandlerActivityPackage(pm, MediaStore.ACTION_IMAGE_CAPTURE, userId),
651                 userId, CAMERA_PERMISSIONS, MICROPHONE_PERMISSIONS, STORAGE_PERMISSIONS);
652 
653         // Sound recorder
654         grantPermissionsToSystemPackage(pm,
655                 getDefaultSystemHandlerActivityPackage(pm,
656                         MediaStore.Audio.Media.RECORD_SOUND_ACTION, userId),
657                 userId, MICROPHONE_PERMISSIONS);
658 
659         // Media provider
660         grantSystemFixedPermissionsToSystemPackage(pm,
661                 getDefaultProviderAuthorityPackage(MediaStore.AUTHORITY, userId), userId,
662                 STORAGE_PERMISSIONS, NOTIFICATION_PERMISSIONS);
663 
664         // Downloads provider
665         grantSystemFixedPermissionsToSystemPackage(pm,
666                 getDefaultProviderAuthorityPackage("downloads", userId), userId,
667                 STORAGE_PERMISSIONS, NOTIFICATION_PERMISSIONS);
668 
669         // Downloads UI
670         grantSystemFixedPermissionsToSystemPackage(pm,
671                 getDefaultSystemHandlerActivityPackage(pm,
672                         DownloadManager.ACTION_VIEW_DOWNLOADS, userId),
673                 userId, STORAGE_PERMISSIONS);
674 
675         // Storage provider
676         grantSystemFixedPermissionsToSystemPackage(pm,
677                 getDefaultProviderAuthorityPackage("com.android.externalstorage.documents", userId),
678                 userId, STORAGE_PERMISSIONS);
679 
680         // CertInstaller
681         grantSystemFixedPermissionsToSystemPackage(pm,
682                 getDefaultSystemHandlerActivityPackage(pm, Credentials.INSTALL_ACTION, userId),
683                 userId, STORAGE_PERMISSIONS);
684 
685         // Dialer
686         if (dialerAppPackageNames == null) {
687             String dialerPackage =
688                     getDefaultSystemHandlerActivityPackage(pm, Intent.ACTION_DIAL, userId);
689             grantDefaultPermissionsToDefaultSystemDialerApp(pm, dialerPackage, userId);
690         } else {
691             for (String dialerAppPackageName : dialerAppPackageNames) {
692                 grantDefaultPermissionsToDefaultSystemDialerApp(pm, dialerAppPackageName, userId);
693             }
694         }
695 
696         // Sim call manager
697         if (simCallManagerPackageNames != null) {
698             for (String simCallManagerPackageName : simCallManagerPackageNames) {
699                 grantDefaultPermissionsToDefaultSystemSimCallManager(pm,
700                         simCallManagerPackageName, userId);
701             }
702         }
703 
704         // Use Open Wifi
705         if (useOpenWifiAppPackageNames != null) {
706             for (String useOpenWifiPackageName : useOpenWifiAppPackageNames) {
707                 grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(pm,
708                         useOpenWifiPackageName, userId);
709             }
710         }
711 
712         // SMS
713         if (smsAppPackageNames == null) {
714             String smsPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
715                     Intent.CATEGORY_APP_MESSAGING, userId);
716             grantDefaultPermissionsToDefaultSystemSmsApp(pm, smsPackage, userId);
717         } else {
718             for (String smsPackage : smsAppPackageNames) {
719                 grantDefaultPermissionsToDefaultSystemSmsApp(pm, smsPackage, userId);
720             }
721         }
722 
723         // Cell Broadcast Receiver
724         grantSystemFixedPermissionsToSystemPackage(pm,
725                 getDefaultSystemHandlerActivityPackage(pm, Intents.SMS_CB_RECEIVED_ACTION, userId),
726                 userId, SMS_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS, NOTIFICATION_PERMISSIONS);
727 
728         // Carrier Provisioning Service
729         grantPermissionsToSystemPackage(pm,
730                 getDefaultSystemHandlerServicePackage(pm, Intents.SMS_CARRIER_PROVISION_ACTION,
731                         userId),
732                 userId, SMS_PERMISSIONS);
733 
734         // Calendar
735         grantPermissionsToSystemPackage(pm,
736                 getDefaultSystemHandlerActivityPackageForCategory(pm,
737                         Intent.CATEGORY_APP_CALENDAR, userId),
738                 userId, CALENDAR_PERMISSIONS, CONTACTS_PERMISSIONS, NOTIFICATION_PERMISSIONS);
739 
740         // Calendar provider
741         String calendarProvider =
742                 getDefaultProviderAuthorityPackage(CalendarContract.AUTHORITY, userId);
743         grantPermissionsToSystemPackage(pm, calendarProvider, userId,
744                 CONTACTS_PERMISSIONS, STORAGE_PERMISSIONS);
745         grantSystemFixedPermissionsToSystemPackage(pm, calendarProvider, userId,
746                 CALENDAR_PERMISSIONS);
747 
748         // Calendar provider sync adapters
749         if (calendarSyncAdapterPackages != null) {
750             grantPermissionToEachSystemPackage(pm,
751                     getHeadlessSyncAdapterPackages(pm, calendarSyncAdapterPackages, userId),
752                     userId, CALENDAR_PERMISSIONS);
753         }
754 
755         // Contacts
756         grantPermissionsToSystemPackage(pm,
757                 getDefaultSystemHandlerActivityPackageForCategory(pm,
758                         Intent.CATEGORY_APP_CONTACTS, userId),
759                 userId, CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
760 
761         // Contacts provider sync adapters
762         if (contactsSyncAdapterPackages != null) {
763             grantPermissionToEachSystemPackage(pm,
764                     getHeadlessSyncAdapterPackages(pm, contactsSyncAdapterPackages, userId),
765                     userId, CONTACTS_PERMISSIONS);
766         }
767 
768         // Contacts provider
769         String contactsProviderPackage =
770                 getDefaultProviderAuthorityPackage(ContactsContract.AUTHORITY, userId);
771         grantSystemFixedPermissionsToSystemPackage(pm, contactsProviderPackage, userId,
772                 CONTACTS_PERMISSIONS, PHONE_PERMISSIONS, CALL_LOG_PERMISSIONS);
773         grantPermissionsToSystemPackage(pm, contactsProviderPackage, userId, STORAGE_PERMISSIONS);
774 
775         // Device provisioning
776         grantPermissionsToSystemPackage(pm,
777                 getDefaultSystemHandlerActivityPackage(pm,
778                         DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE, userId),
779                 userId, CONTACTS_PERMISSIONS, NOTIFICATION_PERMISSIONS);
780 
781         // Maps
782         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, 0)) {
783             grantPermissionsToSystemPackage(pm,
784                 getDefaultSystemHandlerActivityPackageForCategory(pm,
785                         Intent.CATEGORY_APP_MAPS, userId),
786                 userId, FOREGROUND_LOCATION_PERMISSIONS);
787         }
788 
789         // Email
790         grantPermissionsToSystemPackage(pm,
791                 getDefaultSystemHandlerActivityPackageForCategory(pm,
792                         Intent.CATEGORY_APP_EMAIL, userId),
793                 userId, CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS);
794 
795         // Browser
796         String browserPackage = ArrayUtils.firstOrNull(getKnownPackages(
797                 KnownPackages.PACKAGE_BROWSER, userId));
798         if (browserPackage == null) {
799             browserPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
800                     Intent.CATEGORY_APP_BROWSER, userId);
801             if (!pm.isSystemPackage(browserPackage)) {
802                 browserPackage = null;
803             }
804         }
805         grantPermissionsToPackage(pm, browserPackage, userId, false /* ignoreSystemPackage */,
806                 true /*whitelistRestrictedPermissions*/, FOREGROUND_LOCATION_PERMISSIONS);
807 
808         // Voice interaction
809         if (voiceInteractPackageNames != null) {
810             for (String voiceInteractPackageName : voiceInteractPackageNames) {
811                 grantPermissionsToSystemPackage(pm, voiceInteractPackageName, userId,
812                         CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS, MICROPHONE_PERMISSIONS,
813                         PHONE_PERMISSIONS, SMS_PERMISSIONS, COARSE_BACKGROUND_LOCATION_PERMISSIONS,
814                         NEARBY_DEVICES_PERMISSIONS, NOTIFICATION_PERMISSIONS);
815                 revokeRuntimePermissions(pm, voiceInteractPackageName, FINE_LOCATION_PERMISSIONS,
816                         false, userId);
817             }
818         }
819 
820         if (ActivityManager.isLowRamDeviceStatic()) {
821             // Allow voice search on low-ram devices
822             grantPermissionsToSystemPackage(pm,
823                     getDefaultSystemHandlerActivityPackage(pm,
824                             SearchManager.INTENT_ACTION_GLOBAL_SEARCH, userId),
825                     userId, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS,
826                     NOTIFICATION_PERMISSIONS);
827         }
828 
829         // Voice recognition
830         Intent voiceRecoIntent = new Intent(RecognitionService.SERVICE_INTERFACE)
831                 .addCategory(Intent.CATEGORY_DEFAULT);
832         grantPermissionsToSystemPackage(pm,
833                 getDefaultSystemHandlerServicePackage(pm, voiceRecoIntent, userId), userId,
834                 MICROPHONE_PERMISSIONS);
835 
836         // Location
837         if (locationPackageNames != null) {
838             for (String packageName : locationPackageNames) {
839                 grantPermissionsToSystemPackage(pm, packageName, userId,
840                         CONTACTS_PERMISSIONS, CALENDAR_PERMISSIONS, MICROPHONE_PERMISSIONS,
841                         PHONE_PERMISSIONS, SMS_PERMISSIONS, CAMERA_PERMISSIONS,
842                         SENSORS_PERMISSIONS, STORAGE_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS,
843                         NOTIFICATION_PERMISSIONS);
844                 grantSystemFixedPermissionsToSystemPackage(pm, packageName, userId,
845                         ALWAYS_LOCATION_PERMISSIONS, ACTIVITY_RECOGNITION_PERMISSIONS);
846             }
847         }
848         if (locationExtraPackageNames != null) {
849             // Also grant location and activity recognition permission to location extra packages.
850             for (String packageName : locationExtraPackageNames) {
851                 grantPermissionsToSystemPackage(pm, packageName, userId,
852                         ALWAYS_LOCATION_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
853                 grantSystemFixedPermissionsToSystemPackage(pm, packageName, userId,
854                         ACTIVITY_RECOGNITION_PERMISSIONS);
855             }
856         }
857 
858         // Music
859         Intent musicIntent = new Intent(Intent.ACTION_VIEW)
860                 .addCategory(Intent.CATEGORY_DEFAULT)
861                 .setDataAndType(Uri.fromFile(new File("foo.mp3")), AUDIO_MIME_TYPE);
862         grantPermissionsToSystemPackage(pm,
863                 getDefaultSystemHandlerActivityPackage(pm, musicIntent, userId), userId,
864                 STORAGE_PERMISSIONS);
865 
866         // Home
867         Intent homeIntent = new Intent(Intent.ACTION_MAIN)
868                 .addCategory(Intent.CATEGORY_HOME)
869                 .addCategory(Intent.CATEGORY_LAUNCHER_APP);
870         grantPermissionsToSystemPackage(pm,
871                 getDefaultSystemHandlerActivityPackage(pm, homeIntent, userId), userId,
872                 ALWAYS_LOCATION_PERMISSIONS, NOTIFICATION_PERMISSIONS);
873 
874         // Watches
875         if (mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH, 0)) {
876             // Home application on watches
877 
878             String wearPackage = getDefaultSystemHandlerActivityPackageForCategory(pm,
879                     Intent.CATEGORY_HOME_MAIN, userId);
880             grantPermissionsToSystemPackage(pm, wearPackage, userId,
881                     CONTACTS_PERMISSIONS, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
882             grantSystemFixedPermissionsToSystemPackage(pm, wearPackage, userId, PHONE_PERMISSIONS,
883                                                        ACTIVITY_RECOGNITION_PERMISSIONS);
884 
885             // Fitness tracking on watches
886             if (mContext.getResources().getBoolean(R.bool.config_trackerAppNeedsPermissions)) {
887                 Log.d(TAG, "Wear: Skipping permission grant for Default fitness tracker app : "
888                         + wearPackage);
889             } else {
890                 grantPermissionsToSystemPackage(pm,
891                     getDefaultSystemHandlerActivityPackage(pm, ACTION_TRACK, userId), userId,
892                     SENSORS_PERMISSIONS);
893             }
894 
895             // Allow voice search on wear
896             String voiceSearchPackage = getDefaultSystemHandlerActivityPackage(pm,
897                     SearchManager.INTENT_ACTION_GLOBAL_SEARCH, userId);
898             grantPermissionsToSystemPackage(pm, voiceSearchPackage,
899                     userId, PHONE_PERMISSIONS, CALENDAR_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS,
900                     COARSE_BACKGROUND_LOCATION_PERMISSIONS, CONTACTS_PERMISSIONS);
901             revokeRuntimePermissions(pm, voiceSearchPackage,
902                 FINE_LOCATION_PERMISSIONS, false, userId);
903         }
904 
905         // Print Spooler
906         grantSystemFixedPermissionsToSystemPackage(pm, PrintManager.PRINT_SPOOLER_PACKAGE_NAME,
907                 userId, ALWAYS_LOCATION_PERMISSIONS, NOTIFICATION_PERMISSIONS);
908 
909         // EmergencyInfo
910         grantSystemFixedPermissionsToSystemPackage(pm,
911                 getDefaultSystemHandlerActivityPackage(pm,
912                         TelephonyManager.ACTION_EMERGENCY_ASSISTANCE, userId),
913                 userId, CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
914 
915         // NFC Tag viewer
916         Intent nfcTagIntent = new Intent(Intent.ACTION_VIEW)
917                 .setType("vnd.android.cursor.item/ndef_msg");
918         grantPermissionsToSystemPackage(pm,
919                 getDefaultSystemHandlerActivityPackage(pm, nfcTagIntent, userId), userId,
920                 CONTACTS_PERMISSIONS, PHONE_PERMISSIONS);
921 
922         // Storage Manager
923         grantSystemFixedPermissionsToSystemPackage(pm,
924                 getDefaultSystemHandlerActivityPackage(pm,
925                         StorageManager.ACTION_MANAGE_STORAGE, userId),
926                 userId, STORAGE_PERMISSIONS);
927 
928         // Companion devices
929         grantSystemFixedPermissionsToSystemPackage(pm,
930                 getDefaultCompanionDeviceManagerPackage(), userId,
931                 ALWAYS_LOCATION_PERMISSIONS, NEARBY_DEVICES_PERMISSIONS);
932 
933         // Ringtone Picker
934         grantSystemFixedPermissionsToSystemPackage(pm,
935                 getDefaultSystemHandlerActivityPackage(pm,
936                         RingtoneManager.ACTION_RINGTONE_PICKER, userId),
937                 userId, STORAGE_PERMISSIONS);
938 
939         // TextClassifier Service
940         for (String textClassifierPackage :
941                 getKnownPackages(KnownPackages.PACKAGE_SYSTEM_TEXT_CLASSIFIER, userId)) {
942             grantPermissionsToSystemPackage(pm, textClassifierPackage, userId,
943                     COARSE_BACKGROUND_LOCATION_PERMISSIONS, CONTACTS_PERMISSIONS);
944         }
945 
946         // There is no real "marker" interface to identify the shared storage backup, it is
947         // hardcoded in BackupManagerService.SHARED_BACKUP_AGENT_PACKAGE.
948         grantSystemFixedPermissionsToSystemPackage(pm, "com.android.sharedstoragebackup", userId,
949                 STORAGE_PERMISSIONS);
950 
951         // Bluetooth MIDI Service
952         grantSystemFixedPermissionsToSystemPackage(pm,
953                 MidiManager.BLUETOOTH_MIDI_SERVICE_PACKAGE, userId,
954                 NEARBY_DEVICES_PERMISSIONS);
955 
956         // Ad Service
957         String commonServiceAction = "android.adservices.AD_SERVICES_COMMON_SERVICE";
958         grantPermissionsToSystemPackage(pm, getDefaultSystemHandlerServicePackage(pm,
959                         commonServiceAction, userId), userId, NOTIFICATION_PERMISSIONS);
960     }
961 
getDefaultSystemHandlerActivityPackageForCategory(PackageManagerWrapper pm, String category, int userId)962     private String getDefaultSystemHandlerActivityPackageForCategory(PackageManagerWrapper pm,
963             String category, int userId) {
964         return getDefaultSystemHandlerActivityPackage(pm,
965                 new Intent(Intent.ACTION_MAIN).addCategory(category), userId);
966     }
967 
getDefaultSearchSelectorPackage()968     private String getDefaultSearchSelectorPackage() {
969         return mContext.getString(R.string.config_defaultSearchSelectorPackageName);
970     }
971 
getDefaultCaptivePortalLoginPackage()972     private String getDefaultCaptivePortalLoginPackage() {
973         return mContext.getString(R.string.config_defaultCaptivePortalLoginPackageName);
974     }
975 
getDefaultDockManagerPackage()976     private String getDefaultDockManagerPackage() {
977         return mContext.getString(R.string.config_defaultDockManagerPackageName);
978     }
979 
getDefaultCompanionDeviceManagerPackage()980     private String getDefaultCompanionDeviceManagerPackage() {
981         return mContext.getString(R.string.config_companionDeviceManagerPackage);
982     }
983 
984     @SafeVarargs
grantPermissionToEachSystemPackage(PackageManagerWrapper pm, ArrayList<String> packages, int userId, Set<String>... permissions)985     private final void grantPermissionToEachSystemPackage(PackageManagerWrapper pm,
986             ArrayList<String> packages, int userId, Set<String>... permissions) {
987         if (packages == null) return;
988         final int count = packages.size();
989         for (int i = 0; i < count; i++) {
990             grantPermissionsToSystemPackage(pm, packages.get(i), userId, permissions);
991         }
992     }
993 
getKnownPackages(int knownPkgId, int userId)994     private @NonNull String[] getKnownPackages(int knownPkgId, int userId) {
995         return mServiceInternal.getKnownPackageNames(knownPkgId, userId);
996     }
997 
grantDefaultPermissionsToDefaultSystemDialerApp(PackageManagerWrapper pm, String dialerPackage, int userId)998     private void grantDefaultPermissionsToDefaultSystemDialerApp(PackageManagerWrapper pm,
999             String dialerPackage, int userId) {
1000         if (dialerPackage == null) {
1001             return;
1002         }
1003         boolean isPhonePermFixed =
1004                 mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_WATCH, 0);
1005         if (isPhonePermFixed) {
1006             grantSystemFixedPermissionsToSystemPackage(pm, dialerPackage, userId,
1007                     PHONE_PERMISSIONS, NOTIFICATION_PERMISSIONS);
1008         } else {
1009             grantPermissionsToSystemPackage(pm, dialerPackage, userId, PHONE_PERMISSIONS);
1010         }
1011         grantPermissionsToSystemPackage(pm, dialerPackage, userId,
1012                 CONTACTS_PERMISSIONS, SMS_PERMISSIONS, MICROPHONE_PERMISSIONS, CAMERA_PERMISSIONS,
1013                 NOTIFICATION_PERMISSIONS);
1014         boolean isAndroidAutomotive =
1015                 mContext.getPackageManager().hasSystemFeature(PackageManager.FEATURE_AUTOMOTIVE, 0);
1016         if (isAndroidAutomotive) {
1017             grantPermissionsToSystemPackage(pm, dialerPackage, userId, NEARBY_DEVICES_PERMISSIONS);
1018         }
1019     }
1020 
grantDefaultPermissionsToDefaultSystemSmsApp(PackageManagerWrapper pm, String smsPackage, int userId)1021     private void grantDefaultPermissionsToDefaultSystemSmsApp(PackageManagerWrapper pm,
1022             String smsPackage, int userId) {
1023         grantPermissionsToSystemPackage(pm, smsPackage, userId,
1024                 PHONE_PERMISSIONS, CONTACTS_PERMISSIONS, SMS_PERMISSIONS,
1025                 STORAGE_PERMISSIONS, MICROPHONE_PERMISSIONS, CAMERA_PERMISSIONS,
1026                 NOTIFICATION_PERMISSIONS);
1027     }
1028 
grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(PackageManagerWrapper pm, String useOpenWifiPackage, int userId)1029     private void grantDefaultPermissionsToDefaultSystemUseOpenWifiApp(PackageManagerWrapper pm,
1030             String useOpenWifiPackage, int userId) {
1031         grantPermissionsToSystemPackage(pm, useOpenWifiPackage, userId,
1032                 ALWAYS_LOCATION_PERMISSIONS);
1033     }
1034 
grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName, int userId)1035     public void grantDefaultPermissionsToDefaultUseOpenWifiApp(String packageName, int userId) {
1036         Log.i(TAG, "Granting permissions to default Use Open WiFi app for user:" + userId);
1037         grantIgnoringSystemPackage(NO_PM_CACHE, packageName, userId, ALWAYS_LOCATION_PERMISSIONS);
1038     }
1039 
grantDefaultPermissionsToDefaultSimCallManager(String packageName, int userId)1040     public void grantDefaultPermissionsToDefaultSimCallManager(String packageName, int userId) {
1041         grantDefaultPermissionsToDefaultSimCallManager(NO_PM_CACHE, packageName, userId);
1042     }
1043 
grantDefaultPermissionsToDefaultSimCallManager(PackageManagerWrapper pm, String packageName, int userId)1044     private void grantDefaultPermissionsToDefaultSimCallManager(PackageManagerWrapper pm,
1045             String packageName, int userId) {
1046         if (packageName == null) {
1047             return;
1048         }
1049         Log.i(TAG, "Granting permissions to sim call manager for user:" + userId);
1050         grantPermissionsToPackage(pm, packageName, userId, false /* ignoreSystemPackage */,
1051                 true /*whitelistRestrictedPermissions*/, PHONE_PERMISSIONS, MICROPHONE_PERMISSIONS);
1052     }
1053 
grantDefaultPermissionsToDefaultSystemSimCallManager(PackageManagerWrapper pm, String packageName, int userId)1054     private void grantDefaultPermissionsToDefaultSystemSimCallManager(PackageManagerWrapper pm,
1055             String packageName, int userId) {
1056         if (pm.isSystemPackage(packageName)) {
1057             grantDefaultPermissionsToDefaultSimCallManager(pm, packageName, userId);
1058         }
1059     }
1060 
grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId)1061     public void grantDefaultPermissionsToEnabledCarrierApps(String[] packageNames, int userId) {
1062         Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);
1063         if (packageNames == null) {
1064             return;
1065         }
1066         for (String packageName : packageNames) {
1067             grantPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
1068                     PHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS, SMS_PERMISSIONS);
1069         }
1070     }
1071 
grantDefaultPermissionsToEnabledImsServices(String[] packageNames, int userId)1072     public void grantDefaultPermissionsToEnabledImsServices(String[] packageNames, int userId) {
1073         Log.i(TAG, "Granting permissions to enabled ImsServices for user:" + userId);
1074         if (packageNames == null) {
1075             return;
1076         }
1077         for (String packageName : packageNames) {
1078             grantPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
1079                     PHONE_PERMISSIONS, MICROPHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS,
1080                     CAMERA_PERMISSIONS, CONTACTS_PERMISSIONS);
1081         }
1082     }
1083 
grantDefaultPermissionsToEnabledTelephonyDataServices( String[] packageNames, int userId)1084     public void grantDefaultPermissionsToEnabledTelephonyDataServices(
1085             String[] packageNames, int userId) {
1086         Log.i(TAG, "Granting permissions to enabled data services for user:" + userId);
1087         if (packageNames == null) {
1088             return;
1089         }
1090         for (String packageName : packageNames) {
1091             // Grant these permissions as system-fixed, so that nobody can accidentally
1092             // break cellular data.
1093             grantSystemFixedPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
1094                     PHONE_PERMISSIONS, ALWAYS_LOCATION_PERMISSIONS);
1095         }
1096     }
1097 
revokeDefaultPermissionsFromDisabledTelephonyDataServices( String[] packageNames, int userId)1098     public void revokeDefaultPermissionsFromDisabledTelephonyDataServices(
1099             String[] packageNames, int userId) {
1100         Log.i(TAG, "Revoking permissions from disabled data services for user:" + userId);
1101         if (packageNames == null) {
1102             return;
1103         }
1104         for (String packageName : packageNames) {
1105             PackageInfo pkg = NO_PM_CACHE.getSystemPackageInfo(packageName);
1106             if (NO_PM_CACHE.isSystemPackage(pkg) && doesPackageSupportRuntimePermissions(pkg)) {
1107                 revokeRuntimePermissions(NO_PM_CACHE, packageName, PHONE_PERMISSIONS, true,
1108                         userId);
1109                 revokeRuntimePermissions(NO_PM_CACHE, packageName, ALWAYS_LOCATION_PERMISSIONS,
1110                         true, userId);
1111             }
1112         }
1113     }
1114 
grantDefaultPermissionsToActiveLuiApp(String packageName, int userId)1115     public void grantDefaultPermissionsToActiveLuiApp(String packageName, int userId) {
1116         Log.i(TAG, "Granting permissions to active LUI app for user:" + userId);
1117         grantSystemFixedPermissionsToSystemPackage(NO_PM_CACHE, packageName, userId,
1118                 CAMERA_PERMISSIONS, NOTIFICATION_PERMISSIONS);
1119     }
1120 
revokeDefaultPermissionsFromLuiApps(String[] packageNames, int userId)1121     public void revokeDefaultPermissionsFromLuiApps(String[] packageNames, int userId) {
1122         Log.i(TAG, "Revoke permissions from LUI apps for user:" + userId);
1123         if (packageNames == null) {
1124             return;
1125         }
1126         for (String packageName : packageNames) {
1127             PackageInfo pkg = NO_PM_CACHE.getSystemPackageInfo(packageName);
1128             if (NO_PM_CACHE.isSystemPackage(pkg) && doesPackageSupportRuntimePermissions(pkg)) {
1129                 revokeRuntimePermissions(NO_PM_CACHE, packageName, CAMERA_PERMISSIONS, true,
1130                         userId);
1131             }
1132         }
1133     }
1134 
grantDefaultPermissionsToCarrierServiceApp(@onNull String packageName, @UserIdInt int userId)1135     public void grantDefaultPermissionsToCarrierServiceApp(@NonNull String packageName,
1136             @UserIdInt int userId) {
1137         Log.i(TAG, "Grant permissions to Carrier Service app " + packageName + " for user:"
1138                 + userId);
1139         grantPermissionsToPackage(NO_PM_CACHE, packageName, userId, /* ignoreSystemPackage */ false,
1140                /* whitelistRestricted */ true, NOTIFICATION_PERMISSIONS);
1141     }
1142 
getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, String intentAction, int userId)1143     private String getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm,
1144             String intentAction, int userId) {
1145         return getDefaultSystemHandlerActivityPackage(pm, new Intent(intentAction), userId);
1146     }
1147 
getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, Intent intent, int userId)1148     private String getDefaultSystemHandlerActivityPackage(PackageManagerWrapper pm, Intent intent,
1149             int userId) {
1150         ResolveInfo handler = mContext.getPackageManager().resolveActivityAsUser(
1151                 intent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1152         if (handler == null || handler.activityInfo == null) {
1153             return null;
1154         }
1155         if (mServiceInternal.isResolveActivityComponent(handler.activityInfo)) {
1156             return null;
1157         }
1158         String packageName = handler.activityInfo.packageName;
1159         return pm.isSystemPackage(packageName) ? packageName : null;
1160     }
1161 
getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm, String intentAction, int userId)1162     private String getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm,
1163             String intentAction, int userId) {
1164         return getDefaultSystemHandlerServicePackage(pm, new Intent(intentAction), userId);
1165     }
1166 
getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm, Intent intent, int userId)1167     private String getDefaultSystemHandlerServicePackage(PackageManagerWrapper pm,
1168             Intent intent, int userId) {
1169         List<ResolveInfo> handlers = mContext.getPackageManager().queryIntentServicesAsUser(
1170                 intent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1171         if (handlers == null) {
1172             return null;
1173         }
1174         final int handlerCount = handlers.size();
1175         for (int i = 0; i < handlerCount; i++) {
1176             ResolveInfo handler = handlers.get(i);
1177             String handlerPackage = handler.serviceInfo.packageName;
1178             if (pm.isSystemPackage(handlerPackage)) {
1179                 return handlerPackage;
1180             }
1181         }
1182         return null;
1183     }
1184 
getHeadlessSyncAdapterPackages(PackageManagerWrapper pm, String[] syncAdapterPackageNames, int userId)1185     private ArrayList<String> getHeadlessSyncAdapterPackages(PackageManagerWrapper pm,
1186             String[] syncAdapterPackageNames, int userId) {
1187         ArrayList<String> syncAdapterPackages = new ArrayList<>();
1188 
1189         Intent homeIntent = new Intent(Intent.ACTION_MAIN).addCategory(Intent.CATEGORY_LAUNCHER);
1190 
1191         for (String syncAdapterPackageName : syncAdapterPackageNames) {
1192             homeIntent.setPackage(syncAdapterPackageName);
1193 
1194             ResolveInfo homeActivity = mContext.getPackageManager().resolveActivityAsUser(
1195                     homeIntent, DEFAULT_INTENT_QUERY_FLAGS, userId);
1196             if (homeActivity != null) {
1197                 continue;
1198             }
1199 
1200             if (pm.isSystemPackage(syncAdapterPackageName)) {
1201                 syncAdapterPackages.add(syncAdapterPackageName);
1202             }
1203         }
1204 
1205         return syncAdapterPackages;
1206     }
1207 
getDefaultProviderAuthorityPackage(String authority, int userId)1208     private String getDefaultProviderAuthorityPackage(String authority, int userId) {
1209         ProviderInfo provider = mContext.getPackageManager().resolveContentProviderAsUser(
1210                 authority, DEFAULT_INTENT_QUERY_FLAGS, userId);
1211         if (provider != null) {
1212             return provider.packageName;
1213         }
1214         return null;
1215     }
1216 
grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg, Set<String> permissions, boolean systemFixed, int userId)1217     private void grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg,
1218             Set<String> permissions, boolean systemFixed, int userId) {
1219         grantRuntimePermissions(pm, pkg, permissions, systemFixed, false,
1220                 true /*whitelistRestrictedPermissions*/, userId);
1221     }
1222 
revokeRuntimePermissions(PackageManagerWrapper pm, String packageName, Set<String> permissions, boolean systemFixed, int userId)1223     private void revokeRuntimePermissions(PackageManagerWrapper pm, String packageName,
1224             Set<String> permissions, boolean systemFixed, int userId) {
1225         PackageInfo pkg = pm.getSystemPackageInfo(packageName);
1226         if (pkg == null || ArrayUtils.isEmpty(pkg.requestedPermissions)) {
1227             return;
1228         }
1229         Set<String> revokablePermissions = new ArraySet<>(Arrays.asList(pkg.requestedPermissions));
1230 
1231         for (String permission : permissions) {
1232             // We can't revoke what wasn't requested.
1233             if (!revokablePermissions.contains(permission)) {
1234                 continue;
1235             }
1236 
1237             UserHandle user = UserHandle.of(userId);
1238             final int flags = pm.getPermissionFlags(permission, pm.getPackageInfo(packageName),
1239                     user);
1240 
1241             // We didn't get this through the default grant policy. Move along.
1242             if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) == 0) {
1243                 continue;
1244             }
1245             // We aren't going to clobber device policy with a DefaultGrant.
1246             if ((flags & PackageManager.FLAG_PERMISSION_POLICY_FIXED) != 0) {
1247                 continue;
1248             }
1249             // Do not revoke system fixed permissions unless caller set them that way;
1250             // there is no refcount for the number of sources of this, so there
1251             // should be at most one grantor doing SYSTEM_FIXED for any given package.
1252             if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0 && !systemFixed) {
1253                 continue;
1254             }
1255             pm.revokePermission(permission, pkg, user);
1256 
1257             if (DEBUG) {
1258                 Log.i(TAG, "revoked " + (systemFixed ? "fixed " : "not fixed ")
1259                         + permission + " to " + packageName);
1260             }
1261 
1262             // Remove the GRANTED_BY_DEFAULT flag without touching the others.
1263             // Note that we do not revoke FLAG_PERMISSION_SYSTEM_FIXED. That bit remains
1264             // sticky once set.
1265             pm.updatePermissionFlags(permission, pkg,
1266                     PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT, 0, user);
1267         }
1268     }
1269 
1270     /**
1271      * Check if a permission is already fixed or is set by the user.
1272      *
1273      * <p>A permission should not be set by the default policy if the user or other policies already
1274      * set the permission.
1275      *
1276      * @param flags The flags of the permission
1277      *
1278      * @return {@code true} iff the permission can be set without violating a policy of the users
1279      *         intention
1280      */
isFixedOrUserSet(int flags)1281     private boolean isFixedOrUserSet(int flags) {
1282         return (flags & (PackageManager.FLAG_PERMISSION_USER_SET
1283                 | PackageManager.FLAG_PERMISSION_ONE_TIME
1284                 | PackageManager.FLAG_PERMISSION_USER_FIXED
1285                 | PackageManager.FLAG_PERMISSION_POLICY_FIXED
1286                 | PackageManager.FLAG_PERMISSION_SYSTEM_FIXED)) != 0;
1287     }
1288 
grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg, Set<String> permissionsWithoutSplits, boolean systemFixed, boolean ignoreSystemPackage, boolean whitelistRestrictedPermissions, int userId)1289     private void grantRuntimePermissions(PackageManagerWrapper pm, PackageInfo pkg,
1290             Set<String> permissionsWithoutSplits, boolean systemFixed, boolean ignoreSystemPackage,
1291             boolean whitelistRestrictedPermissions, int userId) {
1292         UserHandle user = UserHandle.of(userId);
1293         if (pkg == null) {
1294             return;
1295         }
1296 
1297         String[] requestedPermissions = pkg.requestedPermissions;
1298         if (ArrayUtils.isEmpty(requestedPermissions)) {
1299             return;
1300         }
1301 
1302         // Intersect the requestedPermissions for a factory image with that of its current update
1303         // in case the latter one removed a <uses-permission>
1304         String[] requestedByNonSystemPackage = pm.getPackageInfo(pkg.packageName)
1305                 .requestedPermissions;
1306         int size = requestedPermissions.length;
1307         for (int i = 0; i < size; i++) {
1308             if (!ArrayUtils.contains(requestedByNonSystemPackage, requestedPermissions[i])) {
1309                 requestedPermissions[i] = null;
1310             }
1311         }
1312         requestedPermissions = ArrayUtils.filterNotNull(requestedPermissions, String[]::new);
1313 
1314         final ArraySet<String> permissions = new ArraySet<>(permissionsWithoutSplits);
1315         ApplicationInfo applicationInfo = pkg.applicationInfo;
1316 
1317         int newFlags = PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
1318         if (systemFixed) {
1319             newFlags |= PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
1320         }
1321 
1322         // Automatically attempt to grant split permissions to older APKs
1323         final List<PermissionManager.SplitPermissionInfo> splitPermissions =
1324                 mContext.getSystemService(PermissionManager.class).getSplitPermissions();
1325         final int numSplitPerms = splitPermissions.size();
1326         for (int splitPermNum = 0; splitPermNum < numSplitPerms; splitPermNum++) {
1327             final PermissionManager.SplitPermissionInfo splitPerm =
1328                     splitPermissions.get(splitPermNum);
1329 
1330             if (applicationInfo != null
1331                     && applicationInfo.targetSdkVersion < splitPerm.getTargetSdk()
1332                     && permissionsWithoutSplits.contains(splitPerm.getSplitPermission())) {
1333                 permissions.addAll(splitPerm.getNewPermissions());
1334             }
1335         }
1336 
1337         Set<String> grantablePermissions = null;
1338 
1339         // In some cases, like for the Phone or SMS app, we grant permissions regardless
1340         // of if the version on the system image declares the permission as used since
1341         // selecting the app as the default for that function the user makes a deliberate
1342         // choice to grant this app the permissions needed to function. For all other
1343         // apps, (default grants on first boot and user creation) we don't grant default
1344         // permissions if the version on the system image does not declare them.
1345         if (!ignoreSystemPackage
1346                 && applicationInfo != null
1347                 && applicationInfo.isUpdatedSystemApp()) {
1348             final PackageInfo disabledPkg = pm.getSystemPackageInfo(
1349                     mServiceInternal.getDisabledSystemPackageName(pkg.packageName));
1350             if (disabledPkg != null) {
1351                 if (ArrayUtils.isEmpty(disabledPkg.requestedPermissions)) {
1352                     return;
1353                 }
1354                 if (!Arrays.equals(requestedPermissions, disabledPkg.requestedPermissions)) {
1355                     grantablePermissions = new ArraySet<>(Arrays.asList(requestedPermissions));
1356                     requestedPermissions = disabledPkg.requestedPermissions;
1357                 }
1358             }
1359         }
1360 
1361         final int numRequestedPermissions = requestedPermissions.length;
1362 
1363         // Sort requested permissions so that all permissions that are a foreground permission (i.e.
1364         // permissions that have a background permission) are before their background permissions.
1365         final String[] sortedRequestedPermissions = new String[numRequestedPermissions];
1366         int numForeground = 0;
1367         int numOther = 0;
1368         for (int i = 0; i < numRequestedPermissions; i++) {
1369             String permission = requestedPermissions[i];
1370             if (pm.getBackgroundPermission(permission) != null) {
1371                 sortedRequestedPermissions[numForeground] = permission;
1372                 numForeground++;
1373             } else {
1374                 sortedRequestedPermissions[numRequestedPermissions - 1 - numOther] =
1375                         permission;
1376                 numOther++;
1377             }
1378         }
1379 
1380         for (int requestedPermissionNum = 0; requestedPermissionNum < numRequestedPermissions;
1381                 requestedPermissionNum++) {
1382             String permission = sortedRequestedPermissions[requestedPermissionNum];
1383 
1384             // If there is a disabled system app it may request a permission the updated
1385             // version ot the data partition doesn't, In this case skip the permission.
1386             if (grantablePermissions != null && !grantablePermissions.contains(permission)) {
1387                 continue;
1388             }
1389 
1390             if (permissions.contains(permission)) {
1391                 final int flags = pm.getPermissionFlags(permission, pkg, user);
1392 
1393                 // If we are trying to grant as system fixed and already system fixed
1394                 // then the system can change the system fixed grant state.
1395                 final boolean changingGrantForSystemFixed = systemFixed
1396                         && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0;
1397 
1398                 // Certain flags imply that the permission's current state by the system or
1399                 // device/profile owner or the user. In these cases we do not want to clobber the
1400                 // current state.
1401                 //
1402                 // Unless the caller wants to override user choices. The override is
1403                 // to make sure we can grant the needed permission to the default
1404                 // sms and phone apps after the user chooses this in the UI.
1405                 if (!isFixedOrUserSet(flags) || ignoreSystemPackage
1406                         || changingGrantForSystemFixed) {
1407                     // Never clobber policy fixed permissions.
1408                     // We must allow the grant of a system-fixed permission because
1409                     // system-fixed is sticky, but the permission itself may be revoked.
1410                     if ((flags & PackageManager.FLAG_PERMISSION_POLICY_FIXED) != 0) {
1411                         continue;
1412                     }
1413 
1414                     // Preserve allowlisting flags.
1415                     newFlags |= (flags & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT);
1416 
1417                     // If we are allowlisting the permission, update the exempt flag before grant.
1418                     if (whitelistRestrictedPermissions && pm.isPermissionRestricted(permission)) {
1419                         pm.updatePermissionFlags(permission, pkg,
1420                                 PackageManager.FLAG_PERMISSION_RESTRICTION_SYSTEM_EXEMPT,
1421                                 PackageManager.FLAG_PERMISSION_RESTRICTION_SYSTEM_EXEMPT, user);
1422                     }
1423 
1424                     // If the system tries to change a system fixed permission from one fixed
1425                     // state to another we need to drop the fixed flag to allow the grant.
1426                     if (changingGrantForSystemFixed) {
1427                         pm.updatePermissionFlags(permission, pkg, flags,
1428                                 flags & ~PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, user);
1429                     }
1430 
1431                     if (!pm.isGranted(permission, pkg, user)) {
1432                         pm.grantPermission(permission, pkg, user);
1433                     }
1434 
1435                     // clear the REVIEW_REQUIRED flag, if set
1436                     int flagMask = newFlags | PackageManager.FLAG_PERMISSION_REVIEW_REQUIRED;
1437                     pm.updatePermissionFlags(permission, pkg, flagMask, newFlags, user);
1438                 }
1439 
1440                 // If a component gets a permission for being the default handler A
1441                 // and also default handler B, we grant the weaker grant form.
1442                 if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0
1443                         && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0
1444                         && !systemFixed) {
1445                     if (DEBUG) {
1446                         Log.i(TAG, "Granted not fixed " + permission + " to default handler "
1447                                 + pkg);
1448                     }
1449                     pm.updatePermissionFlags(permission, pkg,
1450                             PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, 0, user);
1451                 }
1452             }
1453         }
1454     }
1455 
grantDefaultPermissionExceptions(PackageManagerWrapper pm, int userId)1456     private void grantDefaultPermissionExceptions(PackageManagerWrapper pm, int userId) {
1457         mHandler.removeMessages(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);
1458 
1459         synchronized (mLock) {
1460             // mGrantExceptions is null only before the first read and then
1461             // it serves as a cache of the default grants that should be
1462             // performed for every user. If there is an entry then the app
1463             // is on the system image and supports runtime permissions.
1464             if (mGrantExceptions == null) {
1465                 mGrantExceptions = readDefaultPermissionExceptionsLocked(pm);
1466             }
1467         }
1468 
1469         Set<String> permissions = null;
1470         final int exceptionCount = mGrantExceptions.size();
1471         for (int i = 0; i < exceptionCount; i++) {
1472             String packageName = mGrantExceptions.keyAt(i);
1473             PackageInfo pkg = pm.getPackageInfo(packageName);
1474             List<DefaultPermissionGrant> permissionGrants = mGrantExceptions.valueAt(i);
1475             final int permissionGrantCount = permissionGrants.size();
1476             for (int j = 0; j < permissionGrantCount; j++) {
1477                 DefaultPermissionGrant permissionGrant = permissionGrants.get(j);
1478                 if (!pm.isPermissionDangerous(permissionGrant.name)) {
1479                     Log.w(TAG, "Ignoring permission " + permissionGrant.name
1480                             + " which isn't dangerous");
1481                     continue;
1482                 }
1483                 if (permissions == null) {
1484                     permissions = new ArraySet<>();
1485                 } else {
1486                     permissions.clear();
1487                 }
1488                 permissions.add(permissionGrant.name);
1489 
1490 
1491                 grantRuntimePermissions(pm, pkg, permissions, permissionGrant.fixed,
1492                         permissionGrant.whitelisted, true /*whitelistRestrictedPermissions*/,
1493                         userId);
1494             }
1495         }
1496     }
1497 
getDefaultPermissionFiles()1498     private File[] getDefaultPermissionFiles() {
1499         ArrayList<File> ret = new ArrayList<File>();
1500         File dir = new File(Environment.getRootDirectory(), "etc/default-permissions");
1501         if (dir.isDirectory() && dir.canRead()) {
1502             Collections.addAll(ret, dir.listFiles());
1503         }
1504         dir = new File(Environment.getVendorDirectory(), "etc/default-permissions");
1505         if (dir.isDirectory() && dir.canRead()) {
1506             Collections.addAll(ret, dir.listFiles());
1507         }
1508         dir = new File(Environment.getOdmDirectory(), "etc/default-permissions");
1509         if (dir.isDirectory() && dir.canRead()) {
1510             Collections.addAll(ret, dir.listFiles());
1511         }
1512         dir = new File(Environment.getProductDirectory(), "etc/default-permissions");
1513         if (dir.isDirectory() && dir.canRead()) {
1514             Collections.addAll(ret, dir.listFiles());
1515         }
1516         dir = new File(Environment.getSystemExtDirectory(), "etc/default-permissions");
1517         if (dir.isDirectory() && dir.canRead()) {
1518             Collections.addAll(ret, dir.listFiles());
1519         }
1520         dir = new File(Environment.getOemDirectory(), "etc/default-permissions");
1521         if (dir.isDirectory() && dir.canRead()) {
1522             Collections.addAll(ret, dir.listFiles());
1523         }
1524         return ret.isEmpty() ? null : ret.toArray(new File[0]);
1525     }
1526 
1527     private @NonNull ArrayMap<String, List<DefaultPermissionGrant>>
readDefaultPermissionExceptionsLocked(PackageManagerWrapper pm)1528             readDefaultPermissionExceptionsLocked(PackageManagerWrapper pm) {
1529         File[] files = getDefaultPermissionFiles();
1530         if (files == null) {
1531             return new ArrayMap<>(0);
1532         }
1533 
1534         ArrayMap<String, List<DefaultPermissionGrant>> grantExceptions = new ArrayMap<>();
1535 
1536         // Iterate over the files in the directory and scan .xml files
1537         for (File file : files) {
1538             if (!file.getPath().endsWith(".xml")) {
1539                 Slog.i(TAG, "Non-xml file " + file
1540                         + " in " + file.getParent() + " directory, ignoring");
1541                 continue;
1542             }
1543             if (!file.canRead()) {
1544                 Slog.w(TAG, "Default permissions file " + file + " cannot be read");
1545                 continue;
1546             }
1547             try (InputStream str = new FileInputStream(file)) {
1548                 TypedXmlPullParser parser = Xml.resolvePullParser(str);
1549                 parse(pm, parser, grantExceptions);
1550             } catch (XmlPullParserException | IOException e) {
1551                 Slog.w(TAG, "Error reading default permissions file " + file, e);
1552             }
1553         }
1554 
1555         return grantExceptions;
1556     }
1557 
parse(PackageManagerWrapper pm, TypedXmlPullParser parser, Map<String, List<DefaultPermissionGrant>> outGrantExceptions)1558     private void parse(PackageManagerWrapper pm, TypedXmlPullParser parser,
1559             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
1560             throws IOException, XmlPullParserException {
1561         final int outerDepth = parser.getDepth();
1562         int type;
1563         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1564                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1565             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1566                 continue;
1567             }
1568             if (TAG_EXCEPTIONS.equals(parser.getName())) {
1569                 parseExceptions(pm, parser, outGrantExceptions);
1570             } else {
1571                 Log.e(TAG, "Unknown tag " + parser.getName());
1572             }
1573         }
1574     }
1575 
parseExceptions(PackageManagerWrapper pm, TypedXmlPullParser parser, Map<String, List<DefaultPermissionGrant>> outGrantExceptions)1576     private void parseExceptions(PackageManagerWrapper pm, TypedXmlPullParser parser,
1577             Map<String, List<DefaultPermissionGrant>> outGrantExceptions)
1578             throws IOException, XmlPullParserException {
1579         final int outerDepth = parser.getDepth();
1580         int type;
1581         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1582                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1583             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1584                 continue;
1585             }
1586             if (TAG_EXCEPTION.equals(parser.getName())) {
1587                 String packageName = parser.getAttributeValue(null, ATTR_PACKAGE);
1588                 String cert = parser.getAttributeValue(null, ATTR_CERT);
1589 
1590                 List<DefaultPermissionGrant> packageExceptions =
1591                         outGrantExceptions.get(packageName);
1592                 if (packageExceptions == null) {
1593                     PackageInfo packageInfo = pm.getPackageInfo(packageName);
1594 
1595                     if (packageInfo == null) {
1596                         Log.w(TAG, "No such package:" + packageName);
1597                         XmlUtils.skipCurrentTag(parser);
1598                         continue;
1599                     }
1600 
1601                     if (!isSystemOrCertificateMatchingPackage(packageInfo, cert)) {
1602                         Log.w(TAG, "Not system or certificate-matching package: " + packageName);
1603                         XmlUtils.skipCurrentTag(parser);
1604                         continue;
1605                     }
1606 
1607                     // The package must support runtime permissions
1608                     if (!doesPackageSupportRuntimePermissions(packageInfo)) {
1609                         Log.w(TAG, "Skipping non supporting runtime permissions package:"
1610                                 + packageName);
1611                         XmlUtils.skipCurrentTag(parser);
1612                         continue;
1613                     }
1614                     packageExceptions = new ArrayList<>();
1615                     outGrantExceptions.put(packageName, packageExceptions);
1616                 }
1617 
1618                 parsePermission(parser, packageExceptions);
1619             } else {
1620                 Log.e(TAG, "Unknown tag " + parser.getName() + "under <exceptions>");
1621             }
1622         }
1623     }
1624 
parsePermission(TypedXmlPullParser parser, List<DefaultPermissionGrant> outPackageExceptions)1625     private void parsePermission(TypedXmlPullParser parser, List<DefaultPermissionGrant>
1626             outPackageExceptions) throws IOException, XmlPullParserException {
1627         final int outerDepth = parser.getDepth();
1628         int type;
1629         while ((type = parser.next()) != XmlPullParser.END_DOCUMENT
1630                 && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {
1631             if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {
1632                 continue;
1633             }
1634 
1635             if (TAG_PERMISSION.contains(parser.getName())) {
1636                 String name = parser.getAttributeValue(null, ATTR_NAME);
1637                 if (name == null) {
1638                     Log.w(TAG, "Mandatory name attribute missing for permission tag");
1639                     XmlUtils.skipCurrentTag(parser);
1640                     continue;
1641                 }
1642 
1643                 // If the trunkstable feature flag is disabled for this
1644                 // exception, skip the tag.
1645                 if (ParsingPackageUtils.getAconfigFlags().skipCurrentElement(
1646                         /* pkg= */ null, parser, /* allowNoNamespace= */ true)) {
1647                     XmlUtils.skipCurrentTag(parser);
1648                     continue;
1649                 }
1650 
1651                 final boolean fixed =
1652                         parser.getAttributeBoolean(null, ATTR_FIXED, false);
1653                 final boolean whitelisted =
1654                         parser.getAttributeBoolean(null, ATTR_WHITELISTED, false);
1655 
1656                 DefaultPermissionGrant exception = new DefaultPermissionGrant(
1657                         name, fixed, whitelisted);
1658                 outPackageExceptions.add(exception);
1659             } else {
1660                 Log.e(TAG, "Unknown tag " + parser.getName() + "under <exception>");
1661             }
1662         }
1663     }
1664 
isSystemOrCertificateMatchingPackage(PackageInfo pi, String cert)1665     private boolean isSystemOrCertificateMatchingPackage(PackageInfo pi, String cert) {
1666         if (cert == null) {
1667             return pi.applicationInfo.isSystemApp();
1668         } else if (Objects.equals(cert, "platform")) {
1669             return mServiceInternal.isPlatformSigned(pi.packageName);
1670         } else {
1671             return mContext.getPackageManager().hasSigningCertificate(pi.packageName, HexEncoding.
1672                     decode(cert.replace(":", "")), PackageManager.CERT_INPUT_SHA256);
1673         }
1674     }
1675 
doesPackageSupportRuntimePermissions(PackageInfo pkg)1676     private static boolean doesPackageSupportRuntimePermissions(PackageInfo pkg) {
1677         return pkg.applicationInfo != null
1678                 && pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1;
1679     }
1680 
1681     /**
1682      * A wrapper for package manager calls done by this class
1683      */
1684     private abstract class PackageManagerWrapper {
getPermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1685         abstract int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1686                 @NonNull UserHandle user);
1687 
updatePermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, int flagMask, int flagValues, @NonNull UserHandle user)1688         abstract void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1689                 int flagMask, int flagValues, @NonNull UserHandle user);
1690 
grantPermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1691         abstract void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
1692                 @NonNull UserHandle user);
1693 
revokePermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1694         abstract void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
1695                 @NonNull UserHandle user);
1696 
isGranted(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1697         abstract boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
1698                 @NonNull UserHandle user);
1699 
getPermissionInfo(@onNull String permissionName)1700         abstract @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName);
1701 
getPackageInfo(@onNull String pkg)1702         abstract @Nullable PackageInfo getPackageInfo(@NonNull String pkg);
1703 
getSystemPackageInfo(@onNull String pkg)1704         @Nullable PackageInfo getSystemPackageInfo(@NonNull String pkg) {
1705             PackageInfo pi = getPackageInfo(pkg);
1706             if (pi == null || !pi.applicationInfo.isSystemApp()) {
1707                 return null;
1708             }
1709             return pi;
1710         }
1711 
isPermissionRestricted(@onNull String name)1712         boolean isPermissionRestricted(@NonNull String name) {
1713             PermissionInfo pi = getPermissionInfo(name);
1714             if (pi == null) {
1715                 return false;
1716             }
1717 
1718             return pi.isRestricted();
1719         }
1720 
isPermissionDangerous(@onNull String name)1721         boolean isPermissionDangerous(@NonNull String name) {
1722             PermissionInfo pi = getPermissionInfo(name);
1723             if (pi == null) {
1724                 return false;
1725             }
1726 
1727             return pi.getProtection() == PermissionInfo.PROTECTION_DANGEROUS;
1728         }
1729 
1730         /**
1731          * Return the background permission for a permission.
1732          *
1733          * @param permission The name of the foreground permission
1734          *
1735          * @return The name of the background permission or {@code null} if the permission has no
1736          *         background permission
1737          */
getBackgroundPermission(@onNull String permission)1738         @Nullable String getBackgroundPermission(@NonNull String permission) {
1739             PermissionInfo pi = getPermissionInfo(permission);
1740             if (pi == null) {
1741                 return null;
1742             }
1743 
1744             return pi.backgroundPermission;
1745         }
1746 
isSystemPackage(@ullable String packageName)1747         boolean isSystemPackage(@Nullable String packageName) {
1748             return isSystemPackage(getPackageInfo(packageName));
1749         }
1750 
isSystemPackage(@ullable PackageInfo pkg)1751         boolean isSystemPackage(@Nullable PackageInfo pkg) {
1752             if (pkg == null) {
1753                 return false;
1754             }
1755             return pkg.applicationInfo.isSystemApp()
1756                     && !isSysComponentOrPersistentPlatformSignedPrivApp(pkg);
1757         }
1758 
isSysComponentOrPersistentPlatformSignedPrivApp(@onNull PackageInfo pkg)1759         boolean isSysComponentOrPersistentPlatformSignedPrivApp(@NonNull PackageInfo pkg) {
1760             if (UserHandle.getAppId(pkg.applicationInfo.uid) < FIRST_APPLICATION_UID) {
1761                 return true;
1762             }
1763             if (!pkg.applicationInfo.isPrivilegedApp()) {
1764                 return false;
1765             }
1766             final PackageInfo disabledPkg = getSystemPackageInfo(
1767                     mServiceInternal.getDisabledSystemPackageName(pkg.applicationInfo.packageName));
1768             if (disabledPkg != null) {
1769                 ApplicationInfo disabledPackageAppInfo = disabledPkg.applicationInfo;
1770                 if (disabledPackageAppInfo != null
1771                         && (disabledPackageAppInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
1772                     return false;
1773                 }
1774             } else if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
1775                 return false;
1776             }
1777             return mServiceInternal.isPlatformSigned(pkg.packageName);
1778         }
1779     }
1780 
1781     /**
1782      * Do package manager calls but cache state and delay any change until {@link #apply()} is
1783      * called
1784      */
1785     private class DelayingPackageManagerCache extends PackageManagerWrapper {
1786         /** uid -> permission -> isGranted, flags */
1787         private final SparseArray<ArrayMap<String, PermissionState>> mDelayedPermissionState =
1788                 new SparseArray<>();
1789         /** userId -> context */
1790         private final SparseArray<Context> mUserContexts = new SparseArray<>();
1791         /** Permission name -> info */
1792         private final ArrayMap<String, PermissionInfo> mPermissionInfos = new ArrayMap<>();
1793         /** Package name -> info */
1794         private final ArrayMap<String, PackageInfo> mPackageInfos = new ArrayMap<>();
1795 
1796         /**
1797          * Apply the cached state
1798          */
apply()1799         void apply() {
1800             PackageManager.corkPackageInfoCache();
1801             for (int uidIdx = 0; uidIdx < mDelayedPermissionState.size(); uidIdx++) {
1802                 for (int permIdx = 0; permIdx < mDelayedPermissionState.valueAt(uidIdx).size();
1803                         permIdx++) {
1804                     try {
1805                         mDelayedPermissionState.valueAt(uidIdx).valueAt(permIdx).apply();
1806                     } catch (IllegalArgumentException e) {
1807                         Slog.w(TAG, "Cannot set permission " + mDelayedPermissionState.valueAt(
1808                                 uidIdx).keyAt(permIdx) + " of uid " + mDelayedPermissionState.keyAt(
1809                                 uidIdx), e);
1810                     }
1811                 }
1812             }
1813             PackageManager.uncorkPackageInfoCache();
1814         }
1815 
addPackageInfo(@onNull String packageName, @NonNull PackageInfo pkg)1816         void addPackageInfo(@NonNull String packageName, @NonNull PackageInfo pkg) {
1817             mPackageInfos.put(packageName, pkg);
1818         }
1819 
createContextAsUser(@onNull UserHandle user)1820         private @NonNull Context createContextAsUser(@NonNull UserHandle user) {
1821             int index = mUserContexts.indexOfKey(user.getIdentifier());
1822             if (index >= 0) {
1823                 return mUserContexts.valueAt(index);
1824             }
1825 
1826             Context uc = mContext.createContextAsUser(user, 0);
1827 
1828             mUserContexts.put(user.getIdentifier(), uc);
1829 
1830             return uc;
1831         }
1832 
getPermissionState(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1833         private @NonNull PermissionState getPermissionState(@NonNull String permission,
1834                 @NonNull PackageInfo pkg, @NonNull UserHandle user) {
1835             int uid = UserHandle.getUid(user.getIdentifier(),
1836                     UserHandle.getAppId(pkg.applicationInfo.uid));
1837             int uidIdx = mDelayedPermissionState.indexOfKey(uid);
1838 
1839             ArrayMap<String, PermissionState> uidState;
1840             if (uidIdx >= 0) {
1841                 uidState = mDelayedPermissionState.valueAt(uidIdx);
1842             } else {
1843                 uidState = new ArrayMap<>();
1844                 mDelayedPermissionState.put(uid, uidState);
1845             }
1846 
1847             int permIdx = uidState.indexOfKey(permission);
1848 
1849             PermissionState permState;
1850             if (permIdx >= 0) {
1851                 permState = uidState.valueAt(permIdx);
1852                 // Quick and dirty fix for shared UID packages - we should grant permission with the
1853                 // correct package even if a previous checkPermission() used a package that isn't
1854                 // requesting the permission. Ideally we should use package manager snapshot and get
1855                 // rid of this entire inner class.
1856                 if (!ArrayUtils.contains(permState.mPkgRequestingPerm.requestedPermissions,
1857                         permission) && ArrayUtils.contains(pkg.requestedPermissions,
1858                         permission)) {
1859                     permState.mPkgRequestingPerm = pkg;
1860                 }
1861             } else {
1862                 permState = new PermissionState(permission, pkg, user);
1863                 uidState.put(permission, permState);
1864             }
1865 
1866             return permState;
1867         }
1868 
1869         @Override
getPermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1870         public int getPermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1871                 @NonNull UserHandle user) {
1872             PermissionState state = getPermissionState(permission, pkg, user);
1873             state.initFlags();
1874             return state.newFlags;
1875         }
1876 
1877         @Override
updatePermissionFlags(@onNull String permission, @NonNull PackageInfo pkg, int flagMask, int flagValues, @NonNull UserHandle user)1878         public void updatePermissionFlags(@NonNull String permission, @NonNull PackageInfo pkg,
1879                 int flagMask, int flagValues, @NonNull UserHandle user) {
1880             PermissionState state = getPermissionState(permission, pkg, user);
1881             state.initFlags();
1882             state.newFlags = (state.newFlags & ~flagMask) | (flagValues & flagMask);
1883         }
1884 
1885         @Override
grantPermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1886         public void grantPermission(@NonNull String permission, @NonNull PackageInfo pkg,
1887                 @NonNull UserHandle user) {
1888             if (PermissionManager.DEBUG_TRACE_GRANTS
1889                     && PermissionManager.shouldTraceGrant(
1890                     pkg.packageName, permission, user.getIdentifier())) {
1891                 Log.i(PermissionManager.LOG_TAG_TRACE_GRANTS,
1892                         "PregrantPolicy is granting " + pkg.packageName + " "
1893                                 + permission + " for user " + user.getIdentifier(),
1894                         new RuntimeException());
1895             }
1896             PermissionState state = getPermissionState(permission, pkg, user);
1897             state.initGranted();
1898             state.newGranted = true;
1899         }
1900 
1901         @Override
revokePermission(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1902         public void revokePermission(@NonNull String permission, @NonNull PackageInfo pkg,
1903                 @NonNull UserHandle user) {
1904             PermissionState state = getPermissionState(permission, pkg, user);
1905             state.initGranted();
1906             state.newGranted = false;
1907         }
1908 
1909         @Override
isGranted(@onNull String permission, @NonNull PackageInfo pkg, @NonNull UserHandle user)1910         public boolean isGranted(@NonNull String permission, @NonNull PackageInfo pkg,
1911                 @NonNull UserHandle user) {
1912             PermissionState state = getPermissionState(permission, pkg, user);
1913             state.initGranted();
1914             return state.newGranted;
1915         }
1916 
1917         @Override
getPermissionInfo(@onNull String permissionName)1918         public @Nullable PermissionInfo getPermissionInfo(@NonNull String permissionName) {
1919             int index = mPermissionInfos.indexOfKey(permissionName);
1920             if (index >= 0) {
1921                 return mPermissionInfos.valueAt(index);
1922             }
1923 
1924             PermissionInfo pi = NO_PM_CACHE.getPermissionInfo(permissionName);
1925             mPermissionInfos.put(permissionName, pi);
1926 
1927             return pi;
1928         }
1929 
1930         @Override
getPackageInfo(@onNull String pkg)1931         public @Nullable PackageInfo getPackageInfo(@NonNull String pkg) {
1932             int index = mPackageInfos.indexOfKey(pkg);
1933             if (index >= 0) {
1934                 return mPackageInfos.valueAt(index);
1935             }
1936 
1937             PackageInfo pi = NO_PM_CACHE.getPackageInfo(pkg);
1938             mPackageInfos.put(pkg, pi);
1939 
1940             return pi;
1941         }
1942 
1943         /**
1944          * State of a single permission belonging to a single uid
1945          */
1946         private class PermissionState {
1947             private final @NonNull String mPermission;
1948             private @NonNull PackageInfo mPkgRequestingPerm;
1949             private final @NonNull UserHandle mUser;
1950 
1951             /** Permission flags when the state was created */
1952             private @Nullable Integer mOriginalFlags;
1953             /** Altered permission flags or {@code null} if no change was requested */
1954             @Nullable Integer newFlags;
1955 
1956             /** Grant state when the state was created */
1957             private @Nullable Boolean mOriginalGranted;
1958             /** Altered grant state or {@code null} if no change was requested */
1959             @Nullable Boolean newGranted;
1960 
PermissionState(@onNull String permission, @NonNull PackageInfo pkgRequestingPerm, @NonNull UserHandle user)1961             private PermissionState(@NonNull String permission,
1962                     @NonNull PackageInfo pkgRequestingPerm, @NonNull UserHandle user) {
1963                 mPermission = permission;
1964                 mPkgRequestingPerm = pkgRequestingPerm;
1965                 mUser = user;
1966             }
1967 
1968             /**
1969              * Apply the changes to the permission to the system
1970              */
apply()1971             void apply() {
1972                 if (DEBUG) {
1973                     Slog.i(TAG, "Granting " + mPermission + " to user " + mUser.getIdentifier()
1974                             + " pkg=" + mPkgRequestingPerm.packageName + " granted=" + newGranted
1975                             + " flags=" + Integer.toBinaryString(newFlags));
1976                 }
1977 
1978                 int flagsToAdd = 0;
1979                 int flagsToRemove = 0;
1980                 if (newFlags != null) {
1981                     flagsToAdd = newFlags & ~mOriginalFlags;
1982                     flagsToRemove = mOriginalFlags & ~newFlags;
1983                 }
1984 
1985                 // Need to remove e.g. SYSTEM_FIXED flags first as otherwise permission cannot be
1986                 // changed
1987                 if (flagsToRemove != 0) {
1988                     NO_PM_CACHE.updatePermissionFlags(mPermission, mPkgRequestingPerm,
1989                             flagsToRemove, 0, mUser);
1990                 }
1991 
1992                 // Need to unrestrict first as otherwise permission grants might fail
1993                 if ((flagsToAdd & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT) != 0) {
1994                     int newRestrictionExcemptFlags =
1995                             flagsToAdd & PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT;
1996 
1997                     NO_PM_CACHE.updatePermissionFlags(mPermission,
1998                             mPkgRequestingPerm, newRestrictionExcemptFlags, -1, mUser);
1999                 }
2000 
2001                 if (newGranted != null && !Objects.equals(newGranted, mOriginalGranted)) {
2002                     if (newGranted) {
2003                         NO_PM_CACHE.grantPermission(mPermission, mPkgRequestingPerm, mUser);
2004                     } else {
2005                         NO_PM_CACHE.revokePermission(mPermission, mPkgRequestingPerm, mUser);
2006                     }
2007                 }
2008 
2009                 if ((flagsToAdd & ~PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT) != 0) {
2010                     int newFlags =
2011                             flagsToAdd & ~PackageManager.FLAGS_PERMISSION_RESTRICTION_ANY_EXEMPT;
2012 
2013                     NO_PM_CACHE.updatePermissionFlags(mPermission, mPkgRequestingPerm, newFlags,
2014                             -1, mUser);
2015                 }
2016             }
2017 
2018             /**
2019              * Load the state of the flags before first use
2020              */
initFlags()2021             void initFlags() {
2022                 if (newFlags == null) {
2023                     mOriginalFlags = NO_PM_CACHE.getPermissionFlags(mPermission, mPkgRequestingPerm,
2024                             mUser);
2025                     newFlags = mOriginalFlags;
2026                 }
2027             }
2028 
2029             /**
2030              * Load the grant state before first use
2031              */
initGranted()2032             void initGranted() {
2033                 if (newGranted == null) {
2034                     // Don't call NO_PM_CACHE here so that contexts are reused
2035                     mOriginalGranted = createContextAsUser(mUser).getPackageManager()
2036                             .checkPermission(mPermission, mPkgRequestingPerm.packageName)
2037                             == PackageManager.PERMISSION_GRANTED;
2038                     newGranted = mOriginalGranted;
2039                 }
2040             }
2041         }
2042     }
2043 
2044     private static final class DefaultPermissionGrant {
2045         final String name;
2046         final boolean fixed;
2047         final boolean whitelisted;
2048 
DefaultPermissionGrant(String name, boolean fixed, boolean whitelisted)2049         public DefaultPermissionGrant(String name, boolean fixed,
2050                 boolean whitelisted) {
2051             this.name = name;
2052             this.fixed = fixed;
2053             this.whitelisted = whitelisted;
2054         }
2055     }
2056 }
2057