Java Code Examples for android.app.AppGlobals#getPackageManager()

/**
 * Return true if all given permissions are signature-only perms.
 */
final boolean isSignaturePerm(String[] perms) {
    if (perms == null) {
        return false;
    }
    IPackageManager pm = AppGlobals.getPackageManager();
    for (int i = perms.length-1; i >= 0; i--) {
        try {
            PermissionInfo pi = pm.getPermissionInfo(perms[i], "android", 0);
            if ((pi.protectionLevel & (PermissionInfo.PROTECTION_MASK_BASE
                    | PermissionInfo.PROTECTION_FLAG_PRIVILEGED))
                    != PermissionInfo.PROTECTION_SIGNATURE) {
                // If this a signature permission and NOT allowed for privileged apps, it
                // is okay...  otherwise, nope!
                return false;
            }
        } catch (RemoteException e) {
            return false;
        }
    }
    return true;
}
 

@Override
public boolean onCreate() {
    Settings.setInSystemServer();
    synchronized (mLock) {
        mUserManager = UserManager.get(getContext());
        mPackageManager = AppGlobals.getPackageManager();
        mHandlerThread = new HandlerThread(LOG_TAG,
                Process.THREAD_PRIORITY_BACKGROUND);
        mHandlerThread.start();
        mHandler = new Handler(mHandlerThread.getLooper());
        mSettingsRegistry = new SettingsRegistry();
    }
    mHandler.post(() -> {
        registerBroadcastReceivers();
        startWatchingUserRestrictionChanges();
    });
    ServiceManager.addService("settings", new SettingsService(this));
    return true;
}
 

private void enforceValidJobRequest(int uid, JobInfo job) {
    final IPackageManager pm = AppGlobals.getPackageManager();
    final ComponentName service = job.getService();
    try {
        ServiceInfo si = pm.getServiceInfo(service,
                PackageManager.MATCH_DIRECT_BOOT_AWARE
                        | PackageManager.MATCH_DIRECT_BOOT_UNAWARE,
                UserHandle.getUserId(uid));
        if (si == null) {
            throw new IllegalArgumentException("No such service " + service);
        }
        if (si.applicationInfo.uid != uid) {
            throw new IllegalArgumentException("uid " + uid +
                    " cannot schedule job in " + service.getPackageName());
        }
        if (!JobService.PERMISSION_BIND.equals(si.permission)) {
            throw new IllegalArgumentException("Scheduled service " + service
                    + " does not require android.permission.BIND_JOB_SERVICE permission");
        }
    } catch (RemoteException e) {
        // Can't happen; the Package Manager is in this same process
    }
}
 

/**
 * Return true if all given permissions are signature-only perms.
 */
final boolean isSignaturePerm(String[] perms) {
    if (perms == null) {
        return false;
    }
    IPackageManager pm = AppGlobals.getPackageManager();
    for (int i = perms.length-1; i >= 0; i--) {
        try {
            PermissionInfo pi = pm.getPermissionInfo(perms[i], "android", 0);
            if ((pi.protectionLevel & (PermissionInfo.PROTECTION_MASK_BASE
                    | PermissionInfo.PROTECTION_FLAG_PRIVILEGED))
                    != PermissionInfo.PROTECTION_SIGNATURE) {
                // If this a signature permission and NOT allowed for privileged apps, it
                // is okay...  otherwise, nope!
                return false;
            }
        } catch (RemoteException e) {
            return false;
        }
    }
    return true;
}
 

static boolean isPrivilegedApp(int callerUid, int callerPid) {
    if (callerUid == Process.SYSTEM_UID || callerUid == 0 ||
            callerPid == Process.myPid() || callerPid == 0) {
        return true;
    }

    IPackageManager pm = AppGlobals.getPackageManager();
    try {
        return (pm.getPrivateFlagsForUid(callerUid) & ApplicationInfo.PRIVATE_FLAG_PRIVILEGED)
                != 0;
    } catch (RemoteException ex) {
        Slog.e(IntentFirewall.TAG, "Remote exception while retrieving uid flags",
                ex);
    }

    return false;
}
 

@Override
public boolean matches(IntentFirewall ifw, ComponentName resolvedComponent, Intent intent,
        int callerUid, int callerPid, String resolvedType, int receivingUid) {
    IPackageManager pm = AppGlobals.getPackageManager();

    int packageUid = -1;
    try {
        // USER_SYSTEM here is not important. Only app id is used and getPackageUid() will
        // return a uid whether the app is installed for a user or not.
        packageUid = pm.getPackageUid(mPackageName, PackageManager.MATCH_ANY_USER,
                UserHandle.USER_SYSTEM);
    } catch (RemoteException ex) {
        // handled below
    }

    if (packageUid == -1)  {
        return false;
    }

    return UserHandle.isSameApp(packageUid, callerUid);
}
 

private static void logIntent(int intentType, Intent intent, int callerUid,
        String resolvedType) {
    // The component shouldn't be null, but let's double check just to be safe
    ComponentName cn = intent.getComponent();
    String shortComponent = null;
    if (cn != null) {
        shortComponent = cn.flattenToShortString();
    }

    String callerPackages = null;
    int callerPackageCount = 0;
    IPackageManager pm = AppGlobals.getPackageManager();
    if (pm != null) {
        try {
            String[] callerPackagesArray = pm.getPackagesForUid(callerUid);
            if (callerPackagesArray != null) {
                callerPackageCount = callerPackagesArray.length;
                callerPackages = joinPackages(callerPackagesArray);
            }
        } catch (RemoteException ex) {
            Slog.e(TAG, "Remote exception while retrieving packages", ex);
        }
    }

    EventLogTags.writeIfwIntentMatched(intentType, shortComponent, callerUid,
            callerPackageCount, callerPackages, intent.getAction(), resolvedType,
            intent.getDataString(), intent.getFlags());
}
 

boolean isFirstBootOrUpgrade() {
    IPackageManager pm = AppGlobals.getPackageManager();
    try {
        return pm.isFirstBoot() || pm.isUpgrade();
    } catch (RemoteException e) {
        throw e.rethrowFromSystemServer();
    }
}
 

private final void addActiveOwnerLocked(int uid, String pkg) {
    final IPackageManager pm = AppGlobals.getPackageManager();
    final int targetUserHandle = UserHandle.getCallingUserId();
    final long oldIdentity = Binder.clearCallingIdentity();
    try {
        PackageInfo pi = pm.getPackageInfo(pkg, 0, targetUserHandle);
        if (pi == null) {
            throw new IllegalArgumentException("Unknown package " + pkg);
        }
        if (!UserHandle.isSameApp(pi.applicationInfo.uid, uid)) {
            throw new SecurityException("Calling uid " + uid
                    + " does not own package " + pkg);
        }
    } catch (RemoteException e) {
        // Can't happen; the package manager is in the same process
    } finally {
        Binder.restoreCallingIdentity(oldIdentity);
    }
    PerUserClipboard clipboard = getClipboard();
    if (clipboard.primaryClip != null && !clipboard.activePermissionOwners.contains(pkg)) {
        final int N = clipboard.primaryClip.getItemCount();
        for (int i=0; i<N; i++) {
            grantItemLocked(clipboard.primaryClip.getItemAt(i), clipboard.primaryClipUid, pkg,
                    UserHandle.getUserId(uid));
        }
        clipboard.activePermissionOwners.add(pkg);
    }
}
 

boolean signaturesMatch(int uid1, int uid2) {
    try {
        IPackageManager pm = AppGlobals.getPackageManager();
        return pm.checkUidSignatures(uid1, uid2) == PackageManager.SIGNATURE_MATCH;
    } catch (RemoteException ex) {
        Slog.e(TAG, "Remote exception while checking signatures", ex);
        return false;
    }
}
 

public MediaSessionService(Context context) {
    super(context);
    mSessionManagerImpl = new SessionManagerImpl();
    PowerManager pm = (PowerManager) context.getSystemService(Context.POWER_SERVICE);
    mMediaEventWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, "handleMediaEvent");
    mLongPressTimeout = ViewConfiguration.getLongPressTimeout();
    mNotificationManager = INotificationManager.Stub.asInterface(
            ServiceManager.getService(Context.NOTIFICATION_SERVICE));
    mPackageManager = AppGlobals.getPackageManager();
}
 

public WallpaperManagerService(Context context) {
    if (DEBUG) Slog.v(TAG, "WallpaperService startup");
    mContext = context;
    mShuttingDown = false;
    mImageWallpaper = ComponentName.unflattenFromString(
            context.getResources().getString(R.string.image_wallpaper_component));
    mDefaultWallpaperComponent = WallpaperManager.getDefaultWallpaperComponent(context);
    mIWindowManager = IWindowManager.Stub.asInterface(
            ServiceManager.getService(Context.WINDOW_SERVICE));
    mIPackageManager = AppGlobals.getPackageManager();
    mAppOpsManager = (AppOpsManager) mContext.getSystemService(Context.APP_OPS_SERVICE);
    mMonitor = new MyPackageMonitor();
    mColorsChangedListeners = new SparseArray<>();
}
 

int executeCancelCommand(PrintWriter pw, String pkgName, int userId,
        boolean hasJobId, int jobId) {
    if (DEBUG) {
        Slog.v(TAG, "executeCancelCommand(): " + pkgName + "/" + userId + " " + jobId);
    }

    int pkgUid = -1;
    try {
        IPackageManager pm = AppGlobals.getPackageManager();
        pkgUid = pm.getPackageUid(pkgName, 0, userId);
    } catch (RemoteException e) { /* can't happen */ }

    if (pkgUid < 0) {
        pw.println("Package " + pkgName + " not found.");
        return JobSchedulerShellCommand.CMD_ERR_NO_PACKAGE;
    }

    if (!hasJobId) {
        pw.println("Canceling all jobs for " + pkgName + " in user " + userId);
        if (!cancelJobsForUid(pkgUid, "cancel shell command for package")) {
            pw.println("No matching jobs found.");
        }
    } else {
        pw.println("Canceling job " + pkgName + "/#" + jobId + " in user " + userId);
        if (!cancelJob(pkgUid, jobId, Process.SHELL_UID)) {
            pw.println("No matching job found.");
        }
    }

    return 0;
}
 

/**
 * Disables BluetoothOppLauncherActivity component, so the Bluetooth sharing option is not
 * offered to the user if Bluetooth or sharing is disallowed. Puts the component to its default
 * state if Bluetooth is not disallowed.
 *
 * @param userId user to disable bluetooth sharing for.
 * @param bluetoothSharingDisallowed whether bluetooth sharing is disallowed.
 */
private void updateOppLauncherComponentState(int userId, boolean bluetoothSharingDisallowed) {
    final ComponentName oppLauncherComponent = new ComponentName("com.android.bluetooth",
            "com.android.bluetooth.opp.BluetoothOppLauncherActivity");
    final int newState =
            bluetoothSharingDisallowed ? PackageManager.COMPONENT_ENABLED_STATE_DISABLED
                    : PackageManager.COMPONENT_ENABLED_STATE_DEFAULT;
    try {
        final IPackageManager imp = AppGlobals.getPackageManager();
        imp.setComponentEnabledSetting(oppLauncherComponent, newState,
                PackageManager.DONT_KILL_APP, userId);
    } catch (Exception e) {
        // The component was not found, do nothing.
    }
}
 

@VisibleForTesting
ShortcutService(Context context, Looper looper, boolean onlyForPackageManagerApis) {
    mContext = Preconditions.checkNotNull(context);
    LocalServices.addService(ShortcutServiceInternal.class, new LocalService());
    mHandler = new Handler(looper);
    mIPackageManager = AppGlobals.getPackageManager();
    mPackageManagerInternal = Preconditions.checkNotNull(
            LocalServices.getService(PackageManagerInternal.class));
    mUserManagerInternal = Preconditions.checkNotNull(
            LocalServices.getService(UserManagerInternal.class));
    mUsageStatsManagerInternal = Preconditions.checkNotNull(
            LocalServices.getService(UsageStatsManagerInternal.class));
    mActivityManagerInternal = Preconditions.checkNotNull(
            LocalServices.getService(ActivityManagerInternal.class));

    mShortcutRequestPinProcessor = new ShortcutRequestPinProcessor(this, mLock);
    mShortcutBitmapSaver = new ShortcutBitmapSaver(this);
    mShortcutDumpFiles = new ShortcutDumpFiles(this);

    if (onlyForPackageManagerApis) {
        return; // Don't do anything further.  For unit tests only.
    }

    // Register receivers.

    // We need to set a priority, so let's just not use PackageMonitor for now.
    // TODO Refactor PackageMonitor to support priorities.
    final IntentFilter packageFilter = new IntentFilter();
    packageFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
    packageFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
    packageFilter.addAction(Intent.ACTION_PACKAGE_CHANGED);
    packageFilter.addAction(Intent.ACTION_PACKAGE_DATA_CLEARED);
    packageFilter.addDataScheme("package");
    packageFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
    mContext.registerReceiverAsUser(mPackageMonitor, UserHandle.ALL,
            packageFilter, null, mHandler);

    final IntentFilter preferedActivityFilter = new IntentFilter();
    preferedActivityFilter.addAction(Intent.ACTION_PREFERRED_ACTIVITY_CHANGED);
    preferedActivityFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
    mContext.registerReceiverAsUser(mPackageMonitor, UserHandle.ALL,
            preferedActivityFilter, null, mHandler);

    final IntentFilter localeFilter = new IntentFilter();
    localeFilter.addAction(Intent.ACTION_LOCALE_CHANGED);
    localeFilter.setPriority(IntentFilter.SYSTEM_HIGH_PRIORITY);
    mContext.registerReceiverAsUser(mReceiver, UserHandle.ALL,
            localeFilter, null, mHandler);

    injectRegisterUidObserver(mUidObserver, ActivityManager.UID_OBSERVER_PROCSTATE
            | ActivityManager.UID_OBSERVER_GONE);
}
 

/**
 *
 * @param context Context to use for looking up activities etc.
 */
public Searchables (Context context, int userId) {
    mContext = context;
    mUserId = userId;
    mPm = AppGlobals.getPackageManager();
}
 

JobSchedulerShellCommand(JobSchedulerService service) {
    mInternal = service;
    mPM = AppGlobals.getPackageManager();
}
 

void saveCompatModes() {
    HashMap<String, Integer> pkgs;
    synchronized (mService) {
        pkgs = new HashMap<String, Integer>(mPackages);
    }

    FileOutputStream fos = null;

    try {
        fos = mFile.startWrite();
        XmlSerializer out = new FastXmlSerializer();
        out.setOutput(fos, StandardCharsets.UTF_8.name());
        out.startDocument(null, true);
        out.setFeature("http://xmlpull.org/v1/doc/features.html#indent-output", true);
        out.startTag(null, "compat-packages");

        final IPackageManager pm = AppGlobals.getPackageManager();
        final Configuration globalConfig = mService.getGlobalConfiguration();
        final int screenLayout = globalConfig.screenLayout;
        final int smallestScreenWidthDp = globalConfig.smallestScreenWidthDp;
        final Iterator<Map.Entry<String, Integer>> it = pkgs.entrySet().iterator();
        while (it.hasNext()) {
            Map.Entry<String, Integer> entry = it.next();
            String pkg = entry.getKey();
            int mode = entry.getValue();
            if (mode == 0) {
                continue;
            }
            ApplicationInfo ai = null;
            try {
                ai = pm.getApplicationInfo(pkg, 0, 0);
            } catch (RemoteException e) {
            }
            if (ai == null) {
                continue;
            }
            CompatibilityInfo info = new CompatibilityInfo(ai, screenLayout,
                    smallestScreenWidthDp, false);
            if (info.alwaysSupportsScreen()) {
                continue;
            }
            if (info.neverSupportsScreen()) {
                continue;
            }
            out.startTag(null, "pkg");
            out.attribute(null, "name", pkg);
            out.attribute(null, "mode", Integer.toString(mode));
            out.endTag(null, "pkg");
        }

        out.endTag(null, "compat-packages");
        out.endDocument();

        mFile.finishWrite(fos);
    } catch (java.io.IOException e1) {
        Slog.w(TAG, "Error writing compat packages", e1);
        if (fos != null) {
            mFile.failWrite(fos);
        }
    }
}
 

ActivityManagerShellCommand(ActivityManagerService service, boolean dumping) {
    mInterface = service;
    mInternal = service;
    mPm = AppGlobals.getPackageManager();
    mDumping = dumping;
}
 

public AppsQueryHelper() {
    this(AppGlobals.getPackageManager());
}