Examples with ResolveInfo android.content.pm.ResolveInfo used on opensource projects

Example 31 with ResolveInfo

use of android.content.pm.ResolveInfo in project android_frameworks_base by ParanoidAndroid.

the class NotificationManagerService method disableNonexistentListeners.

/**
     * Remove notification access for any services that no longer exist.
     */
void disableNonexistentListeners() {
    int currentUser = ActivityManager.getCurrentUser();
    String flatIn = Settings.Secure.getStringForUser(mContext.getContentResolver(), Settings.Secure.ENABLED_NOTIFICATION_LISTENERS, currentUser);
    if (!TextUtils.isEmpty(flatIn)) {
        if (DBG)
            Slog.v(TAG, "flat before: " + flatIn);
        PackageManager pm = mContext.getPackageManager();
        List<ResolveInfo> installedServices = pm.queryIntentServicesAsUser(new Intent(NotificationListenerService.SERVICE_INTERFACE), PackageManager.GET_SERVICES | PackageManager.GET_META_DATA, currentUser);
        Set<ComponentName> installed = new HashSet<ComponentName>();
        for (int i = 0, count = installedServices.size(); i < count; i++) {
            ResolveInfo resolveInfo = installedServices.get(i);
            ServiceInfo info = resolveInfo.serviceInfo;
            if (!android.Manifest.permission.BIND_NOTIFICATION_LISTENER_SERVICE.equals(info.permission)) {
                Slog.w(TAG, "Skipping notification listener service " + info.packageName + "/" + info.name + ": it does not require the permission " + android.Manifest.permission.BIND_NOTIFICATION_LISTENER_SERVICE);
                continue;
            }
            installed.add(new ComponentName(info.packageName, info.name));
        }
        String flatOut = "";
        if (!installed.isEmpty()) {
            String[] enabled = flatIn.split(ENABLED_NOTIFICATION_LISTENERS_SEPARATOR);
            ArrayList<String> remaining = new ArrayList<String>(enabled.length);
            for (int i = 0; i < enabled.length; i++) {
                ComponentName enabledComponent = ComponentName.unflattenFromString(enabled[i]);
                if (installed.contains(enabledComponent)) {
                    remaining.add(enabled[i]);
                }
            }
            flatOut = TextUtils.join(ENABLED_NOTIFICATION_LISTENERS_SEPARATOR, remaining);
        }
        if (DBG)
            Slog.v(TAG, "flat after: " + flatOut);
        if (!flatIn.equals(flatOut)) {
            Settings.Secure.putStringForUser(mContext.getContentResolver(), Settings.Secure.ENABLED_NOTIFICATION_LISTENERS, flatOut, currentUser);
        }
    }
}

Example 32 with ResolveInfo

use of android.content.pm.ResolveInfo in project android_frameworks_base by ParanoidAndroid.

the class ActiveServices method retrieveServiceLocked.

private ServiceLookupResult retrieveServiceLocked(Intent service, String resolvedType, int callingPid, int callingUid, int userId, boolean createIfNeeded) {
    ServiceRecord r = null;
    if (DEBUG_SERVICE)
        Slog.v(TAG, "retrieveServiceLocked: " + service + " type=" + resolvedType + " callingUid=" + callingUid);
    userId = mAm.handleIncomingUser(callingPid, callingUid, userId, false, true, "service", null);
    if (service.getComponent() != null) {
        r = mServiceMap.getServiceByName(service.getComponent(), userId);
    }
    if (r == null) {
        Intent.FilterComparison filter = new Intent.FilterComparison(service);
        r = mServiceMap.getServiceByIntent(filter, userId);
    }
    if (r == null) {
        try {
            ResolveInfo rInfo = AppGlobals.getPackageManager().resolveService(service, resolvedType, ActivityManagerService.STOCK_PM_FLAGS, userId);
            ServiceInfo sInfo = rInfo != null ? rInfo.serviceInfo : null;
            if (sInfo == null) {
                Slog.w(TAG, "Unable to start service " + service + " U=" + userId + ": not found");
                return null;
            }
            ComponentName name = new ComponentName(sInfo.applicationInfo.packageName, sInfo.name);
            if (userId > 0) {
                if (mAm.isSingleton(sInfo.processName, sInfo.applicationInfo, sInfo.name, sInfo.flags)) {
                    userId = 0;
                }
                sInfo = new ServiceInfo(sInfo);
                sInfo.applicationInfo = mAm.getAppInfoForUser(sInfo.applicationInfo, userId);
            }
            r = mServiceMap.getServiceByName(name, userId);
            if (r == null && createIfNeeded) {
                Intent.FilterComparison filter = new Intent.FilterComparison(service.cloneFilter());
                ServiceRestarter res = new ServiceRestarter();
                BatteryStatsImpl.Uid.Pkg.Serv ss = null;
                BatteryStatsImpl stats = mAm.mBatteryStatsService.getActiveStatistics();
                synchronized (stats) {
                    ss = stats.getServiceStatsLocked(sInfo.applicationInfo.uid, sInfo.packageName, sInfo.name);
                }
                r = new ServiceRecord(mAm, ss, name, filter, sInfo, res);
                res.setService(r);
                mServiceMap.putServiceByName(name, UserHandle.getUserId(r.appInfo.uid), r);
                mServiceMap.putServiceByIntent(filter, UserHandle.getUserId(r.appInfo.uid), r);
                // Make sure this component isn't in the pending list.
                int N = mPendingServices.size();
                for (int i = 0; i < N; i++) {
                    ServiceRecord pr = mPendingServices.get(i);
                    if (pr.serviceInfo.applicationInfo.uid == sInfo.applicationInfo.uid && pr.name.equals(name)) {
                        mPendingServices.remove(i);
                        i--;
                        N--;
                    }
                }
            }
        } catch (RemoteException ex) {
        // pm is in same process, this will never happen.
        }
    }
    if (r != null) {
        if (mAm.checkComponentPermission(r.permission, callingPid, callingUid, r.appInfo.uid, r.exported) != PackageManager.PERMISSION_GRANTED) {
            if (!r.exported) {
                Slog.w(TAG, "Permission Denial: Accessing service " + r.name + " from pid=" + callingPid + ", uid=" + callingUid + " that is not exported from uid " + r.appInfo.uid);
                return new ServiceLookupResult(null, "not exported from uid " + r.appInfo.uid);
            }
            Slog.w(TAG, "Permission Denial: Accessing service " + r.name + " from pid=" + callingPid + ", uid=" + callingUid + " requires " + r.permission);
            return new ServiceLookupResult(null, r.permission);
        }
        return new ServiceLookupResult(r, null);
    }
    return null;
}

Example 33 with ResolveInfo

use of android.content.pm.ResolveInfo in project android_frameworks_base by ParanoidAndroid.

the class AccessibilityManagerService method updateLegacyCapabilities.

private void updateLegacyCapabilities(UserState userState) {
    // Up to JB-MR1 we had a white list with services that can enable touch
    // exploration. When a service is first started we show a dialog to the
    // use to get a permission to white list the service.
    final int installedServiceCount = userState.mInstalledServices.size();
    for (int i = 0; i < installedServiceCount; i++) {
        AccessibilityServiceInfo serviceInfo = userState.mInstalledServices.get(i);
        ResolveInfo resolveInfo = serviceInfo.getResolveInfo();
        if ((serviceInfo.getCapabilities() & AccessibilityServiceInfo.CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION) == 0 && resolveInfo.serviceInfo.applicationInfo.targetSdkVersion <= Build.VERSION_CODES.JELLY_BEAN_MR1) {
            ComponentName componentName = new ComponentName(resolveInfo.serviceInfo.packageName, resolveInfo.serviceInfo.name);
            if (userState.mTouchExplorationGrantedServices.contains(componentName)) {
                serviceInfo.setCapabilities(serviceInfo.getCapabilities() | AccessibilityServiceInfo.CAPABILITY_CAN_REQUEST_TOUCH_EXPLORATION);
            }
        }
    }
}

Example 34 with ResolveInfo

use of android.content.pm.ResolveInfo in project android_frameworks_base by ParanoidAndroid.

the class ActivityManagerService method systemReady.

public void systemReady(final Runnable goingCallback) {
    synchronized (this) {
        if (mSystemReady) {
            if (goingCallback != null)
                goingCallback.run();
            return;
        }
        // Check to see if there are any update receivers to run.
        if (!mDidUpdate) {
            if (mWaitingUpdate) {
                return;
            }
            Intent intent = new Intent(Intent.ACTION_PRE_BOOT_COMPLETED);
            List<ResolveInfo> ris = null;
            try {
                ris = AppGlobals.getPackageManager().queryIntentReceivers(intent, null, 0, 0);
            } catch (RemoteException e) {
            }
            if (ris != null) {
                for (int i = ris.size() - 1; i >= 0; i--) {
                    if ((ris.get(i).activityInfo.applicationInfo.flags & ApplicationInfo.FLAG_SYSTEM) == 0) {
                        ris.remove(i);
                    }
                }
                intent.addFlags(Intent.FLAG_RECEIVER_BOOT_UPGRADE);
                ArrayList<ComponentName> lastDoneReceivers = readLastDonePreBootReceivers();
                final ArrayList<ComponentName> doneReceivers = new ArrayList<ComponentName>();
                for (int i = 0; i < ris.size(); i++) {
                    ActivityInfo ai = ris.get(i).activityInfo;
                    ComponentName comp = new ComponentName(ai.packageName, ai.name);
                    if (lastDoneReceivers.contains(comp)) {
                        ris.remove(i);
                        i--;
                    }
                }
                final int[] users = getUsersLocked();
                for (int i = 0; i < ris.size(); i++) {
                    ActivityInfo ai = ris.get(i).activityInfo;
                    ComponentName comp = new ComponentName(ai.packageName, ai.name);
                    doneReceivers.add(comp);
                    intent.setComponent(comp);
                    for (int j = 0; j < users.length; j++) {
                        IIntentReceiver finisher = null;
                        if (i == ris.size() - 1 && j == users.length - 1) {
                            finisher = new IIntentReceiver.Stub() {

                                public void performReceive(Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) {
                                    // The raw IIntentReceiver interface is called
                                    // with the AM lock held, so redispatch to
                                    // execute our code without the lock.
                                    mHandler.post(new Runnable() {

                                        public void run() {
                                            synchronized (ActivityManagerService.this) {
                                                mDidUpdate = true;
                                            }
                                            writeLastDonePreBootReceivers(doneReceivers);
                                            showBootMessage(mContext.getText(R.string.android_upgrading_complete), false);
                                            systemReady(goingCallback);
                                        }
                                    });
                                }
                            };
                        }
                        Slog.i(TAG, "Sending system update to " + intent.getComponent() + " for user " + users[j]);
                        broadcastIntentLocked(null, null, intent, null, finisher, 0, null, null, null, AppOpsManager.OP_NONE, true, false, MY_PID, Process.SYSTEM_UID, users[j]);
                        if (finisher != null) {
                            mWaitingUpdate = true;
                        }
                    }
                }
            }
            if (mWaitingUpdate) {
                return;
            }
            mDidUpdate = true;
        }
        mAppOpsService.systemReady();
        mSystemReady = true;
        if (!mStartRunning) {
            return;
        }
    }
    ArrayList<ProcessRecord> procsToKill = null;
    synchronized (mPidsSelfLocked) {
        for (int i = mPidsSelfLocked.size() - 1; i >= 0; i--) {
            ProcessRecord proc = mPidsSelfLocked.valueAt(i);
            if (!isAllowedWhileBooting(proc.info)) {
                if (procsToKill == null) {
                    procsToKill = new ArrayList<ProcessRecord>();
                }
                procsToKill.add(proc);
            }
        }
    }
    synchronized (this) {
        if (procsToKill != null) {
            for (int i = procsToKill.size() - 1; i >= 0; i--) {
                ProcessRecord proc = procsToKill.get(i);
                Slog.i(TAG, "Removing system update proc: " + proc);
                removeProcessLocked(proc, true, false, "system update done");
            }
        }
        // Now that we have cleaned up any update processes, we
        // are ready to start launching real processes and know that
        // we won't trample on them any more.
        mProcessesReady = true;
    }
    Slog.i(TAG, "System now ready");
    EventLog.writeEvent(EventLogTags.BOOT_PROGRESS_AMS_READY, SystemClock.uptimeMillis());
    synchronized (this) {
        if (mFactoryTest == SystemServer.FACTORY_TEST_LOW_LEVEL) {
            ResolveInfo ri = mContext.getPackageManager().resolveActivity(new Intent(Intent.ACTION_FACTORY_TEST), STOCK_PM_FLAGS);
            CharSequence errorMsg = null;
            if (ri != null) {
                ActivityInfo ai = ri.activityInfo;
                ApplicationInfo app = ai.applicationInfo;
                if ((app.flags & ApplicationInfo.FLAG_SYSTEM) != 0) {
                    mTopAction = Intent.ACTION_FACTORY_TEST;
                    mTopData = null;
                    mTopComponent = new ComponentName(app.packageName, ai.name);
                } else {
                    errorMsg = mContext.getResources().getText(com.android.internal.R.string.factorytest_not_system);
                }
            } else {
                errorMsg = mContext.getResources().getText(com.android.internal.R.string.factorytest_no_action);
            }
            if (errorMsg != null) {
                mTopAction = null;
                mTopData = null;
                mTopComponent = null;
                Message msg = Message.obtain();
                msg.what = SHOW_FACTORY_ERROR_MSG;
                msg.getData().putCharSequence("msg", errorMsg);
                mHandler.sendMessage(msg);
            }
        }
    }
    retrieveSettings();
    if (goingCallback != null)
        goingCallback.run();
    synchronized (this) {
        if (mFactoryTest != SystemServer.FACTORY_TEST_LOW_LEVEL) {
            try {
                List apps = AppGlobals.getPackageManager().getPersistentApplications(STOCK_PM_FLAGS);
                if (apps != null) {
                    int N = apps.size();
                    int i;
                    for (i = 0; i < N; i++) {
                        ApplicationInfo info = (ApplicationInfo) apps.get(i);
                        if (info != null && !info.packageName.equals("android")) {
                            addAppLocked(info, false);
                        }
                    }
                }
            } catch (RemoteException ex) {
            // pm is in same process, this will never happen.
            }
        }
        // Start up initial activity.
        mBooting = true;
        try {
            if (AppGlobals.getPackageManager().hasSystemUidErrors()) {
                Message msg = Message.obtain();
                msg.what = SHOW_UID_ERROR_MSG;
                mHandler.sendMessage(msg);
            }
        } catch (RemoteException e) {
        }
        long ident = Binder.clearCallingIdentity();
        try {
            Intent intent = new Intent(Intent.ACTION_USER_STARTED);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY | Intent.FLAG_RECEIVER_FOREGROUND);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, mCurrentUserId);
            broadcastIntentLocked(null, null, intent, null, null, 0, null, null, null, AppOpsManager.OP_NONE, false, false, MY_PID, Process.SYSTEM_UID, mCurrentUserId);
            intent = new Intent(Intent.ACTION_USER_STARTING);
            intent.addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY);
            intent.putExtra(Intent.EXTRA_USER_HANDLE, mCurrentUserId);
            broadcastIntentLocked(null, null, intent, null, new IIntentReceiver.Stub() {

                @Override
                public void performReceive(Intent intent, int resultCode, String data, Bundle extras, boolean ordered, boolean sticky, int sendingUser) throws RemoteException {
                }
            }, 0, null, null, android.Manifest.permission.INTERACT_ACROSS_USERS, AppOpsManager.OP_NONE, true, false, MY_PID, Process.SYSTEM_UID, UserHandle.USER_ALL);
        } finally {
            Binder.restoreCallingIdentity(ident);
        }
        mMainStack.resumeTopActivityLocked(null);
        sendUserSwitchBroadcastsLocked(-1, mCurrentUserId);
    }
}

Example 35 with ResolveInfo

use of android.content.pm.ResolveInfo in project android_frameworks_base by ParanoidAndroid.

the class ActivityManagerService method startNextMatchingActivity.

public boolean startNextMatchingActivity(IBinder callingActivity, Intent intent, Bundle options) {
    // Refuse possible leaked file descriptors
    if (intent != null && intent.hasFileDescriptors() == true) {
        throw new IllegalArgumentException("File descriptors passed in Intent");
    }
    synchronized (this) {
        ActivityRecord r = mMainStack.isInStackLocked(callingActivity);
        if (r == null) {
            ActivityOptions.abort(options);
            return false;
        }
        if (r.app == null || r.app.thread == null) {
            // The caller is not running...  d'oh!
            ActivityOptions.abort(options);
            return false;
        }
        intent = new Intent(intent);
        // The caller is not allowed to change the data.
        intent.setDataAndType(r.intent.getData(), r.intent.getType());
        // And we are resetting to find the next component...
        intent.setComponent(null);
        ActivityInfo aInfo = null;
        try {
            List<ResolveInfo> resolves = AppGlobals.getPackageManager().queryIntentActivities(intent, r.resolvedType, PackageManager.MATCH_DEFAULT_ONLY | STOCK_PM_FLAGS, UserHandle.getCallingUserId());
            // Look for the original activity in the list...
            final int N = resolves != null ? resolves.size() : 0;
            for (int i = 0; i < N; i++) {
                ResolveInfo rInfo = resolves.get(i);
                if (rInfo.activityInfo.packageName.equals(r.packageName) && rInfo.activityInfo.name.equals(r.info.name)) {
                    // We found the current one...  the next matching is
                    // after it.
                    i++;
                    if (i < N) {
                        aInfo = resolves.get(i).activityInfo;
                    }
                    break;
                }
            }
        } catch (RemoteException e) {
        }
        if (aInfo == null) {
            // Nobody who is next!
            ActivityOptions.abort(options);
            return false;
        }
        intent.setComponent(new ComponentName(aInfo.applicationInfo.packageName, aInfo.name));
        intent.setFlags(intent.getFlags() & ~(Intent.FLAG_ACTIVITY_FORWARD_RESULT | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_MULTIPLE_TASK | Intent.FLAG_ACTIVITY_NEW_TASK));
        // Okay now we need to start the new activity, replacing the
        // currently running activity.  This is a little tricky because
        // we want to start the new one as if the current one is finished,
        // but not finish the current one first so that there is no flicker.
        // And thus...
        final boolean wasFinishing = r.finishing;
        r.finishing = true;
        // Propagate reply information over to the new activity.
        final ActivityRecord resultTo = r.resultTo;
        final String resultWho = r.resultWho;
        final int requestCode = r.requestCode;
        r.resultTo = null;
        if (resultTo != null) {
            resultTo.removeResultsLocked(r, resultWho, requestCode);
        }
        final long origId = Binder.clearCallingIdentity();
        int res = mMainStack.startActivityLocked(r.app.thread, intent, r.resolvedType, aInfo, resultTo != null ? resultTo.appToken : null, resultWho, requestCode, -1, r.launchedFromUid, r.launchedFromPackage, 0, options, false, null);
        Binder.restoreCallingIdentity(origId);
        r.finishing = wasFinishing;
        if (res != ActivityManager.START_SUCCESS) {
            return false;
        }
        return true;
    }
}