7.1去掉权限申请

1、第三方应用

如果不需要弹出此对话框来手动授予权限，而是默认授权，可修改frameworks\base\services\core\java\com\android\server\pm\PackageManagerService.java文件下面的内容

doHandleMessage()下的case POST_INSTALL下

把final boolean grantPermissions = (args.installFlags& PackageManager.INSTALL_GRANT_RUNTIME_PERMISSIONS) != 0;

改为final boolean grantPermissions = true;即可

编译验证方法：

1.mmm frameworks/base/services

2.make snod

3.烧录system.img

2、系统签名的系统应用，也就是不是通过后期安装安装的应用

修改pm下的DefaultPermissionGrantPolicy.java

在grantDefaultSystemHandlerPermissions方法中增加自己新增的app的权限

下面演示给 com.funduemobile.enpad 授予所以权限

PHONE_PERMISSIONS
CONTACTS_PERMISSIONS
LOCATION_PERMISSIONS
CALENDAR_PERMISSIONS
SMS_PERMISSIONS
MICROPHONE_PERMISSIONS
CAMERA_PERMISSIONS
SENSORS_PERMISSIONS
STORAGE_PERMISSIONS

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;

18.  

19. import android.Manifest;

20. import android.annotation.NonNull;

21. import android.app.DownloadManager;

22. import android.app.admin.DevicePolicyManager;

23. import android.content.Intent;

24. import android.content.pm.ActivityInfo;

25. import android.content.pm.ApplicationInfo;

26. import android.content.pm.PackageManager;

27. import android.content.pm.PackageManagerInternal.PackagesProvider;

28. import android.content.pm.PackageManagerInternal.SyncAdapterPackagesProvider;

29. import android.content.pm.PackageParser;

30. import android.content.pm.ProviderInfo;

31. import android.content.pm.ResolveInfo;

32. import android.net.Uri;

33. import android.os.Build;

34. import android.os.Environment;

35. import android.os.Handler;

36. import android.os.Message;

37. import android.os.UserHandle;

38. import android.os.storage.StorageManager;

39. import android.print.PrintManager;

40. import android.provider.CalendarContract;

41. import android.provider.ContactsContract;

42. import android.provider.MediaStore;

43. import android.provider.Telephony.Sms.Intents;

44. import android.telephony.TelephonyManager;

45. import android.security.Credentials;

46. import android.util.ArrayMap;

47. import android.util.ArraySet;

48. import android.util.Log;

49. import android.util.Slog;

50. import android.util.Xml;

51. import com.android.internal.util.XmlUtils;

52. import org.xmlpull.v1.XmlPullParser;

53. import org.xmlpull.v1.XmlPullParserException;

54.  

55. import java.io.BufferedInputStream;

56. import java.io.File;

57. import java.io.FileInputStream;

58. import java.io.IOException;

59. import java.io.InputStream;

60. import java.util.ArrayList;

61. import java.util.List;

62. import java.util.Map;

63. import java.util.Set;

64.  

65. import static android.os.Process.FIRST_APPLICATION_UID;

66.  

67. /**

68. * This class is the policy for granting runtime permissions to

69. * platform components and default handlers in the system such

70. * that the device is usable out-of-the-box. For example, the

71. * shell UID is a part of the system and the Phone app should

72. * have phone related permission by default.

73. */

74. final class DefaultPermissionGrantPolicy {

75. private static final String TAG = "DefaultPermGrantPolicy"; // must be <= 23 chars

76. private static final boolean DEBUG = false;

77.  

78. private static final int DEFAULT_FLAGS = PackageManager.MATCH_DIRECT_BOOT_AWARE

79. | PackageManager.MATCH_DIRECT_BOOT_UNAWARE;

80.  

81. private static final String AUDIO_MIME_TYPE = "audio/mpeg";

82.  

83. private static final String TAG_EXCEPTIONS = "exceptions";

84. private static final String TAG_EXCEPTION = "exception";

85. private static final String TAG_PERMISSION = "permission";

86. private static final String ATTR_PACKAGE = "package";

87. private static final String ATTR_NAME = "name";

88. private static final String ATTR_FIXED = "fixed";

89.  

90. private static final Set<String> PHONE_PERMISSIONS = new ArraySet<>();

91. static {

92. PHONE_PERMISSIONS.add(Manifest.permission.READ_PHONE_STATE);

93. PHONE_PERMISSIONS.add(Manifest.permission.CALL_PHONE);

94. PHONE_PERMISSIONS.add(Manifest.permission.READ_CALL_LOG);

95. PHONE_PERMISSIONS.add(Manifest.permission.WRITE_CALL_LOG);

96. PHONE_PERMISSIONS.add(Manifest.permission.ADD_VOICEMAIL);

97. PHONE_PERMISSIONS.add(Manifest.permission.USE_SIP);

98. PHONE_PERMISSIONS.add(Manifest.permission.PROCESS_OUTGOING_CALLS);

99. }

100.  

101. private static final Set<String> CONTACTS_PERMISSIONS = new ArraySet<>();

102. static {

103. CONTACTS_PERMISSIONS.add(Manifest.permission.READ_CONTACTS);

104. CONTACTS_PERMISSIONS.add(Manifest.permission.WRITE_CONTACTS);

105. CONTACTS_PERMISSIONS.add(Manifest.permission.GET_ACCOUNTS);

106. }

107.  

108. private static final Set<String> LOCATION_PERMISSIONS = new ArraySet<>();

109. static {

110. LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_FINE_LOCATION);

111. LOCATION_PERMISSIONS.add(Manifest.permission.ACCESS_COARSE_LOCATION);

112. }

113.  

114. private static final Set<String> CALENDAR_PERMISSIONS = new ArraySet<>();

115. static {

116. CALENDAR_PERMISSIONS.add(Manifest.permission.READ_CALENDAR);

117. CALENDAR_PERMISSIONS.add(Manifest.permission.WRITE_CALENDAR);

118. }

119.  

120. private static final Set<String> SMS_PERMISSIONS = new ArraySet<>();

121. static {

122. SMS_PERMISSIONS.add(Manifest.permission.SEND_SMS);

123. SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_SMS);

124. SMS_PERMISSIONS.add(Manifest.permission.READ_SMS);

125. SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_WAP_PUSH);

126. SMS_PERMISSIONS.add(Manifest.permission.RECEIVE_MMS);

127. SMS_PERMISSIONS.add(Manifest.permission.READ_CELL_BROADCASTS);

128. }

129.  

130. private static final Set<String> MICROPHONE_PERMISSIONS = new ArraySet<>();

131. static {

132. MICROPHONE_PERMISSIONS.add(Manifest.permission.RECORD_AUDIO);

133. }

134.  

135. private static final Set<String> CAMERA_PERMISSIONS = new ArraySet<>();

136. static {

137. CAMERA_PERMISSIONS.add(Manifest.permission.CAMERA);

138. }

139.  

140. private static final Set<String> SENSORS_PERMISSIONS = new ArraySet<>();

141. static {

142. SENSORS_PERMISSIONS.add(Manifest.permission.BODY_SENSORS);

143. }

144.  

145. private static final Set<String> STORAGE_PERMISSIONS = new ArraySet<>();

146. static {

147. STORAGE_PERMISSIONS.add(Manifest.permission.READ_EXTERNAL_STORAGE);

148. STORAGE_PERMISSIONS.add(Manifest.permission.WRITE_EXTERNAL_STORAGE);

149. }

150.  

151. private static final int MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS = 1;

152.  

153. private static final String ACTION_TWINNING =

154. "com.google.android.clockwork.intent.TWINNING_SETTINGS";

155. private static final String ACTION_TRACK = "com.android.fitness.TRACK";

156.  

157. private final PackageManagerService mService;

158. private final Handler mHandler;

159.  

160. private PackagesProvider mLocationPackagesProvider;

161. private PackagesProvider mVoiceInteractionPackagesProvider;

162. private PackagesProvider mSmsAppPackagesProvider;

163. private PackagesProvider mDialerAppPackagesProvider;

164. private PackagesProvider mSimCallManagerPackagesProvider;

165. private SyncAdapterPackagesProvider mSyncAdapterPackagesProvider;

166.  

167. private ArrayMap<String, List<DefaultPermissionGrant>> mGrantExceptions;

168.  

169. public DefaultPermissionGrantPolicy(PackageManagerService service) {

170. mService = service;

171. mHandler = new Handler(mService.mHandlerThread.getLooper()) {

172. @Override

173. public void handleMessage(Message msg) {

174. if (msg.what == MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS) {

175. synchronized (mService.mPackages) {

176. if (mGrantExceptions == null) {

177. mGrantExceptions = readDefaultPermissionExceptionsLPw();

178. }

179. }

180. }

181. }

182. };

183. }

184.  

185. public void setLocationPackagesProviderLPw(PackagesProvider provider) {

186. mLocationPackagesProvider = provider;

187. }

188.  

189. public void setVoiceInteractionPackagesProviderLPw(PackagesProvider provider) {

190. mVoiceInteractionPackagesProvider = provider;

191. }

192.  

193. public void setSmsAppPackagesProviderLPw(PackagesProvider provider) {

194. mSmsAppPackagesProvider = provider;

195. }

196.  

197. public void setDialerAppPackagesProviderLPw(PackagesProvider provider) {

198. mDialerAppPackagesProvider = provider;

199. }

200.  

201. public void setSimCallManagerPackagesProviderLPw(PackagesProvider provider) {

202. mSimCallManagerPackagesProvider = provider;

203. }

204.  

205. public void setSyncAdapterPackagesProviderLPw(SyncAdapterPackagesProvider provider) {

206. mSyncAdapterPackagesProvider = provider;

207. }

208.  

209. public void grantDefaultPermissions(int userId) {

210. grantPermissionsToSysComponentsAndPrivApps(userId);

211. grantDefaultSystemHandlerPermissions(userId);

212. grantDefaultPermissionExceptions(userId);

213. }

214.  

215. public void scheduleReadDefaultPermissionExceptions() {

216. mHandler.sendEmptyMessage(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);

217. }

218.  

219. private void grantPermissionsToSysComponentsAndPrivApps(int userId) {

220. Log.i(TAG, "Granting permissions to platform components for user " + userId);

221.  

222. synchronized (mService.mPackages) {

223. for (PackageParser.Package pkg : mService.mPackages.values()) {

224. if (!isSysComponentOrPersistentPlatformSignedPrivAppLPr(pkg)

225. || !doesPackageSupportRuntimePermissions(pkg)

226. || pkg.requestedPermissions.isEmpty()) {

227. continue;

228. }

229. Set<String> permissions = new ArraySet<>();

230. final int permissionCount = pkg.requestedPermissions.size();

231. for (int i = 0; i < permissionCount; i++) {

232. String permission = pkg.requestedPermissions.get(i);

233. BasePermission bp = mService.mSettings.mPermissions.get(permission);

234. if (bp != null && bp.isRuntime()) {

235. permissions.add(permission);

236. }

237. }

238. if (!permissions.isEmpty()) {

239. grantRuntimePermissionsLPw(pkg, permissions, true, userId);

240. }

241. }

242. }

243. }

244.  

245. private void grantDefaultSystemHandlerPermissions(int userId) {

246. Log.i(TAG, "Granting permissions to default platform handlers for user " + userId);

247.  

248. final PackagesProvider locationPackagesProvider;

249. final PackagesProvider voiceInteractionPackagesProvider;

250. final PackagesProvider smsAppPackagesProvider;

251. final PackagesProvider dialerAppPackagesProvider;

252. final PackagesProvider simCallManagerPackagesProvider;

253. final SyncAdapterPackagesProvider syncAdapterPackagesProvider;

254.  

255. synchronized (mService.mPackages) {

256. locationPackagesProvider = mLocationPackagesProvider;

257. voiceInteractionPackagesProvider = mVoiceInteractionPackagesProvider;

258. smsAppPackagesProvider = mSmsAppPackagesProvider;

259. dialerAppPackagesProvider = mDialerAppPackagesProvider;

260. simCallManagerPackagesProvider = mSimCallManagerPackagesProvider;

261. syncAdapterPackagesProvider = mSyncAdapterPackagesProvider;

262. }

263.  

264. String[] voiceInteractPackageNames = (voiceInteractionPackagesProvider != null)

265. ? voiceInteractionPackagesProvider.getPackages(userId) : null;

266. String[] locationPackageNames = (locationPackagesProvider != null)

267. ? locationPackagesProvider.getPackages(userId) : null;

268. String[] smsAppPackageNames = (smsAppPackagesProvider != null)

269. ? smsAppPackagesProvider.getPackages(userId) : null;

270. String[] dialerAppPackageNames = (dialerAppPackagesProvider != null)

271. ? dialerAppPackagesProvider.getPackages(userId) : null;

272. String[] simCallManagerPackageNames = (simCallManagerPackagesProvider != null)

273. ? simCallManagerPackagesProvider.getPackages(userId) : null;

274. String[] contactsSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?

275. syncAdapterPackagesProvider.getPackages(ContactsContract.AUTHORITY, userId) : null;

276. String[] calendarSyncAdapterPackages = (syncAdapterPackagesProvider != null) ?

277. syncAdapterPackagesProvider.getPackages(CalendarContract.AUTHORITY, userId) : null;

278.  

279. synchronized (mService.mPackages) {

280. // Installer

281. PackageParser.Package installerPackage = getSystemPackageLPr(

282. mService.mRequiredInstallerPackage);

283. if (installerPackage != null

284. && doesPackageSupportRuntimePermissions(installerPackage)) {

285. grantRuntimePermissionsLPw(installerPackage, STORAGE_PERMISSIONS, true, userId);

286. }

287.  

288. // Verifier

289. PackageParser.Package verifierPackage = getSystemPackageLPr(

290. mService.mRequiredVerifierPackage);

291. if (verifierPackage != null

292. && doesPackageSupportRuntimePermissions(verifierPackage)) {

293. grantRuntimePermissionsLPw(verifierPackage, STORAGE_PERMISSIONS, true, userId);

294. grantRuntimePermissionsLPw(verifierPackage, PHONE_PERMISSIONS, false, userId);

295. grantRuntimePermissionsLPw(verifierPackage, SMS_PERMISSIONS, false, userId);

296. }

297.  

298. // SetupWizard

299. PackageParser.Package setupPackage = getSystemPackageLPr(

300. mService.mSetupWizardPackage);

301. if (setupPackage != null

302. && doesPackageSupportRuntimePermissions(setupPackage)) {

303. grantRuntimePermissionsLPw(setupPackage, PHONE_PERMISSIONS, userId);

304. grantRuntimePermissionsLPw(setupPackage, CONTACTS_PERMISSIONS, userId);

305. grantRuntimePermissionsLPw(setupPackage, LOCATION_PERMISSIONS, userId);

306. grantRuntimePermissionsLPw(setupPackage, CAMERA_PERMISSIONS, userId);

307. }

308.  

309. // Camera

310. Intent cameraIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);

311. PackageParser.Package cameraPackage = getDefaultSystemHandlerActivityPackageLPr(

312. cameraIntent, userId);

313. if (cameraPackage != null

314. && doesPackageSupportRuntimePermissions(cameraPackage)) {

315. grantRuntimePermissionsLPw(cameraPackage, CAMERA_PERMISSIONS, userId);

316. grantRuntimePermissionsLPw(cameraPackage, MICROPHONE_PERMISSIONS, userId);

317. grantRuntimePermissionsLPw(cameraPackage, STORAGE_PERMISSIONS, userId);

318. }

319.  

320. // wfy

321. PackageParser.Package engpadPackage = getSystemPackageLPr("com.funduemobile.enpad");

322. Log.e("wfypermission",engpadPackage==null?"null":"engpadPackage");

323. if (engpadPackage != null

324. && doesPackageSupportRuntimePermissions(engpadPackage)) {

325. Log.e("wfypermission",engpadPackage);

326. grantRuntimePermissionsLPw(engpadPackage, PHONE_PERMISSIONS, userId);

327. grantRuntimePermissionsLPw(engpadPackage, CONTACTS_PERMISSIONS, userId);

328. grantRuntimePermissionsLPw(engpadPackage, LOCATION_PERMISSIONS, userId);

329.  

330. grantRuntimePermissionsLPw(engpadPackage, CALENDAR_PERMISSIONS, userId);

331. grantRuntimePermissionsLPw(engpadPackage, SMS_PERMISSIONS, userId);

332. grantRuntimePermissionsLPw(engpadPackage, MICROPHONE_PERMISSIONS, userId);

333.  

334. grantRuntimePermissionsLPw(engpadPackage, CAMERA_PERMISSIONS, userId);

335. grantRuntimePermissionsLPw(engpadPackage, SENSORS_PERMISSIONS, userId);

336. grantRuntimePermissionsLPw(engpadPackage, STORAGE_PERMISSIONS, userId);

337. }

338.  

339. // Media provider

340. PackageParser.Package mediaStorePackage = getDefaultProviderAuthorityPackageLPr(

341. MediaStore.AUTHORITY, userId);

342. if (mediaStorePackage != null) {

343. grantRuntimePermissionsLPw(mediaStorePackage, STORAGE_PERMISSIONS, true, userId);

344. }

345.  

346. // Downloads provider

347. PackageParser.Package downloadsPackage = getDefaultProviderAuthorityPackageLPr(

348. "downloads", userId);

349. if (downloadsPackage != null) {

350. grantRuntimePermissionsLPw(downloadsPackage, STORAGE_PERMISSIONS, true, userId);

351. }

352.  

353. // Downloads UI

354. Intent downloadsUiIntent = new Intent(DownloadManager.ACTION_VIEW_DOWNLOADS);

355. PackageParser.Package downloadsUiPackage = getDefaultSystemHandlerActivityPackageLPr(

356. downloadsUiIntent, userId);

357. if (downloadsUiPackage != null

358. && doesPackageSupportRuntimePermissions(downloadsUiPackage)) {

359. grantRuntimePermissionsLPw(downloadsUiPackage, STORAGE_PERMISSIONS, true, userId);

360. }

361.  

362. // Storage provider

363. PackageParser.Package storagePackage = getDefaultProviderAuthorityPackageLPr(

364. "com.android.externalstorage.documents", userId);

365. if (storagePackage != null) {

366. grantRuntimePermissionsLPw(storagePackage, STORAGE_PERMISSIONS, true, userId);

367. }

368.  

369. // CertInstaller

370. Intent certInstallerIntent = new Intent(Credentials.INSTALL_ACTION);

371. PackageParser.Package certInstallerPackage = getDefaultSystemHandlerActivityPackageLPr(

372. certInstallerIntent, userId);

373. if (certInstallerPackage != null

374. && doesPackageSupportRuntimePermissions(certInstallerPackage)) {

375. grantRuntimePermissionsLPw(certInstallerPackage, STORAGE_PERMISSIONS, true, userId);

376. }

377.  

378. // Dialer

379. if (dialerAppPackageNames == null) {

380. Intent dialerIntent = new Intent(Intent.ACTION_DIAL);

381. PackageParser.Package dialerPackage = getDefaultSystemHandlerActivityPackageLPr(

382. dialerIntent, userId);

383. if (dialerPackage != null) {

384. grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);

385. }

386. } else {

387. for (String dialerAppPackageName : dialerAppPackageNames) {

388. PackageParser.Package dialerPackage = getSystemPackageLPr(dialerAppPackageName);

389. if (dialerPackage != null) {

390. grantDefaultPermissionsToDefaultSystemDialerAppLPr(dialerPackage, userId);

391. }

392. }

393. }

394.  

395. // Sim call manager

396. if (simCallManagerPackageNames != null) {

397. for (String simCallManagerPackageName : simCallManagerPackageNames) {

398. PackageParser.Package simCallManagerPackage =

399. getSystemPackageLPr(simCallManagerPackageName);

400. if (simCallManagerPackage != null) {

401. grantDefaultPermissionsToDefaultSimCallManagerLPr(simCallManagerPackage,

402. userId);

403. }

404. }

405. }

406.  

407. // SMS

408. if (smsAppPackageNames == null) {

409. Intent smsIntent = new Intent(Intent.ACTION_MAIN);

410. smsIntent.addCategory(Intent.CATEGORY_APP_MESSAGING);

411. PackageParser.Package smsPackage = getDefaultSystemHandlerActivityPackageLPr(

412. smsIntent, userId);

413. if (smsPackage != null) {

414. grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);

415. }

416. } else {

417. for (String smsPackageName : smsAppPackageNames) {

418. PackageParser.Package smsPackage = getSystemPackageLPr(smsPackageName);

419. if (smsPackage != null) {

420. grantDefaultPermissionsToDefaultSystemSmsAppLPr(smsPackage, userId);

421. }

422. }

423. }

424.  

425. // Cell Broadcast Receiver

426. Intent cbrIntent = new Intent(Intents.SMS_CB_RECEIVED_ACTION);

427. PackageParser.Package cbrPackage =

428. getDefaultSystemHandlerActivityPackageLPr(cbrIntent, userId);

429. if (cbrPackage != null && doesPackageSupportRuntimePermissions(cbrPackage)) {

430. grantRuntimePermissionsLPw(cbrPackage, SMS_PERMISSIONS, userId);

431. }

432.  

433. // Carrier Provisioning Service

434. Intent carrierProvIntent = new Intent(Intents.SMS_CARRIER_PROVISION_ACTION);

435. PackageParser.Package carrierProvPackage =

436. getDefaultSystemHandlerServicePackageLPr(carrierProvIntent, userId);

437. if (carrierProvPackage != null && doesPackageSupportRuntimePermissions(carrierProvPackage)) {

438. grantRuntimePermissionsLPw(carrierProvPackage, SMS_PERMISSIONS, false, userId);

439. }

440.  

441. // Calendar

442. Intent calendarIntent = new Intent(Intent.ACTION_MAIN);

443. calendarIntent.addCategory(Intent.CATEGORY_APP_CALENDAR);

444. PackageParser.Package calendarPackage = getDefaultSystemHandlerActivityPackageLPr(

445. calendarIntent, userId);

446. if (calendarPackage != null

447. && doesPackageSupportRuntimePermissions(calendarPackage)) {

448. grantRuntimePermissionsLPw(calendarPackage, CALENDAR_PERMISSIONS, userId);

449. grantRuntimePermissionsLPw(calendarPackage, CONTACTS_PERMISSIONS, userId);

450. }

451.  

452. // Calendar provider

453. PackageParser.Package calendarProviderPackage = getDefaultProviderAuthorityPackageLPr(

454. CalendarContract.AUTHORITY, userId);

455. if (calendarProviderPackage != null) {

456. grantRuntimePermissionsLPw(calendarProviderPackage, CONTACTS_PERMISSIONS, userId);

457. grantRuntimePermissionsLPw(calendarProviderPackage, CALENDAR_PERMISSIONS,

458. true, userId);

459. grantRuntimePermissionsLPw(calendarProviderPackage, STORAGE_PERMISSIONS, userId);

460. }

461.  

462. // Calendar provider sync adapters

463. List<PackageParser.Package> calendarSyncAdapters = getHeadlessSyncAdapterPackagesLPr(

464. calendarSyncAdapterPackages, userId);

465. final int calendarSyncAdapterCount = calendarSyncAdapters.size();

466. for (int i = 0; i < calendarSyncAdapterCount; i++) {

467. PackageParser.Package calendarSyncAdapter = calendarSyncAdapters.get(i);

468. if (doesPackageSupportRuntimePermissions(calendarSyncAdapter)) {

469. grantRuntimePermissionsLPw(calendarSyncAdapter, CALENDAR_PERMISSIONS, userId);

470. }

471. }

472.  

473. // Contacts

474. Intent contactsIntent = new Intent(Intent.ACTION_MAIN);

475. contactsIntent.addCategory(Intent.CATEGORY_APP_CONTACTS);

476. PackageParser.Package contactsPackage = getDefaultSystemHandlerActivityPackageLPr(

477. contactsIntent, userId);

478. if (contactsPackage != null

479. && doesPackageSupportRuntimePermissions(contactsPackage)) {

480. grantRuntimePermissionsLPw(contactsPackage, CONTACTS_PERMISSIONS, userId);

481. grantRuntimePermissionsLPw(contactsPackage, PHONE_PERMISSIONS, userId);

482. }

483.  

484. // Contacts provider sync adapters

485. List<PackageParser.Package> contactsSyncAdapters = getHeadlessSyncAdapterPackagesLPr(

486. contactsSyncAdapterPackages, userId);

487. final int contactsSyncAdapterCount = contactsSyncAdapters.size();

488. for (int i = 0; i < contactsSyncAdapterCount; i++) {

489. PackageParser.Package contactsSyncAdapter = contactsSyncAdapters.get(i);

490. if (doesPackageSupportRuntimePermissions(contactsSyncAdapter)) {

491. grantRuntimePermissionsLPw(contactsSyncAdapter, CONTACTS_PERMISSIONS, userId);

492. }

493. }

494.  

495. // Contacts provider

496. PackageParser.Package contactsProviderPackage = getDefaultProviderAuthorityPackageLPr(

497. ContactsContract.AUTHORITY, userId);

498. if (contactsProviderPackage != null) {

499. grantRuntimePermissionsLPw(contactsProviderPackage, CONTACTS_PERMISSIONS,

500. true, userId);

501. grantRuntimePermissionsLPw(contactsProviderPackage, PHONE_PERMISSIONS,

502. true, userId);

503. grantRuntimePermissionsLPw(contactsProviderPackage, STORAGE_PERMISSIONS, userId);

504. }

505.  

506. // Device provisioning

507. Intent deviceProvisionIntent = new Intent(

508. DevicePolicyManager.ACTION_PROVISION_MANAGED_DEVICE);

509. PackageParser.Package deviceProvisionPackage =

510. getDefaultSystemHandlerActivityPackageLPr(deviceProvisionIntent, userId);

511. if (deviceProvisionPackage != null

512. && doesPackageSupportRuntimePermissions(deviceProvisionPackage)) {

513. grantRuntimePermissionsLPw(deviceProvisionPackage, CONTACTS_PERMISSIONS, userId);

514. }

515.  

516. // Maps

517. Intent mapsIntent = new Intent(Intent.ACTION_MAIN);

518. mapsIntent.addCategory(Intent.CATEGORY_APP_MAPS);

519. PackageParser.Package mapsPackage = getDefaultSystemHandlerActivityPackageLPr(

520. mapsIntent, userId);

521. if (mapsPackage != null

522. && doesPackageSupportRuntimePermissions(mapsPackage)) {

523. grantRuntimePermissionsLPw(mapsPackage, LOCATION_PERMISSIONS, userId);

524. }

525.  

526. // Gallery

527. Intent galleryIntent = new Intent(Intent.ACTION_MAIN);

528. galleryIntent.addCategory(Intent.CATEGORY_APP_GALLERY);

529. PackageParser.Package galleryPackage = getDefaultSystemHandlerActivityPackageLPr(

530. galleryIntent, userId);

531. if (galleryPackage != null

532. && doesPackageSupportRuntimePermissions(galleryPackage)) {

533. grantRuntimePermissionsLPw(galleryPackage, STORAGE_PERMISSIONS, userId);

534. }

535.  

536. // Email

537. Intent emailIntent = new Intent(Intent.ACTION_MAIN);

538. emailIntent.addCategory(Intent.CATEGORY_APP_EMAIL);

539. PackageParser.Package emailPackage = getDefaultSystemHandlerActivityPackageLPr(

540. emailIntent, userId);

541. if (emailPackage != null

542. && doesPackageSupportRuntimePermissions(emailPackage)) {

543. grantRuntimePermissionsLPw(emailPackage, CONTACTS_PERMISSIONS, userId);

544. grantRuntimePermissionsLPw(emailPackage, CALENDAR_PERMISSIONS, userId);

545. }

546.  

547. // Browser

548. PackageParser.Package browserPackage = null;

549. String defaultBrowserPackage = mService.getDefaultBrowserPackageName(userId);

550. if (defaultBrowserPackage != null) {

551. browserPackage = getPackageLPr(defaultBrowserPackage);

552. }

553. if (browserPackage == null) {

554. Intent browserIntent = new Intent(Intent.ACTION_MAIN);

555. browserIntent.addCategory(Intent.CATEGORY_APP_BROWSER);

556. browserPackage = getDefaultSystemHandlerActivityPackageLPr(

557. browserIntent, userId);

558. }

559. if (browserPackage != null

560. && doesPackageSupportRuntimePermissions(browserPackage)) {

561. grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, userId);

562. }

563.  

564. // Voice interaction

565. if (voiceInteractPackageNames != null) {

566. for (String voiceInteractPackageName : voiceInteractPackageNames) {

567. PackageParser.Package voiceInteractPackage = getSystemPackageLPr(

568. voiceInteractPackageName);

569. if (voiceInteractPackage != null

570. && doesPackageSupportRuntimePermissions(voiceInteractPackage)) {

571. grantRuntimePermissionsLPw(voiceInteractPackage,

572. CONTACTS_PERMISSIONS, userId);

573. grantRuntimePermissionsLPw(voiceInteractPackage,

574. CALENDAR_PERMISSIONS, userId);

575. grantRuntimePermissionsLPw(voiceInteractPackage,

576. MICROPHONE_PERMISSIONS, userId);

577. grantRuntimePermissionsLPw(voiceInteractPackage,

578. PHONE_PERMISSIONS, userId);

579. grantRuntimePermissionsLPw(voiceInteractPackage,

580. SMS_PERMISSIONS, userId);

581. grantRuntimePermissionsLPw(voiceInteractPackage,

582. LOCATION_PERMISSIONS, userId);

583. }

584. }

585. }

586.  

587. // Voice recognition

588. Intent voiceRecoIntent = new Intent("android.speech.RecognitionService");

589. voiceRecoIntent.addCategory(Intent.CATEGORY_DEFAULT);

590. PackageParser.Package voiceRecoPackage = getDefaultSystemHandlerServicePackageLPr(

591. voiceRecoIntent, userId);

592. if (voiceRecoPackage != null

593. && doesPackageSupportRuntimePermissions(voiceRecoPackage)) {

594. grantRuntimePermissionsLPw(voiceRecoPackage, MICROPHONE_PERMISSIONS, userId);

595. }

596.  

597. // Location

598. if (locationPackageNames != null) {

599. for (String packageName : locationPackageNames) {

600. PackageParser.Package locationPackage = getSystemPackageLPr(packageName);

601. if (locationPackage != null

602. && doesPackageSupportRuntimePermissions(locationPackage)) {

603. grantRuntimePermissionsLPw(locationPackage, CONTACTS_PERMISSIONS, userId);

604. grantRuntimePermissionsLPw(locationPackage, CALENDAR_PERMISSIONS, userId);

605. grantRuntimePermissionsLPw(locationPackage, MICROPHONE_PERMISSIONS, userId);

606. grantRuntimePermissionsLPw(locationPackage, PHONE_PERMISSIONS, userId);

607. grantRuntimePermissionsLPw(locationPackage, SMS_PERMISSIONS, userId);

608. grantRuntimePermissionsLPw(locationPackage, LOCATION_PERMISSIONS,

609. true, userId);

610. grantRuntimePermissionsLPw(locationPackage, CAMERA_PERMISSIONS, userId);

611. grantRuntimePermissionsLPw(locationPackage, SENSORS_PERMISSIONS, userId);

612. grantRuntimePermissionsLPw(locationPackage, STORAGE_PERMISSIONS, userId);

613. }

614. }

615. }

616.  

617. // Music

618. Intent musicIntent = new Intent(Intent.ACTION_VIEW);

619. musicIntent.addCategory(Intent.CATEGORY_DEFAULT);

620. musicIntent.setDataAndType(Uri.fromFile(new File("foo.mp3")),

621. AUDIO_MIME_TYPE);

622. PackageParser.Package musicPackage = getDefaultSystemHandlerActivityPackageLPr(

623. musicIntent, userId);

624. if (musicPackage != null

625. && doesPackageSupportRuntimePermissions(musicPackage)) {

626. grantRuntimePermissionsLPw(musicPackage, STORAGE_PERMISSIONS, userId);

627. }

628.  

629. // Watches

630. if (mService.hasSystemFeature(PackageManager.FEATURE_WATCH, 0)) {

631. // Home application on watches

632. Intent homeIntent = new Intent(Intent.ACTION_MAIN);

633. homeIntent.addCategory(Intent.CATEGORY_HOME_MAIN);

634.  

635. PackageParser.Package wearHomePackage = getDefaultSystemHandlerActivityPackageLPr(

636. homeIntent, userId);

637.  

638. if (wearHomePackage != null

639. && doesPackageSupportRuntimePermissions(wearHomePackage)) {

640. grantRuntimePermissionsLPw(wearHomePackage, CONTACTS_PERMISSIONS, false,

641. userId);

642. grantRuntimePermissionsLPw(wearHomePackage, PHONE_PERMISSIONS, true, userId);

643. grantRuntimePermissionsLPw(wearHomePackage, MICROPHONE_PERMISSIONS, false,

644. userId);

645. grantRuntimePermissionsLPw(wearHomePackage, LOCATION_PERMISSIONS, false,

646. userId);

647. }

648.  

649. // Twinning on watches

650. Intent twinningIntent = new Intent(ACTION_TWINNING);

651. PackageParser.Package twinningPackage = getDefaultSystemHandlerActivityPackageLPr(

652. twinningIntent, userId);

653.  

654. if (twinningPackage != null

655. && doesPackageSupportRuntimePermissions(twinningPackage)) {

656. grantRuntimePermissionsLPw(twinningPackage, PHONE_PERMISSIONS, false, userId);

657. grantRuntimePermissionsLPw(twinningPackage, SMS_PERMISSIONS, false, userId);

658. }

659.  

660. // Fitness tracking on watches

661. Intent trackIntent = new Intent(ACTION_TRACK);

662. PackageParser.Package trackPackage = getDefaultSystemHandlerActivityPackageLPr(

663. trackIntent, userId);

664. if (trackPackage != null

665. && doesPackageSupportRuntimePermissions(trackPackage)) {

666. grantRuntimePermissionsLPw(trackPackage, SENSORS_PERMISSIONS, false, userId);

667. grantRuntimePermissionsLPw(trackPackage, LOCATION_PERMISSIONS, false, userId);

668. }

669. }

670.  

671. // Print Spooler

672. PackageParser.Package printSpoolerPackage = getSystemPackageLPr(

673. PrintManager.PRINT_SPOOLER_PACKAGE_NAME);

674. if (printSpoolerPackage != null

675. && doesPackageSupportRuntimePermissions(printSpoolerPackage)) {

676. grantRuntimePermissionsLPw(printSpoolerPackage, LOCATION_PERMISSIONS, true, userId);

677. }

678.  

679. // EmergencyInfo

680. Intent emergencyInfoIntent = new Intent(TelephonyManager.ACTION_EMERGENCY_ASSISTANCE);

681. PackageParser.Package emergencyInfoPckg = getDefaultSystemHandlerActivityPackageLPr(

682. emergencyInfoIntent, userId);

683. if (emergencyInfoPckg != null

684. && doesPackageSupportRuntimePermissions(emergencyInfoPckg)) {

685. grantRuntimePermissionsLPw(emergencyInfoPckg, CONTACTS_PERMISSIONS, true, userId);

686. grantRuntimePermissionsLPw(emergencyInfoPckg, PHONE_PERMISSIONS, true, userId);

687. }

688.  

689. // NFC Tag viewer

690. Intent nfcTagIntent = new Intent(Intent.ACTION_VIEW);

691. nfcTagIntent.setType("vnd.android.cursor.item/ndef_msg");

692. PackageParser.Package nfcTagPkg = getDefaultSystemHandlerActivityPackageLPr(

693. nfcTagIntent, userId);

694. if (nfcTagPkg != null

695. && doesPackageSupportRuntimePermissions(nfcTagPkg)) {

696. grantRuntimePermissionsLPw(nfcTagPkg, CONTACTS_PERMISSIONS, false, userId);

697. grantRuntimePermissionsLPw(nfcTagPkg, PHONE_PERMISSIONS, false, userId);

698. }

699.  

700. // Storage Manager

701. Intent storageManagerIntent = new Intent(StorageManager.ACTION_MANAGE_STORAGE);

702. PackageParser.Package storageManagerPckg = getDefaultSystemHandlerActivityPackageLPr(

703. storageManagerIntent, userId);

704. if (storageManagerPckg != null

705. && doesPackageSupportRuntimePermissions(storageManagerPckg)) {

706. grantRuntimePermissionsLPw(storageManagerPckg, STORAGE_PERMISSIONS, true, userId);

707. }

708. mService.mSettings.onDefaultRuntimePermissionsGrantedLPr(userId);

709. }

710. }

711.  

712. private void grantDefaultPermissionsToDefaultSystemDialerAppLPr(

713. PackageParser.Package dialerPackage, int userId) {

714. if (doesPackageSupportRuntimePermissions(dialerPackage)) {

715. boolean isPhonePermFixed =

716. mService.hasSystemFeature(PackageManager.FEATURE_WATCH, 0);

717. grantRuntimePermissionsLPw(

718. dialerPackage, PHONE_PERMISSIONS, isPhonePermFixed, userId);

719. grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, userId);

720. grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, userId);

721. grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, userId);

722. grantRuntimePermissionsLPw(dialerPackage, CAMERA_PERMISSIONS, userId);

723. }

724. }

725.  

726. private void grantDefaultPermissionsToDefaultSystemSmsAppLPr(

727. PackageParser.Package smsPackage, int userId) {

728. if (doesPackageSupportRuntimePermissions(smsPackage)) {

729. grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, userId);

730. grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, userId);

731. grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, userId);

732. }

733. }

734.  

735. public void grantDefaultPermissionsToDefaultSmsAppLPr(String packageName, int userId) {

736. Log.i(TAG, "Granting permissions to default sms app for user:" + userId);

737. if (packageName == null) {

738. return;

739. }

740. PackageParser.Package smsPackage = getPackageLPr(packageName);

741. if (smsPackage != null && doesPackageSupportRuntimePermissions(smsPackage)) {

742. grantRuntimePermissionsLPw(smsPackage, PHONE_PERMISSIONS, false, true, userId);

743. grantRuntimePermissionsLPw(smsPackage, CONTACTS_PERMISSIONS, false, true, userId);

744. grantRuntimePermissionsLPw(smsPackage, SMS_PERMISSIONS, false, true, userId);

745. }

746. }

747.  

748. public void grantDefaultPermissionsToDefaultDialerAppLPr(String packageName, int userId) {

749. Log.i(TAG, "Granting permissions to default dialer app for user:" + userId);

750. if (packageName == null) {

751. return;

752. }

753. PackageParser.Package dialerPackage = getPackageLPr(packageName);

754. if (dialerPackage != null

755. && doesPackageSupportRuntimePermissions(dialerPackage)) {

756. grantRuntimePermissionsLPw(dialerPackage, PHONE_PERMISSIONS, false, true, userId);

757. grantRuntimePermissionsLPw(dialerPackage, CONTACTS_PERMISSIONS, false, true, userId);

758. grantRuntimePermissionsLPw(dialerPackage, SMS_PERMISSIONS, false, true, userId);

759. grantRuntimePermissionsLPw(dialerPackage, MICROPHONE_PERMISSIONS, false, true, userId);

760. grantRuntimePermissionsLPw(dialerPackage, CAMERA_PERMISSIONS, false, true, userId);

761. }

762. }

763.  

764. private void grantDefaultPermissionsToDefaultSimCallManagerLPr(

765. PackageParser.Package simCallManagerPackage, int userId) {

766. Log.i(TAG, "Granting permissions to sim call manager for user:" + userId);

767. if (doesPackageSupportRuntimePermissions(simCallManagerPackage)) {

768. grantRuntimePermissionsLPw(simCallManagerPackage, PHONE_PERMISSIONS, userId);

769. grantRuntimePermissionsLPw(simCallManagerPackage, MICROPHONE_PERMISSIONS, userId);

770. }

771. }

772.  

773. public void grantDefaultPermissionsToDefaultSimCallManagerLPr(String packageName, int userId) {

774. if (packageName == null) {

775. return;

776. }

777. PackageParser.Package simCallManagerPackage = getPackageLPr(packageName);

778. if (simCallManagerPackage != null) {

779. grantDefaultPermissionsToDefaultSimCallManagerLPr(simCallManagerPackage, userId);

780. }

781. }

782.  

783. public void grantDefaultPermissionsToEnabledCarrierAppsLPr(String[] packageNames, int userId) {

784. Log.i(TAG, "Granting permissions to enabled carrier apps for user:" + userId);

785. if (packageNames == null) {

786. return;

787. }

788. for (String packageName : packageNames) {

789. PackageParser.Package carrierPackage = getSystemPackageLPr(packageName);

790. if (carrierPackage != null

791. && doesPackageSupportRuntimePermissions(carrierPackage)) {

792. grantRuntimePermissionsLPw(carrierPackage, PHONE_PERMISSIONS, userId);

793. grantRuntimePermissionsLPw(carrierPackage, LOCATION_PERMISSIONS, userId);

794. grantRuntimePermissionsLPw(carrierPackage, SMS_PERMISSIONS, userId);

795. }

796. }

797. }

798.  

799. public void grantDefaultPermissionsToDefaultBrowserLPr(String packageName, int userId) {

800. Log.i(TAG, "Granting permissions to default browser for user:" + userId);

801. if (packageName == null) {

802. return;

803. }

804. PackageParser.Package browserPackage = getSystemPackageLPr(packageName);

805. if (browserPackage != null

806. && doesPackageSupportRuntimePermissions(browserPackage)) {

807. grantRuntimePermissionsLPw(browserPackage, LOCATION_PERMISSIONS, false, false, userId);

808. }

809. }

810.  

811. private PackageParser.Package getDefaultSystemHandlerActivityPackageLPr(

812. Intent intent, int userId) {

813. ResolveInfo handler = mService.resolveIntent(intent,

814. intent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS, userId);

815. if (handler == null || handler.activityInfo == null) {

816. return null;

817. }

818. ActivityInfo activityInfo = handler.activityInfo;

819. if (activityInfo.packageName.equals(mService.mResolveActivity.packageName)

820. && activityInfo.name.equals(mService.mResolveActivity.name)) {

821. return null;

822. }

823. return getSystemPackageLPr(handler.activityInfo.packageName);

824. }

825.  

826. private PackageParser.Package getDefaultSystemHandlerServicePackageLPr(

827. Intent intent, int userId) {

828. List<ResolveInfo> handlers = mService.queryIntentServices(intent,

829. intent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS, userId)

830. .getList();

831. if (handlers == null) {

832. return null;

833. }

834. final int handlerCount = handlers.size();

835. for (int i = 0; i < handlerCount; i++) {

836. ResolveInfo handler = handlers.get(i);

837. PackageParser.Package handlerPackage = getSystemPackageLPr(

838. handler.serviceInfo.packageName);

839. if (handlerPackage != null) {

840. return handlerPackage;

841. }

842. }

843. return null;

844. }

845.  

846. private List<PackageParser.Package> getHeadlessSyncAdapterPackagesLPr(

847. String[] syncAdapterPackageNames, int userId) {

848. List<PackageParser.Package> syncAdapterPackages = new ArrayList<>();

849.  

850. Intent homeIntent = new Intent(Intent.ACTION_MAIN);

851. homeIntent.addCategory(Intent.CATEGORY_LAUNCHER);

852.  

853. for (String syncAdapterPackageName : syncAdapterPackageNames) {

854. homeIntent.setPackage(syncAdapterPackageName);

855.  

856. ResolveInfo homeActivity = mService.resolveIntent(homeIntent,

857. homeIntent.resolveType(mService.mContext.getContentResolver()), DEFAULT_FLAGS,

858. userId);

859. if (homeActivity != null) {

860. continue;

861. }

862.  

863. PackageParser.Package syncAdapterPackage = getSystemPackageLPr(syncAdapterPackageName);

864. if (syncAdapterPackage != null) {

865. syncAdapterPackages.add(syncAdapterPackage);

866. }

867. }

868.  

869. return syncAdapterPackages;

870. }

871.  

872. private PackageParser.Package getDefaultProviderAuthorityPackageLPr(

873. String authority, int userId) {

874. ProviderInfo provider = mService.resolveContentProvider(authority, DEFAULT_FLAGS, userId);

875. if (provider != null) {

876. return getSystemPackageLPr(provider.packageName);

877. }

878. return null;

879. }

880.  

881. private PackageParser.Package getPackageLPr(String packageName) {

882. return mService.mPackages.get(packageName);

883. }

884.  

885. private PackageParser.Package getSystemPackageLPr(String packageName) {

886. PackageParser.Package pkg = getPackageLPr(packageName);

887. if (pkg != null && pkg.isSystemApp()) {

888. return !isSysComponentOrPersistentPlatformSignedPrivAppLPr(pkg) ? pkg : null;

889. }

890. return null;

891. }

892.  

893. private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,

894. int userId) {

895. grantRuntimePermissionsLPw(pkg, permissions, false, false, userId);

896. }

897.  

898. private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,

899. boolean systemFixed, int userId) {

900. grantRuntimePermissionsLPw(pkg, permissions, systemFixed, false, userId);

901. }

902.  

903. private void grantRuntimePermissionsLPw(PackageParser.Package pkg, Set<String> permissions,

904. boolean systemFixed, boolean isDefaultPhoneOrSms, int userId) {

905. if (pkg.requestedPermissions.isEmpty()) {

906. return;

907. }

908.  

909. List<String> requestedPermissions = pkg.requestedPermissions;

910. Set<String> grantablePermissions = null;

911.  

912. // If this is the default Phone or SMS app we grant permissions regardless

913. // whether the version on the system image declares the permission as used since

914. // selecting the app as the default Phone or SMS the user makes a deliberate

915. // choice to grant this app the permissions needed to function. For all other

916. // apps, (default grants on first boot and user creation) we don't grant default

917. // permissions if the version on the system image does not declare them.

918. if (!isDefaultPhoneOrSms && pkg.isUpdatedSystemApp()) {

919. PackageSetting sysPs = mService.mSettings.getDisabledSystemPkgLPr(pkg.packageName);

920. if (sysPs != null) {

921. if (sysPs.pkg.requestedPermissions.isEmpty()) {

922. return;

923. }

924. if (!requestedPermissions.equals(sysPs.pkg.requestedPermissions)) {

925. grantablePermissions = new ArraySet<>(requestedPermissions);

926. requestedPermissions = sysPs.pkg.requestedPermissions;

927. }

928. }

929. }

930.  

931. final int grantablePermissionCount = requestedPermissions.size();

932. for (int i = 0; i < grantablePermissionCount; i++) {

933. String permission = requestedPermissions.get(i);

934.  

935. // If there is a disabled system app it may request a permission the updated

936. // version ot the data partition doesn't, In this case skip the permission.

937. if (grantablePermissions != null && !grantablePermissions.contains(permission)) {

938. continue;

939. }

940.  

941. if (permissions.contains(permission)) {

942. final int flags = mService.getPermissionFlags(permission, pkg.packageName, userId);

943.  

944. // If any flags are set to the permission, then it is either set in

945. // its current state by the system or device/profile owner or the user.

946. // In all these cases we do not want to clobber the current state.

947. // Unless the caller wants to override user choices. The override is

948. // to make sure we can grant the needed permission to the default

949. // sms and phone apps after the user chooses this in the UI.

950. if (flags == 0 || isDefaultPhoneOrSms) {

951. // Never clobber policy or system.

952. final int fixedFlags = PackageManager.FLAG_PERMISSION_SYSTEM_FIXED

953. | PackageManager.FLAG_PERMISSION_POLICY_FIXED;

954. if ((flags & fixedFlags) != 0) {

955. continue;

956. }

957.  

958. mService.grantRuntimePermission(pkg.packageName, permission, userId);

959. if (DEBUG) {

960. Log.i(TAG, "Granted " + (systemFixed ? "fixed " : "not fixed ")

961. + permission + " to default handler " + pkg.packageName);

962. }

963.  

964. int newFlags = PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT;

965. if (systemFixed) {

966. newFlags |= PackageManager.FLAG_PERMISSION_SYSTEM_FIXED;

967. }

968.  

969. mService.updatePermissionFlags(permission, pkg.packageName,

970. newFlags, newFlags, userId);

971. }

972.  

973. // If a component gets a permission for being the default handler A

974. // and also default handler B, we grant the weaker grant form.

975. if ((flags & PackageManager.FLAG_PERMISSION_GRANTED_BY_DEFAULT) != 0

976. && (flags & PackageManager.FLAG_PERMISSION_SYSTEM_FIXED) != 0

977. && !systemFixed) {

978. if (DEBUG) {

979. Log.i(TAG, "Granted not fixed " + permission + " to default handler "

980. + pkg.packageName);

981. }

982. mService.updatePermissionFlags(permission, pkg.packageName,

983. PackageManager.FLAG_PERMISSION_SYSTEM_FIXED, 0, userId);

984. }

985. }

986. }

987. }

988.  

989. private boolean isSysComponentOrPersistentPlatformSignedPrivAppLPr(PackageParser.Package pkg) {

990. if (UserHandle.getAppId(pkg.applicationInfo.uid) < FIRST_APPLICATION_UID) {

991. return true;

992. }

993. if (!pkg.isPrivilegedApp()) {

994. return false;

995. }

996. PackageSetting sysPkg = mService.mSettings.getDisabledSystemPkgLPr(pkg.packageName);

997. if (sysPkg != null && sysPkg.pkg != null) {

998. if ((sysPkg.pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {

999. return false;

1000. }

1001. } else if ((pkg.applicationInfo.flags & ApplicationInfo.FLAG_PERSISTENT) == 0) {

1002. return false;

1003. }

1004. return PackageManagerService.compareSignatures(mService.mPlatformPackage.mSignatures,

1005. pkg.mSignatures) == PackageManager.SIGNATURE_MATCH;

1006. }

1007.  

1008. private void grantDefaultPermissionExceptions(int userId) {

1009. synchronized (mService.mPackages) {

1010. mHandler.removeMessages(MSG_READ_DEFAULT_PERMISSION_EXCEPTIONS);

1011.  

1012. if (mGrantExceptions == null) {

1013. mGrantExceptions = readDefaultPermissionExceptionsLPw();

1014. }

1015.  

1016. // mGrantExceptions is null only before the first read and then

1017. // it serves as a cache of the default grants that should be

1018. // performed for every user. If there is an entry then the app

1019. // is on the system image and supports runtime permissions.

1020. Set<String> permissions = null;

1021. final int exceptionCount = mGrantExceptions.size();

1022. for (int i = 0; i < exceptionCount; i++) {

1023. String packageName = mGrantExceptions.keyAt(i);

1024. PackageParser.Package pkg = getSystemPackageLPr(packageName);

1025. List<DefaultPermissionGrant> permissionGrants = mGrantExceptions.valueAt(i);

1026. final int permissionGrantCount = permissionGrants.size();

1027. for (int j = 0; j < permissionGrantCount; j++) {

1028. DefaultPermissionGrant permissionGrant = permissionGrants.get(j);

1029. if (permissions == null) {

1030. permissions = new ArraySet<>();

1031. } else {

1032. permissions.clear();

1033. }

1034. permissions.add(permissionGrant.name);

1035. grantRuntimePermissionsLPw(pkg, permissions, false,

1036. permissionGrant.fixed, userId);

1037. }

1038. }

1039. }

1040. }

1041.  

1042. private @NonNull ArrayMap<String, List<DefaultPermissionGrant>>

1043. readDefaultPermissionExceptionsLPw() {

1044. File dir = new File(Environment.getRootDirectory(), "etc/default-permissions");

1045. if (!dir.exists() || !dir.isDirectory() || !dir.canRead()) {

1046. return new ArrayMap<>(0);

1047. }

1048.  

1049. File[] files = dir.listFiles();

1050. if (files == null) {

1051. return new ArrayMap<>(0);

1052. }

1053.  

1054. ArrayMap<String, List<DefaultPermissionGrant>> grantExceptions = new ArrayMap<>();

1055.  

1056. // Iterate over the files in the directory and scan .xml files

1057. for (File file : files) {

1058. if (!file.getPath().endsWith(".xml")) {

1059. Slog.i(TAG, "Non-xml file " + file + " in " + dir + " directory, ignoring");

1060. continue;

1061. }

1062. if (!file.canRead()) {

1063. Slog.w(TAG, "Default permissions file " + file + " cannot be read");

1064. continue;

1065. }

1066. try (

1067. InputStream str = new BufferedInputStream(new FileInputStream(file))

1068. ) {

1069. XmlPullParser parser = Xml.newPullParser();

1070. parser.setInput(str, null);

1071. parse(parser, grantExceptions);

1072. } catch (XmlPullParserException | IOException e) {

1073. Slog.w(TAG, "Error reading default permissions file " + file, e);

1074. }

1075. }

1076.  

1077. return grantExceptions;

1078. }

1079.  

1080. private void parse(XmlPullParser parser, Map<String, List<DefaultPermissionGrant>>

1081. outGrantExceptions) throws IOException, XmlPullParserException {

1082. final int outerDepth = parser.getDepth();

1083. int type;

1084. while ((type = parser.next()) != XmlPullParser.END_DOCUMENT

1085. && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {

1086. if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {

1087. continue;

1088. }

1089. if (TAG_EXCEPTIONS.equals(parser.getName())) {

1090. parseExceptions(parser, outGrantExceptions);

1091. } else {

1092. Log.e(TAG, "Unknown tag " + parser.getName());

1093. }

1094. }

1095. }

1096.  

1097. private void parseExceptions(XmlPullParser parser, Map<String, List<DefaultPermissionGrant>>

1098. outGrantExceptions) throws IOException, XmlPullParserException {

1099. final int outerDepth = parser.getDepth();

1100. int type;

1101. while ((type = parser.next()) != XmlPullParser.END_DOCUMENT

1102. && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {

1103. if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {

1104. continue;

1105. }

1106. if (TAG_EXCEPTION.equals(parser.getName())) {

1107. String packageName = parser.getAttributeValue(null, ATTR_PACKAGE);

1108.  

1109. List<DefaultPermissionGrant> packageExceptions =

1110. outGrantExceptions.get(packageName);

1111. if (packageExceptions == null) {

1112. // The package must be on the system image

1113. PackageParser.Package pkg = getSystemPackageLPr(packageName);

1114. if (pkg == null) {

1115. Log.w(TAG, "Unknown package:" + packageName);

1116. XmlUtils.skipCurrentTag(parser);

1117. continue;

1118. }

1119.  

1120. // The package must support runtime permissions

1121. if (!doesPackageSupportRuntimePermissions(pkg)) {

1122. Log.w(TAG, "Skipping non supporting runtime permissions package:"

1123. + packageName);

1124. XmlUtils.skipCurrentTag(parser);

1125. continue;

1126. }

1127. packageExceptions = new ArrayList<>();

1128. outGrantExceptions.put(packageName, packageExceptions);

1129. }

1130.  

1131. parsePermission(parser, packageExceptions);

1132. } else {

1133. Log.e(TAG, "Unknown tag " + parser.getName() + "under <exceptions>");

1134. }

1135. }

1136. }

1137.  

1138. private void parsePermission(XmlPullParser parser, List<DefaultPermissionGrant>

1139. outPackageExceptions) throws IOException, XmlPullParserException {

1140. final int outerDepth = parser.getDepth();

1141. int type;

1142. while ((type = parser.next()) != XmlPullParser.END_DOCUMENT

1143. && (type != XmlPullParser.END_TAG || parser.getDepth() > outerDepth)) {

1144. if (type == XmlPullParser.END_TAG || type == XmlPullParser.TEXT) {

1145. continue;

1146. }

1147.  

1148. if (TAG_PERMISSION.contains(parser.getName())) {

1149. String name = parser.getAttributeValue(null, ATTR_NAME);

1150. if (name == null) {

1151. Log.w(TAG, "Mandatory name attribute missing for permission tag");

1152. XmlUtils.skipCurrentTag(parser);

1153. continue;

1154. }

1155.  

1156. final boolean fixed = XmlUtils.readBooleanAttribute(parser, ATTR_FIXED);

1157.  

1158. DefaultPermissionGrant exception = new DefaultPermissionGrant(name, fixed);

1159. outPackageExceptions.add(exception);

1160. } else {

1161. Log.e(TAG, "Unknown tag " + parser.getName() + "under <exception>");

1162. }

1163. }

1164. }

1165.  

1166. private static boolean doesPackageSupportRuntimePermissions(PackageParser.Package pkg) {

1167. return pkg.applicationInfo.targetSdkVersion > Build.VERSION_CODES.LOLLIPOP_MR1;

1168. }

1169.  

1170. private static final class DefaultPermissionGrant {

1171. final String name;

1172. final boolean fixed;

1173.  

1174. public DefaultPermissionGrant(String name, boolean fixed) {

1175. this.name = name;

1176. this.fixed = fixed;

1177. }

1178. }

1179. }