Examples with ServiceState com.android.internal.app.procstats.ServiceState used on opensource projects

Example 16 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by ResurrectionRemix.

the class ProcessStats method getServiceStateLocked.

public ServiceState getServiceStateLocked(String packageName, int uid, int vers, String processName, String className) {
    final ProcessStats.PackageState as = getPackageStateLocked(packageName, uid, vers);
    ServiceState ss = as.mServices.get(className);
    if (ss != null) {
        if (DEBUG)
            Slog.d(TAG, "GETSVC: returning existing " + ss);
        return ss;
    }
    final ProcessState ps = processName != null ? getProcessStateLocked(packageName, uid, vers, processName) : null;
    ss = new ServiceState(this, packageName, className, processName, ps);
    as.mServices.put(className, ss);
    if (DEBUG)
        Slog.d(TAG, "GETSVC: creating " + ss + " in " + ps);
    return ss;
}

Example 17 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ProcessStats method getProcessStateLocked.

public ProcessState getProcessStateLocked(String packageName, int uid, int vers, String processName) {
    final PackageState pkgState = getPackageStateLocked(packageName, uid, vers);
    ProcessState ps = pkgState.mProcesses.get(processName);
    if (ps != null) {
        return ps;
    }
    ProcessState commonProc = mProcesses.get(processName, uid);
    if (commonProc == null) {
        commonProc = new ProcessState(this, packageName, uid, vers, processName);
        mProcesses.put(processName, uid, commonProc);
        if (DEBUG)
            Slog.d(TAG, "GETPROC created new common " + commonProc);
    }
    if (!commonProc.isMultiPackage()) {
        if (packageName.equals(commonProc.getPackage()) && vers == commonProc.getVersion()) {
            // This common process is not in use by multiple packages, and
            // is for the calling package, so we can just use it directly.
            ps = commonProc;
            if (DEBUG)
                Slog.d(TAG, "GETPROC also using for pkg " + commonProc);
        } else {
            if (DEBUG)
                Slog.d(TAG, "GETPROC need to split common proc!");
            // This common process has not been in use by multiple packages,
            // but it was created for a different package than the caller.
            // We need to convert it to a multi-package process.
            commonProc.setMultiPackage(true);
            // To do this, we need to make two new process states, one a copy
            // of the current state for the process under the original package
            // name, and the second a free new process state for it as the
            // new package name.
            long now = SystemClock.uptimeMillis();
            // First let's make a copy of the current process state and put
            // that under the now unique state for its original package name.
            final PackageState commonPkgState = getPackageStateLocked(commonProc.getPackage(), uid, commonProc.getVersion());
            if (commonPkgState != null) {
                ProcessState cloned = commonProc.clone(now);
                if (DEBUG)
                    Slog.d(TAG, "GETPROC setting clone to pkg " + commonProc.getPackage() + ": " + cloned);
                commonPkgState.mProcesses.put(commonProc.getName(), cloned);
                // to point to the new package-specific process state.
                for (int i = commonPkgState.mServices.size() - 1; i >= 0; i--) {
                    ServiceState ss = commonPkgState.mServices.valueAt(i);
                    if (ss.getProcess() == commonProc) {
                        if (DEBUG)
                            Slog.d(TAG, "GETPROC switching service to cloned: " + ss);
                        ss.setProcess(cloned);
                    } else if (DEBUG) {
                        Slog.d(TAG, "GETPROC leaving proc of " + ss);
                    }
                }
            } else {
                Slog.w(TAG, "Cloning proc state: no package state " + commonProc.getPackage() + "/" + uid + " for proc " + commonProc.getName());
            }
            // And now make a fresh new process state for the new package name.
            ps = new ProcessState(commonProc, packageName, uid, vers, processName, now);
            if (DEBUG)
                Slog.d(TAG, "GETPROC created new pkg " + ps);
        }
    } else {
        // The common process is for multiple packages, we need to create a
        // separate object for the per-package data.
        ps = new ProcessState(commonProc, packageName, uid, vers, processName, SystemClock.uptimeMillis());
        if (DEBUG)
            Slog.d(TAG, "GETPROC created new pkg " + ps);
    }
    pkgState.mProcesses.put(processName, ps);
    if (DEBUG)
        Slog.d(TAG, "GETPROC adding new pkg " + ps);
    return ps;
}

Example 18 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ProcessStats method dumpCheckinLocked.

public void dumpCheckinLocked(PrintWriter pw, String reqPackage) {
    final long now = SystemClock.uptimeMillis();
    final ArrayMap<String, SparseArray<SparseArray<PackageState>>> pkgMap = mPackages.getMap();
    pw.println("vers,5");
    pw.print("period,");
    pw.print(mTimePeriodStartClockStr);
    pw.print(",");
    pw.print(mTimePeriodStartRealtime);
    pw.print(",");
    pw.print(mRunning ? SystemClock.elapsedRealtime() : mTimePeriodEndRealtime);
    boolean partial = true;
    if ((mFlags & FLAG_SHUTDOWN) != 0) {
        pw.print(",shutdown");
        partial = false;
    }
    if ((mFlags & FLAG_SYSPROPS) != 0) {
        pw.print(",sysprops");
        partial = false;
    }
    if ((mFlags & FLAG_COMPLETE) != 0) {
        pw.print(",complete");
        partial = false;
    }
    if (partial) {
        pw.print(",partial");
    }
    if (mHasSwappedOutPss) {
        pw.print(",swapped-out-pss");
    }
    pw.println();
    pw.print("config,");
    pw.println(mRuntime);
    for (int ip = 0; ip < pkgMap.size(); ip++) {
        final String pkgName = pkgMap.keyAt(ip);
        if (reqPackage != null && !reqPackage.equals(pkgName)) {
            continue;
        }
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            final int uid = uids.keyAt(iu);
            final SparseArray<PackageState> vpkgs = uids.valueAt(iu);
            for (int iv = 0; iv < vpkgs.size(); iv++) {
                final int vers = vpkgs.keyAt(iv);
                final PackageState pkgState = vpkgs.valueAt(iv);
                final int NPROCS = pkgState.mProcesses.size();
                final int NSRVS = pkgState.mServices.size();
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    ProcessState proc = pkgState.mProcesses.valueAt(iproc);
                    proc.dumpPackageProcCheckin(pw, pkgName, uid, vers, pkgState.mProcesses.keyAt(iproc), now);
                }
                for (int isvc = 0; isvc < NSRVS; isvc++) {
                    final String serviceName = DumpUtils.collapseString(pkgName, pkgState.mServices.keyAt(isvc));
                    final ServiceState svc = pkgState.mServices.valueAt(isvc);
                    svc.dumpTimesCheckin(pw, pkgName, uid, vers, serviceName, now);
                }
            }
        }
    }
    ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();
    for (int ip = 0; ip < procMap.size(); ip++) {
        String procName = procMap.keyAt(ip);
        SparseArray<ProcessState> uids = procMap.valueAt(ip);
        for (int iu = 0; iu < uids.size(); iu++) {
            final int uid = uids.keyAt(iu);
            final ProcessState procState = uids.valueAt(iu);
            procState.dumpProcCheckin(pw, procName, uid, now);
        }
    }
    pw.print("total");
    DumpUtils.dumpAdjTimesCheckin(pw, ",", mMemFactorDurations, mMemFactor, mStartTime, now);
    pw.println();
    final int sysMemUsageCount = mSysMemUsage.getKeyCount();
    if (sysMemUsageCount > 0) {
        pw.print("sysmemusage");
        for (int i = 0; i < sysMemUsageCount; i++) {
            final int key = mSysMemUsage.getKeyAt(i);
            final int type = SparseMappingTable.getIdFromKey(key);
            pw.print(",");
            DumpUtils.printProcStateTag(pw, type);
            for (int j = SYS_MEM_USAGE_SAMPLE_COUNT; j < SYS_MEM_USAGE_COUNT; j++) {
                if (j > SYS_MEM_USAGE_CACHED_MINIMUM) {
                    pw.print(":");
                }
                pw.print(mSysMemUsage.getValue(key, j));
            }
        }
    }
    pw.println();
    TotalMemoryUseCollection totalMem = new TotalMemoryUseCollection(ALL_SCREEN_ADJ, ALL_MEM_ADJ);
    computeTotalMemoryUse(totalMem, now);
    pw.print("weights,");
    pw.print(totalMem.totalTime);
    pw.print(",");
    pw.print(totalMem.sysMemCachedWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemFreeWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemZRamWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemKernelWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    pw.print(",");
    pw.print(totalMem.sysMemNativeWeight);
    pw.print(":");
    pw.print(totalMem.sysMemSamples);
    for (int i = 0; i < STATE_COUNT; i++) {
        pw.print(",");
        pw.print(totalMem.processStateWeight[i]);
        pw.print(":");
        pw.print(totalMem.processStateSamples[i]);
    }
    pw.println();
    final int NPAGETYPES = mPageTypeLabels.size();
    for (int i = 0; i < NPAGETYPES; i++) {
        pw.print("availablepages,");
        pw.print(mPageTypeLabels.get(i));
        pw.print(",");
        pw.print(mPageTypeZones.get(i));
        pw.print(",");
        final int[] sizes = mPageTypeSizes.get(i);
        final int N = sizes == null ? 0 : sizes.length;
        for (int j = 0; j < N; j++) {
            if (j != 0) {
                pw.print(",");
            }
            pw.print(sizes[j]);
        }
        pw.println();
    }
}

Example 19 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ProcessStats method writeToParcel.

/** @hide */
public void writeToParcel(Parcel out, long now, int flags) {
    out.writeInt(MAGIC);
    out.writeInt(PARCEL_VERSION);
    out.writeInt(STATE_COUNT);
    out.writeInt(ADJ_COUNT);
    out.writeInt(PSS_COUNT);
    out.writeInt(SYS_MEM_USAGE_COUNT);
    out.writeInt(SparseMappingTable.ARRAY_SIZE);
    mCommonStringToIndex = new ArrayMap<String, Integer>(mProcesses.size());
    // First commit all running times.
    ArrayMap<String, SparseArray<ProcessState>> procMap = mProcesses.getMap();
    final int NPROC = procMap.size();
    for (int ip = 0; ip < NPROC; ip++) {
        SparseArray<ProcessState> uids = procMap.valueAt(ip);
        final int NUID = uids.size();
        for (int iu = 0; iu < NUID; iu++) {
            uids.valueAt(iu).commitStateTime(now);
        }
    }
    final ArrayMap<String, SparseArray<SparseArray<PackageState>>> pkgMap = mPackages.getMap();
    final int NPKG = pkgMap.size();
    for (int ip = 0; ip < NPKG; ip++) {
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        final int NUID = uids.size();
        for (int iu = 0; iu < NUID; iu++) {
            final SparseArray<PackageState> vpkgs = uids.valueAt(iu);
            final int NVERS = vpkgs.size();
            for (int iv = 0; iv < NVERS; iv++) {
                PackageState pkgState = vpkgs.valueAt(iv);
                final int NPROCS = pkgState.mProcesses.size();
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    ProcessState proc = pkgState.mProcesses.valueAt(iproc);
                    if (proc.getCommonProcess() != proc) {
                        proc.commitStateTime(now);
                    }
                }
                final int NSRVS = pkgState.mServices.size();
                for (int isvc = 0; isvc < NSRVS; isvc++) {
                    pkgState.mServices.valueAt(isvc).commitStateTime(now);
                }
            }
        }
    }
    out.writeLong(mTimePeriodStartClock);
    out.writeLong(mTimePeriodStartRealtime);
    out.writeLong(mTimePeriodEndRealtime);
    out.writeLong(mTimePeriodStartUptime);
    out.writeLong(mTimePeriodEndUptime);
    out.writeString(mRuntime);
    out.writeInt(mHasSwappedOutPss ? 1 : 0);
    out.writeInt(mFlags);
    mTableData.writeToParcel(out);
    if (mMemFactor != STATE_NOTHING) {
        mMemFactorDurations[mMemFactor] += now - mStartTime;
        mStartTime = now;
    }
    writeCompactedLongArray(out, mMemFactorDurations, mMemFactorDurations.length);
    mSysMemUsage.writeToParcel(out);
    out.writeInt(NPROC);
    for (int ip = 0; ip < NPROC; ip++) {
        writeCommonString(out, procMap.keyAt(ip));
        final SparseArray<ProcessState> uids = procMap.valueAt(ip);
        final int NUID = uids.size();
        out.writeInt(NUID);
        for (int iu = 0; iu < NUID; iu++) {
            out.writeInt(uids.keyAt(iu));
            final ProcessState proc = uids.valueAt(iu);
            writeCommonString(out, proc.getPackage());
            out.writeInt(proc.getVersion());
            proc.writeToParcel(out, now);
        }
    }
    out.writeInt(NPKG);
    for (int ip = 0; ip < NPKG; ip++) {
        writeCommonString(out, pkgMap.keyAt(ip));
        final SparseArray<SparseArray<PackageState>> uids = pkgMap.valueAt(ip);
        final int NUID = uids.size();
        out.writeInt(NUID);
        for (int iu = 0; iu < NUID; iu++) {
            out.writeInt(uids.keyAt(iu));
            final SparseArray<PackageState> vpkgs = uids.valueAt(iu);
            final int NVERS = vpkgs.size();
            out.writeInt(NVERS);
            for (int iv = 0; iv < NVERS; iv++) {
                out.writeInt(vpkgs.keyAt(iv));
                final PackageState pkgState = vpkgs.valueAt(iv);
                final int NPROCS = pkgState.mProcesses.size();
                out.writeInt(NPROCS);
                for (int iproc = 0; iproc < NPROCS; iproc++) {
                    writeCommonString(out, pkgState.mProcesses.keyAt(iproc));
                    final ProcessState proc = pkgState.mProcesses.valueAt(iproc);
                    if (proc.getCommonProcess() == proc) {
                        // This is the same as the common process we wrote above.
                        out.writeInt(0);
                    } else {
                        // There is separate data for this package's process.
                        out.writeInt(1);
                        proc.writeToParcel(out, now);
                    }
                }
                final int NSRVS = pkgState.mServices.size();
                out.writeInt(NSRVS);
                for (int isvc = 0; isvc < NSRVS; isvc++) {
                    out.writeString(pkgState.mServices.keyAt(isvc));
                    final ServiceState svc = pkgState.mServices.valueAt(isvc);
                    writeCommonString(out, svc.getProcessName());
                    svc.writeToParcel(out, now);
                }
            }
        }
    }
    // Fragmentation info (/proc/pagetypeinfo)
    final int NPAGETYPES = mPageTypeLabels.size();
    out.writeInt(NPAGETYPES);
    for (int i = 0; i < NPAGETYPES; i++) {
        out.writeInt(mPageTypeZones.get(i));
        out.writeString(mPageTypeLabels.get(i));
        out.writeIntArray(mPageTypeSizes.get(i));
    }
    mCommonStringToIndex = null;
}

Example 20 with ServiceState

use of com.android.internal.app.procstats.ServiceState in project android_frameworks_base by DirtyUnicorns.

the class ActiveServices method bindServiceLocked.

int bindServiceLocked(IApplicationThread caller, IBinder token, Intent service, String resolvedType, final IServiceConnection connection, int flags, String callingPackage, final int userId) throws TransactionTooLargeException {
    if (DEBUG_SERVICE)
        Slog.v(TAG_SERVICE, "bindService: " + service + " type=" + resolvedType + " conn=" + connection.asBinder() + " flags=0x" + Integer.toHexString(flags));
    final ProcessRecord callerApp = mAm.getRecordForAppLocked(caller);
    if (callerApp == null) {
        throw new SecurityException("Unable to find app for caller " + caller + " (pid=" + Binder.getCallingPid() + ") when binding service " + service);
    }
    ActivityRecord activity = null;
    if (token != null) {
        activity = ActivityRecord.isInStackLocked(token);
        if (activity == null) {
            Slog.w(TAG, "Binding with unknown activity: " + token);
            return 0;
        }
    }
    int clientLabel = 0;
    PendingIntent clientIntent = null;
    final boolean isCallerSystem = callerApp.info.uid == Process.SYSTEM_UID;
    if (isCallerSystem) {
        // Hacky kind of thing -- allow system stuff to tell us
        // what they are, so we can report this elsewhere for
        // others to know why certain services are running.
        service.setDefusable(true);
        clientIntent = service.getParcelableExtra(Intent.EXTRA_CLIENT_INTENT);
        if (clientIntent != null) {
            clientLabel = service.getIntExtra(Intent.EXTRA_CLIENT_LABEL, 0);
            if (clientLabel != 0) {
                // There are no useful extras in the intent, trash them.
                // System code calling with this stuff just needs to know
                // this will happen.
                service = service.cloneFilter();
            }
        }
    }
    if ((flags & Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
        mAm.enforceCallingPermission(android.Manifest.permission.MANAGE_ACTIVITY_STACKS, "BIND_TREAT_LIKE_ACTIVITY");
    }
    if ((flags & Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0 && !isCallerSystem) {
        throw new SecurityException("Non-system caller " + caller + " (pid=" + Binder.getCallingPid() + ") set BIND_ALLOW_WHITELIST_MANAGEMENT when binding service " + service);
    }
    final boolean callerFg = callerApp.setSchedGroup != ProcessList.SCHED_GROUP_BACKGROUND;
    final boolean isBindExternal = (flags & Context.BIND_EXTERNAL_SERVICE) != 0;
    ServiceLookupResult res = retrieveServiceLocked(service, resolvedType, callingPackage, Binder.getCallingPid(), Binder.getCallingUid(), userId, true, callerFg, isBindExternal);
    if (res == null) {
        return 0;
    }
    if (res.record == null) {
        return -1;
    }
    ServiceRecord s = res.record;
    boolean permissionsReviewRequired = false;
    // when done to start the bound service's process to completing the binding.
    if (mAm.mPermissionReviewRequired || Build.PERMISSIONS_REVIEW_REQUIRED) {
        if (mAm.getPackageManagerInternalLocked().isPermissionsReviewRequired(s.packageName, s.userId)) {
            permissionsReviewRequired = true;
            // Show a permission review UI only for binding from a foreground app
            if (!callerFg) {
                Slog.w(TAG, "u" + s.userId + " Binding to a service in package" + s.packageName + " requires a permissions review");
                return 0;
            }
            final ServiceRecord serviceRecord = s;
            final Intent serviceIntent = service;
            RemoteCallback callback = new RemoteCallback(new RemoteCallback.OnResultListener() {

                @Override
                public void onResult(Bundle result) {
                    synchronized (mAm) {
                        final long identity = Binder.clearCallingIdentity();
                        try {
                            if (!mPendingServices.contains(serviceRecord)) {
                                return;
                            }
                            // otherwise we unbind because the user didn't approve.
                            if (!mAm.getPackageManagerInternalLocked().isPermissionsReviewRequired(serviceRecord.packageName, serviceRecord.userId)) {
                                try {
                                    bringUpServiceLocked(serviceRecord, serviceIntent.getFlags(), callerFg, false, false);
                                } catch (RemoteException e) {
                                /* ignore - local call */
                                }
                            } else {
                                unbindServiceLocked(connection);
                            }
                        } finally {
                            Binder.restoreCallingIdentity(identity);
                        }
                    }
                }
            });
            final Intent intent = new Intent(Intent.ACTION_REVIEW_PERMISSIONS);
            intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_EXCLUDE_FROM_RECENTS);
            intent.putExtra(Intent.EXTRA_PACKAGE_NAME, s.packageName);
            intent.putExtra(Intent.EXTRA_REMOTE_CALLBACK, callback);
            if (DEBUG_PERMISSIONS_REVIEW) {
                Slog.i(TAG, "u" + s.userId + " Launching permission review for package " + s.packageName);
            }
            mAm.mHandler.post(new Runnable() {

                @Override
                public void run() {
                    mAm.mContext.startActivityAsUser(intent, new UserHandle(userId));
                }
            });
        }
    }
    final long origId = Binder.clearCallingIdentity();
    try {
        if (unscheduleServiceRestartLocked(s, callerApp.info.uid, false)) {
            if (DEBUG_SERVICE)
                Slog.v(TAG_SERVICE, "BIND SERVICE WHILE RESTART PENDING: " + s);
        }
        if ((flags & Context.BIND_AUTO_CREATE) != 0) {
            s.lastActivity = SystemClock.uptimeMillis();
            if (!s.hasAutoCreateConnections()) {
                // This is the first binding, let the tracker know.
                ServiceState stracker = s.getTracker();
                if (stracker != null) {
                    stracker.setBound(true, mAm.mProcessStats.getMemFactorLocked(), s.lastActivity);
                }
            }
        }
        mAm.startAssociationLocked(callerApp.uid, callerApp.processName, callerApp.curProcState, s.appInfo.uid, s.name, s.processName);
        AppBindRecord b = s.retrieveAppBindingLocked(service, callerApp);
        ConnectionRecord c = new ConnectionRecord(b, activity, connection, flags, clientLabel, clientIntent);
        IBinder binder = connection.asBinder();
        ArrayList<ConnectionRecord> clist = s.connections.get(binder);
        if (clist == null) {
            clist = new ArrayList<ConnectionRecord>();
            s.connections.put(binder, clist);
        }
        clist.add(c);
        b.connections.add(c);
        if (activity != null) {
            if (activity.connections == null) {
                activity.connections = new HashSet<ConnectionRecord>();
            }
            activity.connections.add(c);
        }
        b.client.connections.add(c);
        if ((c.flags & Context.BIND_ABOVE_CLIENT) != 0) {
            b.client.hasAboveClient = true;
        }
        if ((c.flags & Context.BIND_ALLOW_WHITELIST_MANAGEMENT) != 0) {
            s.whitelistManager = true;
        }
        if (s.app != null) {
            updateServiceClientActivitiesLocked(s.app, c, true);
        }
        clist = mServiceConnections.get(binder);
        if (clist == null) {
            clist = new ArrayList<ConnectionRecord>();
            mServiceConnections.put(binder, clist);
        }
        clist.add(c);
        if ((flags & Context.BIND_AUTO_CREATE) != 0) {
            s.lastActivity = SystemClock.uptimeMillis();
            if (bringUpServiceLocked(s, service.getFlags(), callerFg, false, permissionsReviewRequired) != null) {
                return 0;
            }
        }
        if (s.app != null) {
            if ((flags & Context.BIND_TREAT_LIKE_ACTIVITY) != 0) {
                s.app.treatLikeActivity = true;
            }
            if (s.whitelistManager) {
                s.app.whitelistManager = true;
            }
            // This could have made the service more important.
            mAm.updateLruProcessLocked(s.app, s.app.hasClientActivities || s.app.treatLikeActivity, b.client);
            mAm.updateOomAdjLocked(s.app);
        }
        if (DEBUG_SERVICE)
            Slog.v(TAG_SERVICE, "Bind " + s + " with " + b + ": received=" + b.intent.received + " apps=" + b.intent.apps.size() + " doRebind=" + b.intent.doRebind);
        if (s.app != null && b.intent.received) {
            // publish the connection.
            try {
                c.conn.connected(s.name, b.intent.binder);
            } catch (Exception e) {
                Slog.w(TAG, "Failure sending service " + s.shortName + " to connection " + c.conn.asBinder() + " (in " + c.binding.client.processName + ")", e);
            }
            // rebound, then do so.
            if (b.intent.apps.size() == 1 && b.intent.doRebind) {
                requestServiceBindingLocked(s, b.intent, callerFg, true);
            }
        } else if (!b.intent.requested) {
            requestServiceBindingLocked(s, b.intent, callerFg, false);
        }
        getServiceMap(s.userId).ensureNotStartingBackground(s);
    } finally {
        Binder.restoreCallingIdentity(origId);
    }
    return 1;
}