DefaultPermissionGrantPolicy.java revision 23c8292acc0d45a0f19f3ea8107d48cc52d87dc5 
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
17package com.android.server.pm;
18
19import android.Manifest;
20import android.app.DownloadManager;
21import android.app.admin.DevicePolicyManager;
22import android.content.Intent;
23import android.content.pm.ActivityInfo;
24import android.content.pm.ApplicationInfo;
25import android.content.pm.PackageManager;
26import android.content.pm.PackageManagerInternal.PackagesProvider;
27import android.content.pm.PackageManagerInternal.SyncAdapterPackagesProvider;
28import android.content.pm.PackageParser;
29import android.content.pm.ProviderInfo;
30import android.content.pm.ResolveInfo;
31import android.net.Uri;
32import android.os.Build;
33import android.os.UserHandle;
34import android.print.PrintManager;
35import android.provider.CalendarContract;
36import android.provider.ContactsContract;
37import android.provider.MediaStore;
38import android.provider.Telephony.Sms.Intents;
39import android.telephony.TelephonyManager;
40import android.security.Credentials;
41import android.util.ArraySet;
42import android.util.Log;
43
44import java.io.File;
45import java.util.ArrayList;
46import java.util.List;
47import java.util.Set;
48
49import static android.os.Process.FIRST_APPLICATION_UID;
50
51/**
52 * This class is the policy for granting runtime permissions to
53 * platform components and default handlers in the system such
54 * that the device is usable out-of-the-box. For example, the
55 * shell UID is a part of the system and the Phone app should
56 * have phone related permission by default.
57 */
58final class DefaultPermissionGrantPolicy {
59    private static final String TAG = "DefaultPermGrantPolicy"; // must be <= 23 chars
60    private static final boolean DEBUG = false;
61
62    private static final int DEFAULT_FLAGS = PackageManager.MATCH_DIRECT_BOOT_AWARE
63            | PackageManager.MATCH_DIRECT_BOOT_UNAWARE;
64
65    private static final String AUDIO_MIME_TYPE = "audio/mpeg";
66
67    private static final Set<String> PHONE_PERMISSIONS = new ArraySet<>();
68    static {
69        PHONE_PERMISSIONS.add(Manifest.permission.READ_PHONE_STATE);
70        PHONE_PERMISSIONS.add(Manifest.permission.CALL_PHONE);
71        PHONE_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);
72        PHONE_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);
73        PHONE_PERMISSIONS.add(Manifest.permission.ADD_VOICEMAIL);
74        PHONE_PERMISSIONS.add(Manifest.permission.USE_SIP);
75        PHONE_PERMISSIONS.add(Manifest.permission.PROCESS_OUTGOING_CALLS);
76    }
77
78    private static final Set<String> CONTACTS_PERMISSIONS = new ArraySet<>();
79    static {
80        CONTACTS_PERMISSIONS.add(Manifest.permission.READ_CONTACTS);
81        CONTACTS_PERMISSIONS.add(Manifest.permission.WRITE_CONTACTS);
82        CONTACTS_PERMISSIONS.add(Manifest.permission.GET_ACCOUNTS);
83    }
84
85    private static final Set<String> LOCATION_PERMISSIONS = new ArraySet<>();
86    static {
87        LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);
88        LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);
89    }
90
91    private static final Set<String> CALENDAR_PERMISSIONS = new ArraySet<>();
92    static {
93        CALENDAR_PERMISSIONS.add(Manifest.permission.READ_CALENDAR);
94        CALENDAR_PERMISSIONS.add(Manifest.permission.WRITE_CALENDAR);
95    }
96
97    private static final Set<String> SMS_PERMISSIONS = new ArraySet<>();
98    static {
99        SMS_PERMISSIONS.add(Manifest.permission.SEND_SMS);
100        SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_SMS);
101        SMS_PERMISSIONS.add(Manifest.permission.READ_SMS);
102        SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_WAP_PUSH);
103        SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_MMS);
104        SMS_PERMISSIONS.add(Manifest.permission.READ_CELL_BROADCASTS);
105    }
106
107    private static final Set<String> MICROPHONE_PERMISSIONS = new ArraySet<>();
108    static {
109        MICROPHONE_PERMISSIONS.add(Manifest.permission.RECORD_AUDIO);
110    }
111
112    private static final Set<String> CAMERA_PERMISSIONS = new ArraySet<>();
113    static {
114        CAMERA_PERMISSIONS.add(Manifest.permission.CAMERA);
115    }
116
117    private static final Set<String> SENSORS_PERMISSIONS = new ArraySet<>();
118    static {
119        SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS);
120    }
121
122    private static final Set<String> STORAGE_PERMISSIONS = new ArraySet<>();
123    static {
124        STORAGE_PERMISSIONS.add(Manifest.permission.READ_EXTERNAL_STORAGE);
125        STORAGE_PERMISSIONS.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);
126    }
127
128    private final PackageManagerService mService;
129
130    private PackagesProvider mLocationPackagesProvider;
131    private PackagesProvider mVoiceInteractionPackagesProvider;
132    private PackagesProvider mSmsAppPackagesProvider;
133    private PackagesProvider mDialerAppPackagesProvider;
134    private PackagesProvider mSimCallManagerPackagesProvider;
135    private SyncAdapterPackagesProvider mSyncAdapterPackagesProvider;
136
137    public DefaultPermissionGrantPolicy(PackageManagerService service) {
138        mService = service;
139    }
140
141    public void setLocationPackagesProviderLPw(PackagesProvider provider) {
142        mLocationPackagesProvider = provider;
143    }
144
145    public void setVoiceInteractionPackagesProviderLPw(PackagesProvider provider) {
146        mVoiceInteractionPackagesProvider = provider;
147    }
148
149    public void setSmsAppPackagesProviderLPw(PackagesProvider provider) {
150        mSmsAppPackagesProvider = provider;
151    }
152
153    public void setDialerAppPackagesProviderLPw(PackagesProvider provider) {
154        mDialerAppPackagesProvider = provider;
155    }
156
157    public void setSimCallManagerPackagesProviderLPw(PackagesProvider provider) {
158        mSimCallManagerPackagesProvider = provider;
159    }
160
161    public void setSyncAdapterPackagesProviderLPw(SyncAdapterPackagesProvider provider) {
162        mSyncAdapterPackagesProvider = provider;
163    }
164
165    public void grantDefaultPermissions(int userId) {
166        grantPermissionsToSysComponentsAndPrivApps(userId);
167        grantDefaultSystemHandlerPermissions(userId);
168    }
169
170    private void grantPermissionsToSysComponentsAndPrivApps(int userId) {
171        Log.i(TAG, "Granting permissions to platform components for user " + userId);
172
173        synchronized (mService.mPackages) {
174            for (PackageParser.Package pkg : mService.mPackages.values()) {
175                if (!isSysComponentOrPersistentPlatformSignedPrivAppLPr(pkg)
176                        || !doesPackageSupportRuntimePermissions(pkg)
177                        || pkg.requestedPermissions.isEmpty()) {
178                    continue;
179                }
180                Set<String> permissions = new ArraySet<>();
181                final int permissionCount = pkg.requestedPermissions.size();
182                for (int i = 0; i < permissionCount; i++) {
183                    String permission = pkg.requestedPermissions.get(i);
184                    BasePermission bp = mService.mSettings.mPermissions.get(permission);
185                    if (bp != null && bp.isRuntime()) {
186                        permissions.add(permission);
187                    }
188                }
189                if (!permissions.isEmpty()) {
190                    grantRuntimePermissionsLPw(pkg, permissions, true, userId);
191                }
192            }
193        }
194    }
195
196    private void grantDefaultSystemHandlerPermissions(int userId) {
197        Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);
198
199        final PackagesProvider locationPackagesProvider;
200        final PackagesProvider voiceInteractionPackagesProvider;
201        final PackagesProvider smsAppPackagesProvider;
202        final PackagesProvider dialerAppPackagesProvider;
203        final PackagesProvider simCallManagerPackagesProvider;
204        final SyncAdapterPackagesProvider syncAdapterPackagesProvider;
205
206        synchronized (mService.mPackages) {
207            locationPackagesProvider = mLocationPackagesProvider;
208            voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;
209            smsAppPackagesProvider = mSmsAppPackagesProvider;
210            dialerAppPackagesProvider = mDialerAppPackagesProvider;
211            simCallManagerPackagesProvider = mSimCallManagerPackagesProvider;
212            syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;
213        }
214
215        String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)
216                ? voiceInteractionPackagesProvider.getPackages(userId) : null;
217        String[] locationPackageNames = (locationPackagesProvider != null)
218                ? locationPackagesProvider.getPackages(userId) : null;
219        String[] smsAppPackageNames = (smsAppPackagesProvider != null)
220                ? smsAppPackagesProvider.getPackages(userId) : null;
221        String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)
222                ? dialerAppPackagesProvider.getPackages(userId) : null;
223        String[] simCallManagerPackageNames = (simCallManagerPackagesProvider != null)
224                ? simCallManagerPackagesProvider.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;
229
230        synchronized (mService.mPackages) {
231            // Installer
232            PackageParser.Package installerPackage = getSystemPackageLPr(
233                    mService.mRequiredInstallerPackage);
234            if (installerPackage != null
235                    && doesPackageSupportRuntimePermissions(installerPackage)) {
236                grantRuntimePermissionsLPw(installerPackage, STORAGE_PERMISSIONS, true, userId);
237            }
238
239            // Verifier
240            PackageParser.Package verifierPackage = getSystemPackageLPr(
241                    mService.mRequiredVerifierPackage);
242            if (verifierPackage != null
243                    && doesPackageSupportRuntimePermissions(verifierPackage)) {
244                grantRuntimePermissionsLPw(verifierPackage, STORAGE_PERMISSIONS, true, userId);
245                grantRuntimePermissionsLPw(verifierPackage, PHONE_PERMISSIONS, false, userId);
246                grantRuntimePermissionsLPw(verifierPackage, SMS_PERMISSIONS, false, userId);
247            }
248
249            // SetupWizard
250            PackageParser.Package setupPackage = getSystemPackageLPr(
251                    mService.mSetupWizardPackage);
252            if (setupPackage != null
253                    && doesPackageSupportRuntimePermissions(setupPackage)) {
254                grantRuntimePermissionsLPw(setupPackage, PHONE_PERMISSIONS, userId);
255                grantRuntimePermissionsLPw(setupPackage, CONTACTS_PERMISSIONS, userId);
256                grantRuntimePermissionsLPw(setupPackage, LOCATION_PERMISSIONS, userId);
257                grantRuntimePermissionsLPw(setupPackage, CAMERA_PERMISSIONS, userId);
258            }
259
260            // Camera
261            Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
262            PackageParser.Package cameraPackage = getDefaultSystemHandlerActivityPackageLPr(
263                    cameraIntent, userId);
264            if (cameraPackage != null
265                    && doesPackageSupportRuntimePermissions(cameraPackage)) {
266                grantRuntimePermissionsLPw(cameraPackage, CAMERA_PERMISSIONS, userId);
267                grantRuntimePermissionsLPw(cameraPackage, MICROPHONE_PERMISSIONS, userId);
268                grantRuntimePermissionsLPw(cameraPackage, STORAGE_PERMISSIONS, userId);
269            }
270
271            // Media provider
272            PackageParser.Package mediaStorePackage = getDefaultProviderAuthorityPackageLPr(
273                    MediaStore.AUTHORITY, userId);
274            if (mediaStorePackage != null) {
275                grantRuntimePermissionsLPw(mediaStorePackage, STORAGE_PERMISSIONS, true, userId);
276            }
277
278            // Downloads provider
279            PackageParser.Package downloadsPackage = getDefaultProviderAuthorityPackageLPr(
280                    "downloads", userId);
281            if (downloadsPackage != null) {
282                grantRuntimePermissionsLPw(downloadsPackage, STORAGE_PERMISSIONS, true, userId);
283            }
284
285            // Downloads UI
286            Intent downloadsUiIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);
287            PackageParser.Package downloadsUiPackage = getDefaultSystemHandlerActivityPackageLPr(
288                    downloadsUiIntent, userId);
289            if (downloadsUiPackage != null
290                    && doesPackageSupportRuntimePermissions(downloadsUiPackage)) {
291                grantRuntimePermissionsLPw(downloadsUiPackage, STORAGE_PERMISSIONS, true, userId);
292            }
293
294            // Storage provider
295            PackageParser.Package storagePackage = getDefaultProviderAuthorityPackageLPr(
296                    "com.android.externalstorage.documents", userId);
297            if (storagePackage != null) {
298                grantRuntimePermissionsLPw(storagePackage, STORAGE_PERMISSIONS, true, userId);
299            }
300
301            // CertInstaller
302            Intent certInstallerIntent = new Intent(Credentials.INSTALL_ACTION);
303            PackageParser.Package certInstallerPackage = getDefaultSystemHandlerActivityPackageLPr(
304                    certInstallerIntent, userId);
305            if (certInstallerPackage != null
306                    && doesPackageSupportRuntimePermissions(certInstallerPackage)) {
307                grantRuntimePermissionsLPw(certInstallerPackage, STORAGE_PERMISSIONS, true, userId);
308            }
309
310            // Dialer
311            if (dialerAppPackageNames == null) {
312                Intent dialerIntent = new Intent(Intent.ACTION_DIAL);
313                PackageParser.Package dialerPackage = getDefaultSystemHandlerActivityPackageLPr(
314                        dialerIntent, userId);
315                if (dialerPackage != null) {
316                    grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);
317                }
318            } else {
319                for (String dialerAppPackageName : dialerAppPackageNames) {
320                    PackageParser.Package dialerPackage = getSystemPackageLPr(dialerAppPackageName);
321                    if (dialerPackage != null) {
322                        grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);
323                    }
324                }
325            }
326
327            // Sim call manager
328            if (simCallManagerPackageNames != null) {
329                for (String simCallManagerPackageName : simCallManagerPackageNames) {
330                    PackageParser.Package simCallManagerPackage =
331                            getSystemPackageLPr(simCallManagerPackageName);
332                    if (simCallManagerPackage != null) {
333                        grantDefaultPermissionsToDefaultSimCallManagerLPr(simCallManagerPackage,
334                                userId);
335                    }
336                }
337            }
338
339            // SMS
340            if (smsAppPackageNames == null) {
341                Intent smsIntent = new Intent(Intent.ACTION_MAIN);
342                smsIntent.addCategory(Intent.CATEGORY_APP_MESSAGING);
343                PackageParser.Package smsPackage = getDefaultSystemHandlerActivityPackageLPr(
344                        smsIntent, userId);
345                if (smsPackage != null) {
346                   grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);
347                }
348            } else {
349                for (String smsPackageName : smsAppPackageNames) {
350                    PackageParser.Package smsPackage = getSystemPackageLPr(smsPackageName);
351                    if (smsPackage != null) {
352                        grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);
353                    }
354                }
355            }
356
357            // Cell Broadcast Receiver
358            Intent cbrIntent = new Intent(Intents.SMS_CB_RECEIVED_ACTION);
359            PackageParser.Package cbrPackage =
360                    getDefaultSystemHandlerActivityPackageLPr(cbrIntent, userId);
361            if (cbrPackage != null && doesPackageSupportRuntimePermissions(cbrPackage)) {
362                grantRuntimePermissionsLPw(cbrPackage, SMS_PERMISSIONS, userId);
363            }
364
365            // Carrier Provisioning Service
366            Intent carrierProvIntent = new Intent(Intents.SMS_CARRIER_PROVISION_ACTION);
367            PackageParser.Package carrierProvPackage =
368                    getDefaultSystemHandlerServicePackageLPr(carrierProvIntent, userId);
369            if (carrierProvPackage != null && doesPackageSupportRuntimePermissions(carrierProvPackage)) {
370                grantRuntimePermissionsLPw(carrierProvPackage, SMS_PERMISSIONS, false, userId);
371            }
372
373            // Calendar
374            Intent calendarIntent = new Intent(Intent.ACTION_MAIN);
375            calendarIntent.addCategory(Intent.CATEGORY_APP_CALENDAR);
376            PackageParser.Package calendarPackage = getDefaultSystemHandlerActivityPackageLPr(
377                    calendarIntent, userId);
378            if (calendarPackage != null
379                    && doesPackageSupportRuntimePermissions(calendarPackage)) {
380                grantRuntimePermissionsLPw(calendarPackage, CALENDAR_PERMISSIONS, userId);
381                grantRuntimePermissionsLPw(calendarPackage, CONTACTS_PERMISSIONS, userId);
382            }
383
384            // Calendar provider
385            PackageParser.Package calendarProviderPackage = getDefaultProviderAuthorityPackageLPr(
386                    CalendarContract.AUTHORITY, userId);
387            if (calendarProviderPackage != null) {
388                grantRuntimePermissionsLPw(calendarProviderPackage, CONTACTS_PERMISSIONS, userId);
389                grantRuntimePermissionsLPw(calendarProviderPackage, CALENDAR_PERMISSIONS,
390                        true, userId);
391                grantRuntimePermissionsLPw(calendarProviderPackage, STORAGE_PERMISSIONS, userId);
392            }
393
394            // Calendar provider sync adapters
395            List<PackageParser.Package> calendarSyncAdapters = getHeadlessSyncAdapterPackagesLPr(
396                    calendarSyncAdapterPackages, userId);
397            final int calendarSyncAdapterCount = calendarSyncAdapters.size();
398            for (int i = 0; i < calendarSyncAdapterCount; i++) {
399                PackageParser.Package calendarSyncAdapter = calendarSyncAdapters.get(i);
400                if (doesPackageSupportRuntimePermissions(calendarSyncAdapter)) {
401                    grantRuntimePermissionsLPw(calendarSyncAdapter, CALENDAR_PERMISSIONS, userId);
402                }
403            }
404
405            // Contacts
406            Intent contactsIntent = new Intent(Intent.ACTION_MAIN);
407            contactsIntent.addCategory(Intent.CATEGORY_APP_CONTACTS);
408            PackageParser.Package contactsPackage = getDefaultSystemHandlerActivityPackageLPr(
409                    contactsIntent, userId);
410            if (contactsPackage != null
411                    && doesPackageSupportRuntimePermissions(contactsPackage)) {
412                grantRuntimePermissionsLPw(contactsPackage, CONTACTS_PERMISSIONS, userId);
413                grantRuntimePermissionsLPw(contactsPackage, PHONE_PERMISSIONS, userId);
414            }
415
416            // Contacts provider sync adapters
417            List<PackageParser.Package> contactsSyncAdapters = getHeadlessSyncAdapterPackagesLPr(
418                    contactsSyncAdapterPackages, userId);
419            final int contactsSyncAdapterCount = contactsSyncAdapters.size();
420            for (int i = 0; i < contactsSyncAdapterCount; i++) {
421                PackageParser.Package contactsSyncAdapter = contactsSyncAdapters.get(i);
422                if (doesPackageSupportRuntimePermissions(contactsSyncAdapter)) {
423                    grantRuntimePermissionsLPw(contactsSyncAdapter, CONTACTS_PERMISSIONS, userId);
424                }
425            }
426
427            // Contacts provider
428            PackageParser.Package contactsProviderPackage = getDefaultProviderAuthorityPackageLPr(
429                    ContactsContract.AUTHORITY, userId);
430            if (contactsProviderPackage != null) {
431                grantRuntimePermissionsLPw(contactsProviderPackage, CONTACTS_PERMISSIONS,
432                        true, userId);
433                grantRuntimePermissionsLPw(contactsProviderPackage, PHONE_PERMISSIONS,
434                        true, userId);
435                grantRuntimePermissionsLPw(contactsProviderPackage, STORAGE_PERMISSIONS, userId);
436            }
437
438            // Device provisioning
439            Intent deviceProvisionIntent = new Intent(
440                    DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE);
441            PackageParser.Package deviceProvisionPackage =
442                    getDefaultSystemHandlerActivityPackageLPr(deviceProvisionIntent, userId);
443            if (deviceProvisionPackage != null
444                    && doesPackageSupportRuntimePermissions(deviceProvisionPackage)) {
445                grantRuntimePermissionsLPw(deviceProvisionPackage, CONTACTS_PERMISSIONS, userId);
446            }
447
448            // Maps
449            Intent mapsIntent = new Intent(Intent.ACTION_MAIN);
450            mapsIntent.addCategory(Intent.CATEGORY_APP_MAPS);
451            PackageParser.Package mapsPackage = getDefaultSystemHandlerActivityPackageLPr(
452                    mapsIntent, userId);
453            if (mapsPackage != null
454                    && doesPackageSupportRuntimePermissions(mapsPackage)) {
455                grantRuntimePermissionsLPw(mapsPackage, LOCATION_PERMISSIONS, userId);
456            }
457
458            // Gallery
459            Intent galleryIntent = new Intent(Intent.ACTION_MAIN);
460            galleryIntent.addCategory(Intent.CATEGORY_APP_GALLERY);
461            PackageParser.Package galleryPackage = getDefaultSystemHandlerActivityPackageLPr(
462                    galleryIntent, userId);
463            if (galleryPackage != null
464                    && doesPackageSupportRuntimePermissions(galleryPackage)) {
465                grantRuntimePermissionsLPw(galleryPackage, STORAGE_PERMISSIONS, userId);
466            }
467
468            // Email
469            Intent emailIntent = new Intent(Intent.ACTION_MAIN);
470            emailIntent.addCategory(Intent.CATEGORY_APP_EMAIL);
471            PackageParser.Package emailPackage = getDefaultSystemHandlerActivityPackageLPr(
472                    emailIntent, userId);
473            if (emailPackage != null
474                    && doesPackageSupportRuntimePermissions(emailPackage)) {
475                grantRuntimePermissionsLPw(emailPackage, CONTACTS_PERMISSIONS, userId);
476            }
477
478            // Browser
479            PackageParser.Package browserPackage = null;
480            String defaultBrowserPackage = mService.getDefaultBrowserPackageName(userId);
481            if (defaultBrowserPackage != null) {
482                browserPackage = getPackageLPr(defaultBrowserPackage);
483            }
484            if (browserPackage == null) {
485                Intent browserIntent = new Intent(Intent.ACTION_MAIN);
486                browserIntent.addCategory(Intent.CATEGORY_APP_BROWSER);
487                browserPackage = getDefaultSystemHandlerActivityPackageLPr(
488                        browserIntent, userId);
489            }
490            if (browserPackage != null
491                    && doesPackageSupportRuntimePermissions(browserPackage)) {
492                grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, userId);
493            }
494
495            // Voice interaction
496            if (voiceInteractPackageNames != null) {
497                for (String voiceInteractPackageName : voiceInteractPackageNames) {
498                    PackageParser.Package voiceInteractPackage = getSystemPackageLPr(
499                            voiceInteractPackageName);
500                    if (voiceInteractPackage != null
501                            && doesPackageSupportRuntimePermissions(voiceInteractPackage)) {
502                        grantRuntimePermissionsLPw(voiceInteractPackage,
503                                CONTACTS_PERMISSIONS, userId);
504                        grantRuntimePermissionsLPw(voiceInteractPackage,
505                                CALENDAR_PERMISSIONS, userId);
506                        grantRuntimePermissionsLPw(voiceInteractPackage,
507                                MICROPHONE_PERMISSIONS, userId);
508                        grantRuntimePermissionsLPw(voiceInteractPackage,
509                                PHONE_PERMISSIONS, userId);
510                        grantRuntimePermissionsLPw(voiceInteractPackage,
511                                SMS_PERMISSIONS, userId);
512                        grantRuntimePermissionsLPw(voiceInteractPackage,
513                                LOCATION_PERMISSIONS, userId);
514                    }
515                }
516            }
517
518            // Voice recognition
519            Intent voiceRecoIntent = new Intent("android.speech.RecognitionService");
520            voiceRecoIntent.addCategory(Intent.CATEGORY_DEFAULT);
521            PackageParser.Package voiceRecoPackage = getDefaultSystemHandlerServicePackageLPr(
522                    voiceRecoIntent, userId);
523            if (voiceRecoPackage != null
524                    && doesPackageSupportRuntimePermissions(voiceRecoPackage)) {
525                grantRuntimePermissionsLPw(voiceRecoPackage, MICROPHONE_PERMISSIONS, userId);
526            }
527
528            // Location
529            if (locationPackageNames != null) {
530                for (String packageName : locationPackageNames) {
531                    PackageParser.Package locationPackage = getSystemPackageLPr(packageName);
532                    if (locationPackage != null
533                            && doesPackageSupportRuntimePermissions(locationPackage)) {
534                        grantRuntimePermissionsLPw(locationPackage, CONTACTS_PERMISSIONS, userId);
535                        grantRuntimePermissionsLPw(locationPackage, CALENDAR_PERMISSIONS, userId);
536                        grantRuntimePermissionsLPw(locationPackage, MICROPHONE_PERMISSIONS, userId);
537                        grantRuntimePermissionsLPw(locationPackage, PHONE_PERMISSIONS, userId);
538                        grantRuntimePermissionsLPw(locationPackage, SMS_PERMISSIONS, userId);
539                        grantRuntimePermissionsLPw(locationPackage, LOCATION_PERMISSIONS,
540                                true, userId);
541                        grantRuntimePermissionsLPw(locationPackage, CAMERA_PERMISSIONS, userId);
542                        grantRuntimePermissionsLPw(locationPackage, SENSORS_PERMISSIONS, userId);
543                        grantRuntimePermissionsLPw(locationPackage, STORAGE_PERMISSIONS, userId);
544                    }
545                }
546            }
547
548            // Music
549            Intent musicIntent = new Intent(Intent.ACTION_VIEW);
550            musicIntent.addCategory(Intent.CATEGORY_DEFAULT);
551            musicIntent.setDataAndType(Uri.fromFile(new File("foo.mp3")),
552                    AUDIO_MIME_TYPE);
553            PackageParser.Package musicPackage = getDefaultSystemHandlerActivityPackageLPr(
554                    musicIntent, userId);
555            if (musicPackage != null
556                    && doesPackageSupportRuntimePermissions(musicPackage)) {
557                grantRuntimePermissionsLPw(musicPackage, STORAGE_PERMISSIONS, userId);
558            }
559
560            // Android Wear Home
561            if (mService.hasSystemFeature(PackageManager.FEATURE_WATCH, 0)) {
562                Intent homeIntent = new Intent(Intent.ACTION_MAIN);
563                homeIntent.addCategory(Intent.CATEGORY_HOME_MAIN);
564
565                PackageParser.Package wearHomePackage = getDefaultSystemHandlerActivityPackageLPr(
566                        homeIntent, userId);
567
568                if (wearHomePackage != null
569                        && doesPackageSupportRuntimePermissions(wearHomePackage)) {
570                    grantRuntimePermissionsLPw(wearHomePackage, CONTACTS_PERMISSIONS, false,
571                            userId);
572                    grantRuntimePermissionsLPw(wearHomePackage, PHONE_PERMISSIONS, true, userId);
573                    grantRuntimePermissionsLPw(wearHomePackage, MICROPHONE_PERMISSIONS, false,
574                            userId);
575                    grantRuntimePermissionsLPw(wearHomePackage, LOCATION_PERMISSIONS, false,
576                            userId);
577                }
578            }
579
580            // Print Spooler
581            PackageParser.Package printSpoolerPackage = getSystemPackageLPr(
582                    PrintManager.PRINT_SPOOLER_PACKAGE_NAME);
583            if (printSpoolerPackage != null
584                    && doesPackageSupportRuntimePermissions(printSpoolerPackage)) {
585                grantRuntimePermissionsLPw(printSpoolerPackage, LOCATION_PERMISSIONS, true, userId);
586            }
587
588            // EmergencyInfo
589            Intent emergencyInfoIntent = new Intent(TelephonyManager.ACTION_EMERGENCY_ASSISTANCE);
590            PackageParser.Package emergencyInfoPckg = getDefaultSystemHandlerActivityPackageLPr(
591                    emergencyInfoIntent, userId);
592            if (emergencyInfoPckg != null
593                    && doesPackageSupportRuntimePermissions(emergencyInfoPckg)) {
594                grantRuntimePermissionsLPw(emergencyInfoPckg, CONTACTS_PERMISSIONS, true, userId);
595                grantRuntimePermissionsLPw(emergencyInfoPckg, PHONE_PERMISSIONS, true, userId);
596            }
597
598            // NFC Tag viewer
599            Intent nfcTagIntent = new Intent(Intent.ACTION_VIEW);
600            nfcTagIntent.setType("vnd.android.cursor.item/ndef_msg");
601            PackageParser.Package nfcTagPkg = getDefaultSystemHandlerActivityPackageLPr(
602                    nfcTagIntent, userId);
603            if (nfcTagPkg != null
604                    && doesPackageSupportRuntimePermissions(nfcTagPkg)) {
605                grantRuntimePermissionsLPw(nfcTagPkg, CONTACTS_PERMISSIONS, false, userId);
606                grantRuntimePermissionsLPw(nfcTagPkg, PHONE_PERMISSIONS, false, userId);
607            }
608            mService.mSettings.onDefaultRuntimePermissionsGrantedLPr(userId);
609        }
610    }
611
612    private void grantDefaultPermissionsToDefaultSystemDialerAppLPr(
613            PackageParser.Package dialerPackage, int userId) {
614        if (doesPackageSupportRuntimePermissions(dialerPackage)) {
615            boolean isPhonePermFixed =
616                    mService.hasSystemFeature(PackageManager.FEATURE_WATCH, 0);
617            grantRuntimePermissionsLPw(
618                    dialerPackage, PHONE_PERMISSIONS, isPhonePermFixed, userId);
619            grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, userId);
620            grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, userId);
621            grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, userId);
622        }
623    }
624
625    private void grantDefaultPermissionsToDefaultSystemSmsAppLPr(
626            PackageParser.Package smsPackage, int userId) {
627        if (doesPackageSupportRuntimePermissions(smsPackage)) {
628            grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, userId);
629            grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, userId);
630            grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, userId);
631        }
632    }
633
634    public void grantDefaultPermissionsToDefaultSmsAppLPr(String packageName, int userId) {
635        Log.i(TAG, "Granting permissions to default sms app for user:" + userId);
636        if (packageName == null) {
637            return;
638        }
639        PackageParser.Package smsPackage = getPackageLPr(packageName);
640        if (smsPackage != null && doesPackageSupportRuntimePermissions(smsPackage)) {
641            grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, false, true, userId);
642            grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, false, true, userId);
643            grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, false, true, userId);
644        }
645    }
646
647    public void grantDefaultPermissionsToDefaultDialerAppLPr(String packageName, int userId) {
648        Log.i(TAG, "Granting permissions to default dialer app for user:" + userId);
649        if (packageName == null) {
650            return;
651        }
652        PackageParser.Package dialerPackage = getPackageLPr(packageName);
653        if (dialerPackage != null
654                && doesPackageSupportRuntimePermissions(dialerPackage)) {
655            grantRuntimePermissionsLPw(dialerPackage, PHONE_PERMISSIONS, false, true, userId);
656            grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, false, true, userId);
657            grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, false, true, userId);
658            grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, false, true, userId);
659        }
660    }
661
662    private void grantDefaultPermissionsToDefaultSimCallManagerLPr(
663            PackageParser.Package simCallManagerPackage, int userId) {
664        Log.i(TAG, "Granting permissions to sim call manager for user:" + userId);
665        if (doesPackageSupportRuntimePermissions(simCallManagerPackage)) {
666            grantRuntimePermissionsLPw(simCallManagerPackage, PHONE_PERMISSIONS, userId);
667            grantRuntimePermissionsLPw(simCallManagerPackage, MICROPHONE_PERMISSIONS, userId);
668        }
669    }
670
671    public void grantDefaultPermissionsToDefaultSimCallManagerLPr(String packageName, int userId) {
672        if (packageName == null) {
673            return;
674        }
675        PackageParser.Package simCallManagerPackage = getPackageLPr(packageName);
676        if (simCallManagerPackage != null) {
677            grantDefaultPermissionsToDefaultSimCallManagerLPr(simCallManagerPackage, userId);
678        }
679    }
680
681    public void grantDefaultPermissionsToEnabledCarrierAppsLPr(String[] packageNames, int userId) {
682        Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);
683        if (packageNames == null) {
684            return;
685        }
686        for (String packageName : packageNames) {
687            PackageParser.Package carrierPackage = getSystemPackageLPr(packageName);
688            if (carrierPackage != null
689                    && doesPackageSupportRuntimePermissions(carrierPackage)) {
690                grantRuntimePermissionsLPw(carrierPackage, PHONE_PERMISSIONS, userId);
691                grantRuntimePermissionsLPw(carrierPackage, LOCATION_PERMISSIONS, userId);
692                grantRuntimePermissionsLPw(carrierPackage, SMS_PERMISSIONS, userId);
693            }
694        }
695    }
696
697    public void grantDefaultPermissionsToDefaultBrowserLPr(String packageName, int userId) {
698        Log.i(TAG, "Granting permissions to default browser for user:" + userId);
699        if (packageName == null) {
700            return;
701        }
702        PackageParser.Package browserPackage = getSystemPackageLPr(packageName);
703        if (browserPackage != null
704                && doesPackageSupportRuntimePermissions(browserPackage)) {
705            grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, false, false, userId);
706        }
707    }
708
709    private PackageParser.Package getDefaultSystemHandlerActivityPackageLPr(
710            Intent intent, int userId) {
711        ResolveInfo handler = mService.resolveIntent(intent,
712                intent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS, userId);
713        if (handler == null || handler.activityInfo == null) {
714            return null;
715        }
716        ActivityInfo activityInfo = handler.activityInfo;
717        if (activityInfo.packageName.equals(mService.mResolveActivity.packageName)
718                && activityInfo.name.equals(mService.mResolveActivity.name)) {
719            return null;
720        }
721        return getSystemPackageLPr(handler.activityInfo.packageName);
722    }
723
724    private PackageParser.Package getDefaultSystemHandlerServicePackageLPr(
725            Intent intent, int userId) {
726        List<ResolveInfo> handlers = mService.queryIntentServices(intent,
727                intent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS, userId)
728                .getList();
729        if (handlers == null) {
730            return null;
731        }
732        final int handlerCount = handlers.size();
733        for (int i = 0; i < handlerCount; i++) {
734            ResolveInfo handler = handlers.get(i);
735            PackageParser.Package handlerPackage = getSystemPackageLPr(
736                    handler.serviceInfo.packageName);
737            if (handlerPackage != null) {
738                return handlerPackage;
739            }
740        }
741        return null;
742    }
743
744    private List<PackageParser.Package> getHeadlessSyncAdapterPackagesLPr(
745            String[] syncAdapterPackageNames, int userId) {
746        List<PackageParser.Package> syncAdapterPackages = new ArrayList<>();
747
748        Intent homeIntent = new Intent(Intent.ACTION_MAIN);
749        homeIntent.addCategory(Intent.CATEGORY_LAUNCHER);
750
751        for (String syncAdapterPackageName : syncAdapterPackageNames) {
752            homeIntent.setPackage(syncAdapterPackageName);
753
754            ResolveInfo homeActivity = mService.resolveIntent(homeIntent,
755                    homeIntent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS,
756                    userId);
757            if (homeActivity != null) {
758                continue;
759            }
760
761            PackageParser.Package syncAdapterPackage = getSystemPackageLPr(syncAdapterPackageName);
762            if (syncAdapterPackage != null) {
763                syncAdapterPackages.add(syncAdapterPackage);
764            }
765        }
766
767        return syncAdapterPackages;
768    }
769
770    private PackageParser.Package getDefaultProviderAuthorityPackageLPr(
771            String authority, int userId) {
772        ProviderInfo provider = mService.resolveContentProvider(authority, DEFAULT_FLAGS, userId);
773        if (provider != null) {
774            return getSystemPackageLPr(provider.packageName);
775        }
776        return null;
777    }
778
779    private PackageParser.Package getPackageLPr(String packageName) {
780        return mService.mPackages.get(packageName);
781    }
782
783    private PackageParser.Package getSystemPackageLPr(String packageName) {
784        PackageParser.Package pkg = getPackageLPr(packageName);
785        if (pkg != null && pkg.isSystemApp()) {
786            return !isSysComponentOrPersistentPlatformSignedPrivAppLPr(pkg) ? pkg : null;
787        }
788        return null;
789    }
790
791    private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
792            int userId) {
793        grantRuntimePermissionsLPw(pkg, permissions, false, false, userId);
794    }
795
796    private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
797            boolean systemFixed, int userId) {
798        grantRuntimePermissionsLPw(pkg, permissions, systemFixed, false, userId);
799    }
800
801    private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,
802            boolean systemFixed, boolean isDefaultPhoneOrSms, int userId) {
803        if (pkg.requestedPermissions.isEmpty()) {
804            return;
805        }
806
807        List<String> requestedPermissions = pkg.requestedPermissions;
808        Set<String> grantablePermissions = null;
809
810        // If this is the default Phone or SMS app we grant permissions regardless
811        // whether the version on the system image declares the permission as used since
812        // selecting the app as the default Phone or SMS the user makes a deliberate
813        // choice to grant this app the permissions needed to function. For all other
814        // apps, (default grants on first boot and user creation) we don't grant default
815        // permissions if the version on the system image does not declare them.
816        if (!isDefaultPhoneOrSms && pkg.isUpdatedSystemApp()) {
817            PackageSetting sysPs = mService.mSettings.getDisabledSystemPkgLPr(pkg.packageName);
818            if (sysPs != null) {
819                if (sysPs.pkg.requestedPermissions.isEmpty()) {
820                    return;
821                }
822                if (!requestedPermissions.equals(sysPs.pkg.requestedPermissions)) {
823                    grantablePermissions = new ArraySet<>(requestedPermissions);
824                    requestedPermissions = sysPs.pkg.requestedPermissions;
825                }
826            }
827        }
828
829        final int grantablePermissionCount = requestedPermissions.size();
830        for (int i = 0; i < grantablePermissionCount; i++) {
831            String permission = requestedPermissions.get(i);
832
833            // If there is a disabled system app it may request a permission the updated
834            // version ot the data partition doesn't, In this case skip the permission.
835            if (grantablePermissions != null && !grantablePermissions.contains(permission)) {
836                continue;
837            }
838
839            if (permissions.contains(permission)) {
840                final int flags = mService.getPermissionFlags(permission, pkg.packageName, userId);
841
842                // If any flags are set to the permission, then it is either set in
843                // its current state by the system or device/profile owner or the user.
844                // In all these cases we do not want to clobber the current state.
845                // Unless the caller wants to override user choices. The override is
846                // to make sure we can grant the needed permission to the default
847                // sms and phone apps after the user chooses this in the UI.
848                if (flags == 0 || isDefaultPhoneOrSms) {
849                    // Never clobber policy or system.
850                    final int fixedFlags = PackageManager.FLAG_PERMISSION_SYSTEM_FIXED
851                            | PackageManager.FLAG_PERMISSION_POLICY_FIXED;
852                    if ((flags & fixedFlags) != 0) {
853                        continue;
854                    }
855
856                    mService.grantRuntimePermission(pkg.packageName, permission, userId);
857                    if (DEBUG) {
858                        Log.i(TAG, "Granted " + (systemFixed ? "fixed " : "not fixed ")
859                                + permission + " to default handler " + pkg.packageName);
860                    }
861
862                    int newFlags = PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;
863                    if (systemFixed) {
864                        newFlags |= PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;
865                    }
866
867                    mService.updatePermissionFlags(permission, pkg.packageName,
868                            newFlags, newFlags, userId);
869                }
870
871                // If a component gets a permission for being the default handler A
872                // and also default handler B, we grant the weaker grant form.
873                if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0
874                        && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0
875                        && !systemFixed) {
876                    if (DEBUG) {
877                        Log.i(TAG, "Granted not fixed " + permission + " to default handler "
878                                + pkg.packageName);
879                    }
880                    mService.updatePermissionFlags(permission, pkg.packageName,
881                            PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, 0, userId);
882                }
883            }
884        }
885    }
886
887    private boolean isSysComponentOrPersistentPlatformSignedPrivAppLPr(PackageParser.Package pkg) {
888        if (UserHandle.getAppId(pkg.applicationInfo.uid) < FIRST_APPLICATION_UID) {
889            return true;
890        }
891        if (!pkg.isPrivilegedApp()) {
892            return false;
893        }
894        PackageSetting sysPkg = mService.mSettings.getDisabledSystemPkgLPr(pkg.packageName);
895        if (sysPkg != null && sysPkg.pkg != null) {
896            if ((sysPkg.pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
897                return false;
898            }
899        } else if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {
900            return false;
901        }
902        return PackageManagerService.compareSignatures(mService.mPlatformPackage.mSignatures,
903                pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;
904    }
905
906    private static boolean doesPackageSupportRuntimePermissions(PackageParser.Package pkg) {
907        return pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1;
908    }
909}
910