public class PackageImpl implements ParsedPackage, AndroidPackageInternal,
        AndroidPackageHidden, ParsingPackage, ParsingPackageHidden, Parcelable {
    ...
    private String sharedUserId;

    private List<ParsedUsesPermission> usesPermissions = emptyList();
}

public void onPackageInstalled(@NonNull AndroidPackage pkg, int previousAppId,
        @NonNull PermissionManagerServiceInternal.PackageInstalledParams params,
        @UserIdInt int userId) {
    ...
    onPackageInstalledInternal(pkg, previousAppId, params, userIds);
}

private void onPackageInstalledInternal(@NonNull AndroidPackage pkg, int previousAppId,
        @NonNull PermissionManagerServiceInternal.PackageInstalledParams params,
        @UserIdInt int[] userIds) {
    ...
    updatePermissions(pkg.getPackageName(), pkg);
    for (final int userId : userIds) {
        addAllowlistedRestrictedPermissionsInternal(pkg,
                params.getAllowlistedRestrictedPermissions(),
                FLAG_PERMISSION_WHITELIST_INSTALLER, userId);
        grantRequestedPermissionsInternal(pkg, params.getPermissionStates(), userId);
    }
}

private void updatePermissions(@NonNull String packageName, @Nullable AndroidPackage pkg) {
    /**
    *如果传入的pkg为空，需要更新所有包的权限并替换包的权限信息
    *否则只替换报的权限信息
    **/
    final int flags =
            (pkg == null ? UPDATE_PERMISSIONS_ALL | UPDATE_PERMISSIONS_REPLACE_PKG
                    : UPDATE_PERMISSIONS_REPLACE_PKG);
    //调用另一个updatePermission方法
    updatePermissions(
            packageName, pkg, getVolumeUuidForPackage(pkg), flags, mDefaultPermissionCallback);
}


private void updatePermissions(final @Nullable String changingPkgName,
        final @Nullable AndroidPackage changingPkg,
        final @Nullable String replaceVolumeUuid,
        @UpdatePermissionFlags int flags,
        final @Nullable PermissionCallback callback) {
    //callback为PermissionManagerServiceImpl内部定义的mDefaultPermissionCallback
    if ((flags & UPDATE_PERMISSIONS_ALL) != 0) {
        final boolean replaceAll = ((flags & UPDATE_PERMISSIONS_REPLACE_ALL) != 0);
        mPackageManagerInt.forEachPackage((AndroidPackage pkg) -> {
            ...
            restorePermissionState(pkg, replace, changingPkgName, callback,
                    UserHandle.USER_ALL);
        });
    }
    if (changingPkg != null) {
        ...
        restorePermissionState(changingPkg, replace, changingPkgName, callback,
                UserHandle.USER_ALL);
    }
}

private void restorePermissionState(@NonNull AndroidPackage pkg, boolean replace,
        @Nullable String changingPackageName, @Nullable PermissionCallback callback,
        @UserIdInt int filterUserId) {
    final PackageStateInternal ps =
        mPackageManagerInt.getPackageStateInternal(pkg.getPackageName());
    ...

    for (final String permissionName : pkg.getRequestedPermissions()) {
        final Permission permission;
        synchronized (mLock) {
            permission = mRegistry.getPermission(permissionName);
        }
        if (permission == null) {
            continue;
        }
        //如果权限是privileged权限且在allowlist中进行了授权
        if (permission.isPrivileged()
                && checkPrivilegedPermissionAllowlist(pkg, ps, permission)) {
            if (isPrivilegedPermissionAllowlisted == null) {
                isPrivilegedPermissionAllowlisted = new ArraySet<>();
            }
            isPrivilegedPermissionAllowlisted.add(permissionName);
        }
        //如果权限是signature权限
        if (permission.isSignature() && (shouldGrantPermissionBySignature(pkg, permission)
                || shouldGrantPermissionByProtectionFlags(pkg, ps, permission,
                        shouldGrantPrivilegedPermissionIfWasGranted))) {
            if (shouldGrantSignaturePermission == null) {
                shouldGrantSignaturePermission = new ArraySet<>();
            }
            shouldGrantSignaturePermission.add(permissionName);
        }
        //内部权限
        if (permission.isInternal()
                && shouldGrantPermissionByProtectionFlags(pkg, ps, permission,
                        shouldGrantPrivilegedPermissionIfWasGranted)) {
            if (shouldGrantInternalPermission == null) {
                shouldGrantInternalPermission = new ArraySet<>();
            }
            shouldGrantInternalPermission.add(permissionName);
        }
    }

    //特定uid显式请求的权限
    Collection<String> uidRequestedPermissions;
    //特定uid隐式具有的权限
    Collection<String> uidImplicitPermissions;

    ...

    //进行权限授予的操作
    ...

    //调用callback的onPermissionUpdated方法
    if (callback != null) {
        callback.onPermissionUpdated(updatedUserIds,
                (changingPackageName != null && replace && installPermissionsChanged)
                        || runtimePermissionsRevoked, pkg.getUid());
    }
    
}

public boolean grantPermission(@NonNull Permission permission) {
    final PermissionState permissionState = getOrCreatePermissionState(permission);
    return permissionState.grant();
}

public boolean grant() {
    synchronized (mLock) {
        if (mGranted) {
            return false;
        }
        mGranted = true;
        UidPermissionState.invalidateCache();
        return true;
    }
}

private final PermissionCallback mDefaultPermissionCallback = new PermissionCallback() {
    ...

    @Override
    public void onInstallPermissionUpdated() {
        mPackageManagerInt.writeSettings(true);
    }
};

void writeSettings(boolean sync) {
    synchronized (mLock) {
        ...
        writeSettingsLPrTEMP(sync);
        ...
    }
}

void writeSettingsLPrTEMP(boolean sync) {
    snapshotComputer(false);
    mPermissionManager.writeLegacyPermissionsTEMP(mSettings.mPermissions);
    mSettings.writeLPr(mLiveComputer, sync);
}

final int uid = UserHandle.getUid(userId, pkg.getUid());
if (callback != null) {
    if (isRuntimePermission) {
        callback.onPermissionGranted(uid, userId);
    } else {
        callback.onInstallPermissionGranted();
    }
    if (permissionHasGids) {
        callback.onGidsChanged(UserHandle.getAppId(pkg.getUid()), userId);
    }
}