2 * Copyright (C) 2015 The Android Open Source Project
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
8 * http://www.apache.org/licenses/LICENSE-2.0
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.
17 package com.android.server.pm;
19 import android.Manifest;
20 import android.app.DownloadManager;
21 import android.app.admin.DevicePolicyManager;
22 import android.content.Intent;
23 import android.content.pm.ApplicationInfo;
24 import android.content.pm.PackageManager;
25 import android.content.pm.PackageManagerInternal.PackagesProvider;
26 import android.content.pm.PackageManagerInternal.SyncAdapterPackagesProvider;
27 import android.content.pm.PackageParser;
28 import android.content.pm.ProviderInfo;
29 import android.content.pm.ResolveInfo;
30 import android.net.Uri;
31 import android.os.Build;
32 import android.os.UserHandle;
33 import android.provider.CalendarContract;
34 import android.provider.ContactsContract;
35 import android.provider.MediaStore;
36 import android.provider.Telephony.Sms.Intents;
37 import android.util.ArraySet;
38 import android.util.Log;
41 import java.util.ArrayList;
42 import java.util.List;
45 import static android.os.Process.FIRST_APPLICATION_UID;
48 * This class is the policy for granting runtime permissions to
49 * platform components and default handlers in the system such
50 * that the device is usable out-of-the-box. For example, the
51 * shell UID is a part of the system and the Phone app should
52 * have phone related permission by default.
54 final class DefaultPermissionGrantPolicy {
55 private static final String TAG = "DefaultPermGrantPolicy"; // must be <= 23 chars
56 private static final boolean DEBUG = false;
58 private static final String AUDIO_MIME_TYPE = "audio/mpeg";
60 private static final Set<String> PHONE_PERMISSIONS = new ArraySet<>();
62 PHONE_PERMISSIONS.add(Manifest.permission.READ_PHONE_STATE);
63 PHONE_PERMISSIONS.add(Manifest.permission.CALL_PHONE);
64 PHONE_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);
65 PHONE_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);
66 PHONE_PERMISSIONS.add(Manifest.permission.ADD_VOICEMAIL);
67 PHONE_PERMISSIONS.add(Manifest.permission.USE_SIP);
68 PHONE_PERMISSIONS.add(Manifest.permission.PROCESS_OUTGOING_CALLS);
71 private static final Set<String> CONTACTS_PERMISSIONS = new ArraySet<>();
73 CONTACTS_PERMISSIONS.add(Manifest.permission.READ_CONTACTS);
74 CONTACTS_PERMISSIONS.add(Manifest.permission.WRITE_CONTACTS);
75 CONTACTS_PERMISSIONS.add(Manifest.permission.GET_ACCOUNTS);
78 private static final Set<String> LOCATION_PERMISSIONS = new ArraySet<>();
80 LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
81 LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
84 private static final Set<String> CALENDAR_PERMISSIONS = new ArraySet<>();
86 CALENDAR_PERMISSIONS.add(Manifest.permission.READ_CALENDAR);
87 CALENDAR_PERMISSIONS.add(Manifest.permission.WRITE_CALENDAR);
90 private static final Set<String> SMS_PERMISSIONS = new ArraySet<>();
92 SMS_PERMISSIONS.add(Manifest.permission.SEND_SMS);
93 SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_SMS);
94 SMS_PERMISSIONS.add(Manifest.permission.READ_SMS);
95 SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_WAP_PUSH);
96 SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_MMS);
97 SMS_PERMISSIONS.add(Manifest.permission.READ_CELL_BROADCASTS);
100 private static final Set<String> MICROPHONE_PERMISSIONS = new ArraySet<>();
102 MICROPHONE_PERMISSIONS.add(Manifest.permission.RECORD_AUDIO);
105 private static final Set<String> CAMERA_PERMISSIONS = new ArraySet<>();
107 CAMERA_PERMISSIONS.add(Manifest.permission.CAMERA);
110 private static final Set<String> SENSORS_PERMISSIONS = new ArraySet<>();
112 SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS);
115 private static final Set<String> STORAGE_PERMISSIONS = new ArraySet<>();
117 STORAGE_PERMISSIONS.add(Manifest.permission.READ_EXTERNAL_STORAGE);
118 STORAGE_PERMISSIONS.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
121 private final PackageManagerService mService;
123 private PackagesProvider mImePackagesProvider;
124 private PackagesProvider mLocationPackagesProvider;
125 private PackagesProvider mVoiceInteractionPackagesProvider;
126 private PackagesProvider mSmsAppPackagesProvider;
127 private PackagesProvider mDialerAppPackagesProvider;
128 private SyncAdapterPackagesProvider mSyncAdapterPackagesProvider;
130 public DefaultPermissionGrantPolicy(PackageManagerService service) {
134 public void setImePackagesProviderLPr(PackagesProvider provider) {
135 mImePackagesProvider = provider;
138 public void setLocationPackagesProviderLPw(PackagesProvider provider) {
139 mLocationPackagesProvider = provider;
142 public void setVoiceInteractionPackagesProviderLPw(PackagesProvider provider) {
143 mVoiceInteractionPackagesProvider = provider;
146 public void setSmsAppPackagesProviderLPw(PackagesProvider provider) {
147 mSmsAppPackagesProvider = provider;
150 public void setDialerAppPackagesProviderLPw(PackagesProvider provider) {
151 mDialerAppPackagesProvider = provider;
154 public void setSyncAdapterPackagesProviderLPw(SyncAdapterPackagesProvider provider) {
155 mSyncAdapterPackagesProvider = provider;
158 public void grantDefaultPermissions(int userId) {
159 grantPermissionsToSysComponentsAndPrivApps(userId);
160 grantDefaultSystemHandlerPermissions(userId);
163 private void grantPermissionsToSysComponentsAndPrivApps(int userId) {
164 Log.i(TAG, "Granting permissions to platform components for user " + userId);
166 synchronized (mService.mPackages) {
167 for (PackageParser.Package pkg : mService.mPackages.values()) {
168 if (!isSysComponentOrPersistentPlatformSignedPrivApp(pkg)
169 || !doesPackageSupportRuntimePermissions(pkg)) {
172 final int permissionCount = pkg.requestedPermissions.size();
173 for (int i = 0; i < permissionCount; i++) {
174 String permission = pkg.requestedPermissions.get(i);
175 BasePermission bp = mService.mSettings.mPermissions.get(permission);
176 if (bp != null && bp.isRuntime()) {
177 final int flags = mService.getPermissionFlags(permission,
178 pkg.packageName, userId);
179 if ((flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) == 0) {
180 mService.grantRuntimePermission(pkg.packageName, permission, userId);
181 mService.updatePermissionFlags(permission, pkg.packageName,
182 PackageManager.MASK_PERMISSION_FLAGS,
183 PackageManager.FLAG_PERMISSION_SYSTEM_FIXED
184 | PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT, userId);
186 Log.i(TAG, "Granted " + permission + " to system component "
196 private void grantDefaultSystemHandlerPermissions(int userId) {
197 Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);
199 final PackagesProvider imePackagesProvider;
200 final PackagesProvider locationPackagesProvider;
201 final PackagesProvider voiceInteractionPackagesProvider;
202 final PackagesProvider smsAppPackagesProvider;
203 final PackagesProvider dialerAppPackagesProvider;
204 final SyncAdapterPackagesProvider syncAdapterPackagesProvider;
206 synchronized (mService.mPackages) {
207 imePackagesProvider = mImePackagesProvider;
208 locationPackagesProvider = mLocationPackagesProvider;
209 voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;
210 smsAppPackagesProvider = mSmsAppPackagesProvider;
211 dialerAppPackagesProvider = mDialerAppPackagesProvider;
212 syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;
215 String[] imePackageNames = (imePackagesProvider != null)
216 ? imePackagesProvider.getPackages(userId) : null;
217 String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)
218 ? voiceInteractionPackagesProvider.getPackages(userId) : null;
219 String[] locationPackageNames = (locationPackagesProvider != null)
220 ? locationPackagesProvider.getPackages(userId) : null;
221 String[] smsAppPackageNames = (smsAppPackagesProvider != null)
222 ? smsAppPackagesProvider.getPackages(userId) : null;
223 String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)
224 ? dialerAppPackagesProvider.getPackages(userId) : null;
225 String[] contactsSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
226 syncAdapterPackagesProvider.getPackages(ContactsContract.AUTHORITY, userId) : null;
227 String[] calendarSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?
228 syncAdapterPackagesProvider.getPackages(CalendarContract.AUTHORITY, userId) : null;
230 synchronized (mService.mPackages) {
232 PackageParser.Package installerPackage = getSystemPackageLPr(
233 mService.mRequiredInstallerPackage);
234 if (installerPackage != null
235 && doesPackageSupportRuntimePermissions(installerPackage)) {
236 grantRuntimePermissionsLPw(installerPackage, STORAGE_PERMISSIONS, true, userId);
240 PackageParser.Package verifierPackage = getSystemPackageLPr(
241 mService.mRequiredVerifierPackage);
242 if (verifierPackage != null
243 && doesPackageSupportRuntimePermissions(verifierPackage)) {
244 grantRuntimePermissionsLPw(verifierPackage, STORAGE_PERMISSIONS, true, userId);
248 Intent setupIntent = new Intent(Intent.ACTION_MAIN);
249 setupIntent.addCategory(Intent.CATEGORY_SETUP_WIZARD);
250 PackageParser.Package setupPackage = getDefaultSystemHandlerActivityPackageLPr(
251 setupIntent, userId);
252 if (setupPackage != null
253 && doesPackageSupportRuntimePermissions(setupPackage)) {
254 grantRuntimePermissionsLPw(setupPackage, PHONE_PERMISSIONS, userId);
255 grantRuntimePermissionsLPw(setupPackage, CONTACTS_PERMISSIONS, userId);
259 Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
260 PackageParser.Package cameraPackage = getDefaultSystemHandlerActivityPackageLPr(
261 cameraIntent, userId);
262 if (cameraPackage != null
263 && doesPackageSupportRuntimePermissions(cameraPackage)) {
264 grantRuntimePermissionsLPw(cameraPackage, CAMERA_PERMISSIONS, userId);
265 grantRuntimePermissionsLPw(cameraPackage, MICROPHONE_PERMISSIONS, userId);
266 grantRuntimePermissionsLPw(cameraPackage, STORAGE_PERMISSIONS, userId);
270 PackageParser.Package mediaStorePackage = getDefaultProviderAuthorityPackageLPr(
271 MediaStore.AUTHORITY, userId);
272 if (mediaStorePackage != null) {
273 grantRuntimePermissionsLPw(mediaStorePackage, STORAGE_PERMISSIONS, true, userId);
276 // Downloads provider
277 PackageParser.Package downloadsPackage = getDefaultProviderAuthorityPackageLPr(
278 "downloads", userId);
279 if (downloadsPackage != null) {
280 grantRuntimePermissionsLPw(downloadsPackage, STORAGE_PERMISSIONS, true, userId);
284 Intent downloadsUiIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
285 PackageParser.Package downloadsUiPackage = getDefaultSystemHandlerActivityPackageLPr(
286 downloadsUiIntent, userId);
287 if (downloadsUiPackage != null
288 && doesPackageSupportRuntimePermissions(downloadsUiPackage)) {
289 grantRuntimePermissionsLPw(downloadsUiPackage, STORAGE_PERMISSIONS, true, userId);
293 PackageParser.Package storagePackage = getDefaultProviderAuthorityPackageLPr(
294 "com.android.externalstorage.documents", userId);
295 if (storagePackage != null) {
296 grantRuntimePermissionsLPw(storagePackage, STORAGE_PERMISSIONS, userId);
300 if (dialerAppPackageNames == null) {
301 Intent dialerIntent = new Intent(Intent.ACTION_DIAL);
302 PackageParser.Package dialerPackage = getDefaultSystemHandlerActivityPackageLPr(
303 dialerIntent, userId);
304 if (dialerPackage != null) {
305 grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);
308 for (String dialerAppPackageName : dialerAppPackageNames) {
309 PackageParser.Package dialerPackage = getSystemPackageLPr(dialerAppPackageName);
310 if (dialerPackage != null) {
311 grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);
317 if (smsAppPackageNames == null) {
318 Intent smsIntent = new Intent(Intent.ACTION_MAIN);
319 smsIntent.addCategory(Intent.CATEGORY_APP_MESSAGING);
320 PackageParser.Package smsPackage = getDefaultSystemHandlerActivityPackageLPr(
322 if (smsPackage != null) {
323 grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);
326 for (String smsPackageName : smsAppPackageNames) {
327 PackageParser.Package smsPackage = getSystemPackageLPr(smsPackageName);
328 if (smsPackage != null) {
329 grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);
334 // Cell Broadcast Receiver
335 Intent cbrIntent = new Intent(Intents.SMS_CB_RECEIVED_ACTION);
336 PackageParser.Package cbrPackage =
337 getDefaultSystemHandlerActivityPackageLPr(cbrIntent, userId);
338 if (cbrPackage != null && doesPackageSupportRuntimePermissions(cbrPackage)) {
339 grantRuntimePermissionsLPw(cbrPackage, SMS_PERMISSIONS, false, userId);
343 Intent calendarIntent = new Intent(Intent.ACTION_MAIN);
344 calendarIntent.addCategory(Intent.CATEGORY_APP_CALENDAR);
345 PackageParser.Package calendarPackage = getDefaultSystemHandlerActivityPackageLPr(
346 calendarIntent, userId);
347 if (calendarPackage != null
348 && doesPackageSupportRuntimePermissions(calendarPackage)) {
349 grantRuntimePermissionsLPw(calendarPackage, CALENDAR_PERMISSIONS, userId);
350 grantRuntimePermissionsLPw(calendarPackage, CONTACTS_PERMISSIONS, userId);
354 PackageParser.Package calendarProviderPackage = getDefaultProviderAuthorityPackageLPr(
355 CalendarContract.AUTHORITY, userId);
356 if (calendarProviderPackage != null) {
357 grantRuntimePermissionsLPw(calendarProviderPackage, CONTACTS_PERMISSIONS, userId);
358 grantRuntimePermissionsLPw(calendarProviderPackage, CALENDAR_PERMISSIONS,
360 grantRuntimePermissionsLPw(calendarProviderPackage, STORAGE_PERMISSIONS, userId);
363 // Calendar provider sync adapters
364 List<PackageParser.Package> calendarSyncAdapters = getHeadlessSyncAdapterPackagesLPr(
365 calendarSyncAdapterPackages, userId);
366 final int calendarSyncAdapterCount = calendarSyncAdapters.size();
367 for (int i = 0; i < calendarSyncAdapterCount; i++) {
368 PackageParser.Package calendarSyncAdapter = calendarSyncAdapters.get(i);
369 if (doesPackageSupportRuntimePermissions(calendarSyncAdapter)) {
370 grantRuntimePermissionsLPw(calendarSyncAdapter, CALENDAR_PERMISSIONS, userId);
375 Intent contactsIntent = new Intent(Intent.ACTION_MAIN);
376 contactsIntent.addCategory(Intent.CATEGORY_APP_CONTACTS);
377 PackageParser.Package contactsPackage = getDefaultSystemHandlerActivityPackageLPr(
378 contactsIntent, userId);
379 if (contactsPackage != null
380 && doesPackageSupportRuntimePermissions(contactsPackage)) {
381 grantRuntimePermissionsLPw(contactsPackage, CONTACTS_PERMISSIONS, userId);
382 grantRuntimePermissionsLPw(contactsPackage, PHONE_PERMISSIONS, userId);
385 // Contacts provider sync adapters
386 List<PackageParser.Package> contactsSyncAdapters = getHeadlessSyncAdapterPackagesLPr(
387 contactsSyncAdapterPackages, userId);
388 final int contactsSyncAdapterCount = contactsSyncAdapters.size();
389 for (int i = 0; i < contactsSyncAdapterCount; i++) {
390 PackageParser.Package contactsSyncAdapter = contactsSyncAdapters.get(i);
391 if (doesPackageSupportRuntimePermissions(contactsSyncAdapter)) {
392 grantRuntimePermissionsLPw(contactsSyncAdapter, CONTACTS_PERMISSIONS, userId);
397 PackageParser.Package contactsProviderPackage = getDefaultProviderAuthorityPackageLPr(
398 ContactsContract.AUTHORITY, userId);
399 if (contactsProviderPackage != null) {
400 grantRuntimePermissionsLPw(contactsProviderPackage, CONTACTS_PERMISSIONS,
402 grantRuntimePermissionsLPw(contactsProviderPackage, PHONE_PERMISSIONS,
404 grantRuntimePermissionsLPw(contactsProviderPackage, STORAGE_PERMISSIONS, userId);
407 // Device provisioning
408 Intent deviceProvisionIntent = new Intent(
409 DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE);
410 PackageParser.Package deviceProvisionPackage =
411 getDefaultSystemHandlerActivityPackageLPr(deviceProvisionIntent, userId);
412 if (deviceProvisionPackage != null
413 && doesPackageSupportRuntimePermissions(deviceProvisionPackage)) {
414 grantRuntimePermissionsLPw(deviceProvisionPackage, CONTACTS_PERMISSIONS, userId);
418 Intent mapsIntent = new Intent(Intent.ACTION_MAIN);
419 mapsIntent.addCategory(Intent.CATEGORY_APP_MAPS);
420 PackageParser.Package mapsPackage = getDefaultSystemHandlerActivityPackageLPr(
422 if (mapsPackage != null
423 && doesPackageSupportRuntimePermissions(mapsPackage)) {
424 grantRuntimePermissionsLPw(mapsPackage, LOCATION_PERMISSIONS, userId);
428 Intent galleryIntent = new Intent(Intent.ACTION_MAIN);
429 galleryIntent.addCategory(Intent.CATEGORY_APP_GALLERY);
430 PackageParser.Package galleryPackage = getDefaultSystemHandlerActivityPackageLPr(
431 galleryIntent, userId);
432 if (galleryPackage != null
433 && doesPackageSupportRuntimePermissions(galleryPackage)) {
434 grantRuntimePermissionsLPw(galleryPackage, STORAGE_PERMISSIONS, userId);
438 Intent emailIntent = new Intent(Intent.ACTION_MAIN);
439 emailIntent.addCategory(Intent.CATEGORY_APP_EMAIL);
440 PackageParser.Package emailPackage = getDefaultSystemHandlerActivityPackageLPr(
441 emailIntent, userId);
442 if (emailPackage != null
443 && doesPackageSupportRuntimePermissions(emailPackage)) {
444 grantRuntimePermissionsLPw(emailPackage, CONTACTS_PERMISSIONS, userId);
448 PackageParser.Package browserPackage = null;
449 String defaultBrowserPackage = mService.getDefaultBrowserPackageName(userId);
450 if (defaultBrowserPackage != null) {
451 browserPackage = getPackageLPr(defaultBrowserPackage);
453 if (browserPackage == null) {
454 Intent browserIntent = new Intent(Intent.ACTION_MAIN);
455 browserIntent.addCategory(Intent.CATEGORY_APP_BROWSER);
456 browserPackage = getDefaultSystemHandlerActivityPackageLPr(
457 browserIntent, userId);
459 if (browserPackage != null
460 && doesPackageSupportRuntimePermissions(browserPackage)) {
461 grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, userId);
465 if (imePackageNames != null) {
466 for (String imePackageName : imePackageNames) {
467 PackageParser.Package imePackage = getSystemPackageLPr(imePackageName);
468 if (imePackage != null
469 && doesPackageSupportRuntimePermissions(imePackage)) {
470 grantRuntimePermissionsLPw(imePackage, CONTACTS_PERMISSIONS, userId);
476 if (voiceInteractPackageNames != null) {
477 for (String voiceInteractPackageName : voiceInteractPackageNames) {
478 PackageParser.Package voiceInteractPackage = getSystemPackageLPr(
479 voiceInteractPackageName);
480 if (voiceInteractPackage != null
481 && doesPackageSupportRuntimePermissions(voiceInteractPackage)) {
482 grantRuntimePermissionsLPw(voiceInteractPackage,
483 CONTACTS_PERMISSIONS, userId);
484 grantRuntimePermissionsLPw(voiceInteractPackage,
485 CALENDAR_PERMISSIONS, userId);
486 grantRuntimePermissionsLPw(voiceInteractPackage,
487 MICROPHONE_PERMISSIONS, userId);
488 grantRuntimePermissionsLPw(voiceInteractPackage,
489 PHONE_PERMISSIONS, userId);
490 grantRuntimePermissionsLPw(voiceInteractPackage,
491 SMS_PERMISSIONS, userId);
492 grantRuntimePermissionsLPw(voiceInteractPackage,
493 LOCATION_PERMISSIONS, userId);
499 if (locationPackageNames != null) {
500 for (String packageName : locationPackageNames) {
501 PackageParser.Package locationPackage = getSystemPackageLPr(packageName);
502 if (locationPackage != null
503 && doesPackageSupportRuntimePermissions(locationPackage)) {
504 grantRuntimePermissionsLPw(locationPackage, CONTACTS_PERMISSIONS, userId);
505 grantRuntimePermissionsLPw(locationPackage, CALENDAR_PERMISSIONS, userId);
506 grantRuntimePermissionsLPw(locationPackage, MICROPHONE_PERMISSIONS, userId);
507 grantRuntimePermissionsLPw(locationPackage, PHONE_PERMISSIONS, userId);
508 grantRuntimePermissionsLPw(locationPackage, SMS_PERMISSIONS, userId);
509 grantRuntimePermissionsLPw(locationPackage, LOCATION_PERMISSIONS,
511 grantRuntimePermissionsLPw(locationPackage, CAMERA_PERMISSIONS, userId);
512 grantRuntimePermissionsLPw(locationPackage, SENSORS_PERMISSIONS, userId);
513 grantRuntimePermissionsLPw(locationPackage, STORAGE_PERMISSIONS, userId);
519 Intent musicIntent = new Intent(Intent.ACTION_VIEW);
520 musicIntent.addCategory(Intent.CATEGORY_DEFAULT);
521 musicIntent.setDataAndType(Uri.fromFile(new File("foo.mp3")),
523 PackageParser.Package musicPackage = getDefaultSystemHandlerActivityPackageLPr(
524 musicIntent, userId);
525 if (musicPackage != null
526 && doesPackageSupportRuntimePermissions(musicPackage)) {
527 grantRuntimePermissionsLPw(musicPackage, STORAGE_PERMISSIONS, userId);
530 mService.mSettings.onDefaultRuntimePermissionsGrantedLPr(userId);
534 private void grantDefaultPermissionsToDefaultSystemDialerAppLPr(
535 PackageParser.Package dialerPackage, int userId) {
536 if (doesPackageSupportRuntimePermissions(dialerPackage)) {
537 grantRuntimePermissionsLPw(dialerPackage, PHONE_PERMISSIONS, userId);
538 grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, userId);
539 grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, userId);
540 grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, userId);
545 private void grantDefaultPermissionsToDefaultSystemSmsAppLPr(
546 PackageParser.Package smsPackage, int userId) {
547 if (doesPackageSupportRuntimePermissions(smsPackage)) {
548 grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, userId);
549 grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, userId);
550 grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, userId);
555 public void grantDefaultPermissionsToDefaultSmsAppLPr(String packageName, int userId) {
556 Log.i(TAG, "Granting permissions to default sms app for user:" + userId);
557 if (packageName == null) {
560 PackageParser.Package smsPackage = getPackageLPr(packageName);
561 if (smsPackage != null && doesPackageSupportRuntimePermissions(smsPackage)) {
562 grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, false, true, userId);
563 grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, false, true, userId);
564 grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, false, true, userId);
568 public void grantDefaultPermissionsToDefaultDialerAppLPr(String packageName, int userId) {
569 Log.i(TAG, "Granting permissions to default dialer app for user:" + userId);
570 if (packageName == null) {
573 PackageParser.Package dialerPackage = getPackageLPr(packageName);
574 if (dialerPackage != null
575 && doesPackageSupportRuntimePermissions(dialerPackage)) {
576 grantRuntimePermissionsLPw(dialerPackage, PHONE_PERMISSIONS, false, true, userId);
577 grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, false, true, userId);
578 grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, false, true, userId);
579 grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, false, true, userId);
583 public void grantDefaultPermissionsToEnabledCarrierAppsLPr(String[] packageNames, int userId) {
584 Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);
585 if (packageNames == null) {
588 for (String packageName : packageNames) {
589 PackageParser.Package carrierPackage = getSystemPackageLPr(packageName);
590 if (carrierPackage != null
591 && doesPackageSupportRuntimePermissions(carrierPackage)) {
592 grantRuntimePermissionsLPw(carrierPackage, PHONE_PERMISSIONS, userId);
593 grantRuntimePermissionsLPw(carrierPackage, LOCATION_PERMISSIONS, userId);
598 public void grantDefaultPermissionsToDefaultBrowserLPr(String packageName, int userId) {
599 Log.i(TAG, "Granting permissions to default browser for user:" + userId);
600 if (packageName == null) {
603 PackageParser.Package browserPackage = getSystemPackageLPr(packageName);
604 if (browserPackage != null
605 && doesPackageSupportRuntimePermissions(browserPackage)) {
606 grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, false, false, userId);
610 private PackageParser.Package getDefaultSystemHandlerActivityPackageLPr(
611 Intent intent, int userId) {
612 List<ResolveInfo> handlers = mService.mActivities.queryIntent(intent,
613 intent.resolveType(mService.mContext.getContentResolver()),
614 PackageManager.GET_DISABLED_COMPONENTS, userId);
615 if (handlers == null) {
618 final int handlerCount = handlers.size();
619 for (int i = 0; i < handlerCount; i++) {
620 ResolveInfo handler = handlers.get(i);
621 PackageParser.Package handlerPackage = getSystemPackageLPr(
622 handler.activityInfo.packageName);
623 if (handlerPackage != null) {
624 return handlerPackage;
630 private List<PackageParser.Package> getHeadlessSyncAdapterPackagesLPr(
631 String[] syncAdapterPackageNames, int userId) {
632 List<PackageParser.Package> syncAdapterPackages = new ArrayList<>();
634 Intent homeIntent = new Intent(Intent.ACTION_MAIN);
635 homeIntent.addCategory(Intent.CATEGORY_HOME);
637 for (String syncAdapterPackageName : syncAdapterPackageNames) {
638 homeIntent.setPackage(syncAdapterPackageName);
640 List<ResolveInfo> homeActivities = mService.mActivities.queryIntent(homeIntent,
641 homeIntent.resolveType(mService.mContext.getContentResolver()),
642 PackageManager.GET_DISABLED_COMPONENTS, userId);
643 if (!homeActivities.isEmpty()) {
647 PackageParser.Package syncAdapterPackage = getSystemPackageLPr(syncAdapterPackageName);
648 if (syncAdapterPackage != null) {
649 syncAdapterPackages.add(syncAdapterPackage);
653 return syncAdapterPackages;
656 private PackageParser.Package getDefaultProviderAuthorityPackageLPr(
657 String authority, int userId) {
658 ProviderInfo provider = mService.resolveContentProvider(authority, 0, userId);
659 if (provider != null) {
660 return getSystemPackageLPr(provider.packageName);
665 private PackageParser.Package getPackageLPr(String packageName) {
666 return mService.mPackages.get(packageName);
669 private PackageParser.Package getSystemPackageLPr(String packageName) {
670 PackageParser.Package pkg = getPackageLPr(packageName);
671 if (pkg != null && pkg.isSystemApp()) {
672 return !isSysComponentOrPersistentPlatformSignedPrivApp(pkg) ? pkg : null;
677 private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
679 grantRuntimePermissionsLPw(pkg, permissions, false, false, userId);
682 private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
683 boolean systemFixed, int userId) {
684 grantRuntimePermissionsLPw(pkg, permissions, systemFixed, false, userId);
687 private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
688 boolean systemFixed, boolean overrideUserChoice, int userId) {
689 List<String> requestedPermissions = pkg.requestedPermissions;
691 if (pkg.isUpdatedSystemApp()) {
692 PackageSetting sysPs = mService.mSettings.getDisabledSystemPkgLPr(pkg.packageName);
694 requestedPermissions = sysPs.pkg.requestedPermissions;
698 final int permissionCount = requestedPermissions.size();
699 for (int i = 0; i < permissionCount; i++) {
700 String permission = requestedPermissions.get(i);
701 if (permissions.contains(permission)) {
702 final int flags = mService.getPermissionFlags(permission, pkg.packageName, userId);
704 // If any flags are set to the permission, then it is either set in
705 // its current state by the system or device/profile owner or the user.
706 // In all these cases we do not want to clobber the current state.
707 // Unless the caller wants to override user choices. The override is
708 // to make sure we can grant the needed permission to the default
709 // sms and phone apps after the user chooses this in the UI.
710 if (flags == 0 || overrideUserChoice) {
711 // Never clobber policy or system.
712 final int fixedFlags = PackageManager.FLAG_PERMISSION_SYSTEM_FIXED
713 | PackageManager.FLAG_PERMISSION_POLICY_FIXED;
714 if ((flags & fixedFlags) != 0) {
718 mService.grantRuntimePermission(pkg.packageName, permission, userId);
720 Log.i(TAG, "Granted " + permission + " to default handler "
724 int newFlags = PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
726 newFlags |= PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
729 mService.updatePermissionFlags(permission, pkg.packageName,
730 newFlags, newFlags, userId);
736 private boolean isSysComponentOrPersistentPlatformSignedPrivApp(PackageParser.Package pkg) {
737 if (UserHandle.getAppId(pkg.applicationInfo.uid) < FIRST_APPLICATION_UID) {
740 if ((pkg.applicationInfo.privateFlags & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED) == 0
741 || (pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
744 return PackageManagerService.compareSignatures(mService.mPlatformPackage.mSignatures,
745 pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
748 private static boolean doesPackageSupportRuntimePermissions(PackageParser.Package pkg) {
749 return pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1;