@Override
@SuppressWarnings("unchecked")
public List<PermissionInfo> queryPermissionsByGroup(String group, int flags)
        throws NameNotFoundException {
    try {
        ParceledListSlice<PermissionInfo> parceledList =
                mPM.queryPermissionsByGroup(group, flags);
        if (parceledList != null) {
            List<PermissionInfo> pi = parceledList.getList();
            if (pi != null) {
                return pi;
            }
        }
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }

    throw new NameNotFoundException(group);
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentContentProvidersAsUser(
        Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentContentProviders(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<PermissionInfo> queryPermissionsByGroup(String group, int flags)
        throws NameNotFoundException {
    try {
        ParceledListSlice<PermissionInfo> parceledList =
                mPM.queryPermissionsByGroup(group, flags);
        if (parceledList != null) {
            List<PermissionInfo> pi = parceledList.getList();
            if (pi != null) {
                return pi;
            }
        }
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }

    throw new NameNotFoundException(group);
}
 

/**
 * @hide
 */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentReceivers(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags,  userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentServicesAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentServices(intent,
                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentContentProvidersAsUser(
        Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentContentProviders(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public FeatureInfo[] getSystemAvailableFeatures() {
    try {
        ParceledListSlice<FeatureInfo> parceledList =
                mPM.getSystemAvailableFeatures();
        if (parceledList == null) {
            return new FeatureInfo[0];
        }
        final List<FeatureInfo> list = parceledList.getList();
        final FeatureInfo[] res = new FeatureInfo[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * @hide
 */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList = mPM.queryIntentReceivers(
                intent,
                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                updateFlagsForComponent(flags, userId, intent),
                userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * @hide
 */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentReceivers(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags,  userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/** @hide Same as above but for a specific user */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentActivitiesAsUser(Intent intent,
        int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList = mPM.queryIntentActivities(
                intent,
                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                updateFlagsForComponent(flags, userId, intent),
                userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentContentProvidersAsUser(
        Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentContentProviders(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public FeatureInfo[] getSystemAvailableFeatures() {
    try {
        ParceledListSlice<FeatureInfo> parceledList =
                mPM.getSystemAvailableFeatures();
        if (parceledList == null) {
            return new FeatureInfo[0];
        }
        final List<FeatureInfo> list = parceledList.getList();
        final FeatureInfo[] res = new FeatureInfo[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@SuppressWarnings("unchecked")
@Override
public List<PackageInfo> getPackagesHoldingPermissions(
        String[] permissions, int flags) {
    final int userId = mContext.getUserId();
    try {
        ParceledListSlice<PackageInfo> parceledList =
                mPM.getPackagesHoldingPermissions(permissions, flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public FeatureInfo[] getSystemAvailableFeatures() {
    try {
        ParceledListSlice<FeatureInfo> parceledList =
                mPM.getSystemAvailableFeatures();
        if (parceledList == null) {
            return new FeatureInfo[0];
        }
        final List<FeatureInfo> list = parceledList.getList();
        final FeatureInfo[] res = new FeatureInfo[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public FeatureInfo[] getSystemAvailableFeatures() {
    try {
        ParceledListSlice<FeatureInfo> parceledList =
                mPM.getSystemAvailableFeatures();
        if (parceledList == null) {
            return new FeatureInfo[0];
        }
        final List<FeatureInfo> list = parceledList.getList();
        final FeatureInfo[] res = new FeatureInfo[list.size()];
        for (int i = 0; i < res.length; i++) {
            res[i] = list.get(i);
        }
        return res;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * @hide
 */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentReceivers(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags,  userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

private ParceledListSlice<ResolveInfo> queryActivitiesForUser(String callingPackage,
        Intent intent, UserHandle user) {
    if (!canAccessProfile(user.getIdentifier(), "Cannot retrieve activities")) {
        return null;
    }

    final int callingUid = injectBinderCallingUid();
    long ident = injectClearCallingIdentity();
    try {
        final PackageManagerInternal pmInt =
                LocalServices.getService(PackageManagerInternal.class);
        List<ResolveInfo> apps = pmInt.queryIntentActivities(intent,
                PackageManager.MATCH_DIRECT_BOOT_AWARE
                        | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
                callingUid, user.getIdentifier());
        return new ParceledListSlice<>(apps);
    } finally {
        injectRestoreCallingIdentity(ident);
    }
}
 

@SuppressWarnings("unchecked")
@Override
public List<PackageInfo> getPackagesHoldingPermissions(
        String[] permissions, int flags) {
    final int userId = mContext.getUserId();
    try {
        ParceledListSlice<PackageInfo> parceledList =
                mPM.getPackagesHoldingPermissions(permissions, flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/** @hide Same as above but for a specific user */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentActivitiesAsUser(Intent intent,
        int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentActivities(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * @hide
 */
@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryBroadcastReceiversAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentReceivers(intent,
                        intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                        flags,  userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public ParceledListSlice getShortcuts(String callingPackage, long changedSince,
        String packageName, List shortcutIds, ComponentName componentName, int flags,
        UserHandle targetUser) {
    ensureShortcutPermission(callingPackage);
    if (!canAccessProfile(targetUser.getIdentifier(), "Cannot get shortcuts")) {
        return new ParceledListSlice<>(Collections.EMPTY_LIST);
    }
    if (shortcutIds != null && packageName == null) {
        throw new IllegalArgumentException(
                "To query by shortcut ID, package name must also be set");
    }

    // TODO(b/29399275): Eclipse compiler requires explicit List<ShortcutInfo> cast below.
    return new ParceledListSlice<>((List<ShortcutInfo>)
            mShortcutServiceInternal.getShortcuts(getCallingUserId(),
                    callingPackage, changedSince, packageName, shortcutIds,
                    componentName, flags, targetUser.getIdentifier(),
                    injectBinderCallingPid(), injectBinderCallingUid()));
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentServicesAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentServices(intent,
                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                flags, userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

/**
 * {@hide}
 * Returns the current standby bucket of every app that has a bucket assigned to it.
 * The caller must hold the permission android.permission.PACKAGE_USAGE_STATS. The key of the
 * returned Map is the package name and the value is the bucket assigned to the package.
 * @see #getAppStandbyBucket()
 */
@SystemApi
@RequiresPermission(android.Manifest.permission.PACKAGE_USAGE_STATS)
public Map<String, Integer> getAppStandbyBuckets() {
    try {
        final ParceledListSlice<AppStandbyInfo> slice = mService.getAppStandbyBuckets(
                mContext.getOpPackageName(), mContext.getUserId());
        final List<AppStandbyInfo> bucketList = slice.getList();
        final ArrayMap<String, Integer> bucketMap = new ArrayMap<>();
        final int n = bucketList.size();
        for (int i = 0; i < n; i++) {
            final AppStandbyInfo bucketInfo = bucketList.get(i);
            bucketMap.put(bucketInfo.mPackageName, bucketInfo.mStandbyBucket);
        }
        return bucketMap;
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentServicesAsUser(Intent intent, int flags, int userId) {
    try {
        ParceledListSlice<ResolveInfo> parceledList = mPM.queryIntentServices(
                intent,
                intent.resolveTypeIfNeeded(mContext.getContentResolver()),
                updateFlagsForComponent(flags, userId, intent),
                userId);
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
public ParceledListSlice getShortcutConfigActivities(
        String callingPackage, String packageName, UserHandle user)
        throws RemoteException {
    return queryActivitiesForUser(callingPackage,
            new Intent(Intent.ACTION_CREATE_SHORTCUT).setPackage(packageName), user);
}
 

/** @hide */
@SuppressWarnings("unchecked")
@Override
public List<EphemeralApplicationInfo> getEphemeralApplications() {
    try {
        ParceledListSlice<EphemeralApplicationInfo> slice =
                mPM.getEphemeralApplications(mContext.getUserId());
        if (slice != null) {
            return slice.getList();
        }
        return Collections.emptyList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

private int uninstallSystemUpdates() {
    final PrintWriter pw = getOutPrintWriter();
    List<String> failedUninstalls = new LinkedList<>();
    try {
        final ParceledListSlice<ApplicationInfo> packages =
                mInterface.getInstalledApplications(
                        PackageManager.MATCH_SYSTEM_ONLY, UserHandle.USER_SYSTEM);
        final IPackageInstaller installer = mInterface.getPackageInstaller();
        List<ApplicationInfo> list = packages.getList();
        for (ApplicationInfo info : list) {
            if (info.isUpdatedSystemApp()) {
                pw.println("Uninstalling updates to " + info.packageName + "...");
                final LocalIntentReceiver receiver = new LocalIntentReceiver();
                installer.uninstall(new VersionedPackage(info.packageName,
                                info.versionCode), null /*callerPackageName*/, 0 /* flags */,
                        receiver.getIntentSender(), 0);

                final Intent result = receiver.getResult();
                final int status = result.getIntExtra(PackageInstaller.EXTRA_STATUS,
                        PackageInstaller.STATUS_FAILURE);
                if (status != PackageInstaller.STATUS_SUCCESS) {
                    failedUninstalls.add(info.packageName);
                }
            }
        }
    } catch (RemoteException e) {
        pw.println("Failure ["
                + e.getClass().getName() + " - "
                + e.getMessage() + "]");
        return 0;
    }
    if (!failedUninstalls.isEmpty()) {
        pw.println("Failure [Couldn't uninstall packages: "
                + TextUtils.join(", ", failedUninstalls)
                + "]");
        return 0;
    }
    pw.println("Success");
    return 1;
}
 

private StatusBarNotification[] cleanUpNotificationList(
        ParceledListSlice<StatusBarNotification> parceledList) {
    if (parceledList == null || parceledList.getList() == null) {
        return new StatusBarNotification[0];
    }
    List<StatusBarNotification> list = parceledList.getList();
    ArrayList<StatusBarNotification> corruptNotifications = null;
    int N = list.size();
    for (int i = 0; i < N; i++) {
        StatusBarNotification sbn = list.get(i);
        Notification notification = sbn.getNotification();
        try {
            // convert icon metadata to legacy format for older clients
            createLegacyIconExtras(notification);
            // populate remote views for older clients.
            maybePopulateRemoteViews(notification);
            // populate people for older clients.
            maybePopulatePeople(notification);
        } catch (IllegalArgumentException e) {
            if (corruptNotifications == null) {
                corruptNotifications = new ArrayList<>(N);
            }
            corruptNotifications.add(sbn);
            Log.w(TAG, "get(Active/Snoozed)Notifications: can't rebuild notification from " +
                    sbn.getPackageName());
        }
    }
    if (corruptNotifications != null) {
        list.removeAll(corruptNotifications);
    }
    return list.toArray(new StatusBarNotification[list.size()]);
}
 

@Override
@SuppressWarnings("unchecked")
public List<ResolveInfo> queryIntentActivityOptions(
    ComponentName caller, Intent[] specifics, Intent intent,
    int flags) {
    final ContentResolver resolver = mContext.getContentResolver();

    String[] specificTypes = null;
    if (specifics != null) {
        final int N = specifics.length;
        for (int i=0; i<N; i++) {
            Intent sp = specifics[i];
            if (sp != null) {
                String t = sp.resolveTypeIfNeeded(resolver);
                if (t != null) {
                    if (specificTypes == null) {
                        specificTypes = new String[N];
                    }
                    specificTypes[i] = t;
                }
            }
        }
    }

    try {
        ParceledListSlice<ResolveInfo> parceledList =
                mPM.queryIntentActivityOptions(caller, specifics, specificTypes, intent,
                intent.resolveTypeIfNeeded(resolver), flags, mContext.getUserId());
        if (parceledList == null) {
            return Collections.emptyList();
        }
        return parceledList.getList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

@Override
@SuppressWarnings("unchecked")
public List<ProviderInfo> queryContentProviders(String processName,
        int uid, int flags) {
    try {
        ParceledListSlice<ProviderInfo> slice =
                mPM.queryContentProviders(processName, uid, flags);
        return slice != null ? slice.getList() : Collections.<ProviderInfo>emptyList();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}