Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 480543ef authored by Karishma Vakil's avatar Karishma Vakil
Browse files

[DeviceAware] Inline some calls to AppOpsCheckingService and remove some 

methods from AppOpsService.Op and AppOpsService.UidState

This reduces the depth of call stack and removes some methods that need not be
under the aforementioned classes, as they aren't making use of the core
state maintained by the classes (ultimately AttributedOp instances).

Methods removed:

- UidState#getNonDefaultUidModes()
- UidState#getUidMode(int op)
- UidState#setUidMode(int op, int mode)
- Op#getMode()
- Op#setMode(@Mode int mode)

Bug: 299330771
Test: atest CtsAppOpsTestCases CtsAppOps2TestCases
Change-Id: I8d3a95ed4625195419b07beffbee10db2f0728a6
parent 08495046

services/core/java/com/android/server/appop/AppOpsService.java

+130 −58
Original line number Diff line number Diff line
@@ -531,19 +531,6 @@ public class AppOpsService extends IAppOpsService.Stub { 
            }

        }



        // Functions for uid mode access and manipulation.

        public SparseIntArray getNonDefaultUidModes() {

            return mAppOpsCheckingService.getNonDefaultUidModes(uid);

        }



        public int getUidMode(int op) {

            return mAppOpsCheckingService.getUidMode(uid, op);

        }



        public boolean setUidMode(int op, int mode) {

            return mAppOpsCheckingService.setUidMode(uid, op, mode);

        }



        @SuppressWarnings("GuardedBy")

        int evalMode(int op, int mode) {

            return getUidStateTracker().evalMode(uid, op, mode);
@@ -613,15 +600,6 @@ public class AppOpsService extends IAppOpsService.Stub { 
            this.packageName = packageName;

        }



        @Mode int getMode() {

            return mAppOpsCheckingService.getPackageMode(packageName, this.op,

                    UserHandle.getUserId(this.uid));

        }

        void setMode(@Mode int mode) {

            mAppOpsCheckingService.setPackageMode(packageName, this.op, mode,

                    UserHandle.getUserId(this.uid));

        }



        void removeAttributionsWithNoTime() {

            for (int i = mAttributions.size() - 1; i >= 0; i--) {

                if (!mAttributions.valueAt(i).hasAnyTime()) {
@@ -653,7 +631,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
                        mAttributions.valueAt(i).createAttributedOpEntryLocked());

            }



            return new OpEntry(op, getMode(), attributionEntries);

            return new OpEntry(

                    op,

                    mAppOpsCheckingService.getPackageMode(

                            this.packageName, this.op, UserHandle.getUserId(this.uid)),

                    attributionEntries);

        }



        @NonNull OpEntry createSingleAttributionEntryLocked(@Nullable String attributionTag) {
@@ -668,7 +650,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
                }

            }



            return new OpEntry(op, getMode(), attributionEntries);

            return new OpEntry(

                    op,

                    mAppOpsCheckingService.getPackageMode(

                            this.packageName, this.op, UserHandle.getUserId(this.uid)),

                    attributionEntries);

        }



        boolean isRunning() {
@@ -1384,8 +1370,10 @@ public class AppOpsService extends IAppOpsService.Stub { 
                    }

                    final int code = foregroundOps.keyAt(fgi);



                    if (uidState.getUidMode(code) != AppOpsManager.opToDefaultMode(code)

                            && uidState.getUidMode(code) == AppOpsManager.MODE_FOREGROUND) {

                    if (mAppOpsCheckingService.getUidMode(uidState.uid, code)

                                    != AppOpsManager.opToDefaultMode(code)

                            && mAppOpsCheckingService.getUidMode(uidState.uid, code)

                                    == AppOpsManager.MODE_FOREGROUND) {

                        mHandler.sendMessage(PooledLambda.obtainMessage(

                                AppOpsService::notifyOpChangedForAllPkgsInUid,

                                this, code, uidState.uid, true));
@@ -1405,7 +1393,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
                                    if (op == null) {

                                        continue;

                                    }

                                    if (op.getMode() == AppOpsManager.MODE_FOREGROUND) {

                                    if (mAppOpsCheckingService.getPackageMode(

                                                    op.packageName,

                                                    op.op,

                                                    UserHandle.getUserId(op.uid))

                                            == AppOpsManager.MODE_FOREGROUND) {

                                        mHandler.sendMessage(PooledLambda.obtainMessage(

                                                AppOpsService::notifyOpChanged,

                                                this, listenerSet.valueAt(cbi), code, uidState.uid,
@@ -1497,7 +1489,7 @@ public class AppOpsService extends IAppOpsService.Stub { 
    @Nullable

    private ArrayList<AppOpsManager.OpEntry> collectUidOps(@NonNull UidState uidState,

            @Nullable int[] ops) {

        final SparseIntArray opModes = uidState.getNonDefaultUidModes();

        final SparseIntArray opModes = mAppOpsCheckingService.getNonDefaultUidModes(uidState.uid);

        if (opModes == null) {

            return null;

        }
@@ -1778,7 +1770,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
            Ops ops = getOpsLocked(uid, packageName, null, false, null, /* edit */ false);

            if (ops != null) {

                ops.remove(op.op);

                op.setMode(AppOpsManager.opToDefaultMode(op.op));

                mAppOpsCheckingService.setPackageMode(

                        packageName,

                        op.op,

                        AppOpsManager.opToDefaultMode(op.op),

                        UserHandle.getUserId(op.uid));

                if (ops.size() <= 0) {

                    UidState uidState = ops.uidState;

                    ArrayMap<String, Ops> pkgOps = uidState.pkgOps;
@@ -1848,15 +1844,16 @@ public class AppOpsService extends IAppOpsService.Stub { 
                uidState = new UidState(uid);

                mUidStates.put(uid, uidState);

            }

            if (uidState.getUidMode(code) != AppOpsManager.opToDefaultMode(code)) {

                previousMode = uidState.getUidMode(code);

            if (mAppOpsCheckingService.getUidMode(uidState.uid, code)

                    != AppOpsManager.opToDefaultMode(code)) {

                previousMode = mAppOpsCheckingService.getUidMode(uidState.uid, code);

            } else {

                // doesn't look right but is legacy behavior.

                previousMode = MODE_DEFAULT;

            }



            mIgnoredCallback = permissionPolicyCallback;

            if (!uidState.setUidMode(code, mode)) {

            if (!mAppOpsCheckingService.setUidMode(uidState.uid, code, mode)) {

                return;

            }

            if (mode != MODE_ERRORED && mode != previousMode) {
@@ -2133,10 +2130,15 @@ public class AppOpsService extends IAppOpsService.Stub { 
        synchronized (this) {

            Op op = getOpLocked(code, uid, packageName, null, false, pvr.bypass, /* edit */ true);

            if (op != null) {

                if (op.getMode() != mode) {

                    previousMode = op.getMode();

                if (mAppOpsCheckingService.getPackageMode(

                                op.packageName, op.op, UserHandle.getUserId(op.uid))

                        != mode) {

                    previousMode =

                            mAppOpsCheckingService.getPackageMode(

                                    op.packageName, op.op, UserHandle.getUserId(op.uid));

                    mIgnoredCallback = permissionPolicyCallback;

                    op.setMode(mode);

                    mAppOpsCheckingService.setPackageMode(op.packageName, op.op, mode,

                            UserHandle.getUserId(op.uid));

                }

            }

        }
@@ -2274,7 +2276,7 @@ public class AppOpsService extends IAppOpsService.Stub { 
            for (int i = mUidStates.size() - 1; i >= 0; i--) {

                UidState uidState = mUidStates.valueAt(i);



                SparseIntArray opModes = uidState.getNonDefaultUidModes();

                SparseIntArray opModes = mAppOpsCheckingService.getNonDefaultUidModes(uidState.uid);

                if (opModes != null && (uidState.uid == reqUid || reqUid == -1)) {

                    final int uidOpCount = opModes.size();

                    for (int j = uidOpCount - 1; j >= 0; j--) {
@@ -2283,7 +2285,7 @@ public class AppOpsService extends IAppOpsService.Stub { 
                            int previousMode = opModes.valueAt(j);

                            int newMode = isUidOpGrantedByRole(uidState.uid, code) ? MODE_ALLOWED :

                                    AppOpsManager.opToDefaultMode(code);

                            uidState.setUidMode(code, newMode);

                            mAppOpsCheckingService.setUidMode(uidState.uid, code, newMode);

                            for (String packageName : getPackagesForUid(uidState.uid)) {

                                callbacks = addCallbacks(callbacks, code, uidState.uid, packageName,

                                        previousMode, mOpModeWatchers.get(code));
@@ -2325,14 +2327,22 @@ public class AppOpsService extends IAppOpsService.Stub { 
                            continue;

                        }

                        if (AppOpsManager.opAllowsReset(curOp.op)) {

                            int previousMode = curOp.getMode();

                            int previousMode =

                                    mAppOpsCheckingService.getPackageMode(

                                            curOp.packageName,

                                            curOp.op,

                                            UserHandle.getUserId(curOp.uid));

                            int newMode = isPackageOpGrantedByRole(packageName, uidState.uid,

                                    curOp.op) ? MODE_ALLOWED : AppOpsManager.opToDefaultMode(

                                    curOp.op);

                            if (previousMode == newMode) {

                                continue;

                            }

                            curOp.setMode(newMode);

                            mAppOpsCheckingService.setPackageMode(

                                    curOp.packageName,

                                    curOp.op,

                                    newMode,

                                    UserHandle.getUserId(curOp.uid));

                            changed = true;

                            uidChanged = true;

                            final int uid = curOp.uidState.uid;
@@ -2591,15 +2601,22 @@ public class AppOpsService extends IAppOpsService.Stub { 
            code = AppOpsManager.opToSwitch(code);

            UidState uidState = getUidStateLocked(uid, false);

            if (uidState != null

                    && uidState.getUidMode(code) != AppOpsManager.opToDefaultMode(code)) {

                final int rawMode = uidState.getUidMode(code);

                    && mAppOpsCheckingService.getUidMode(uidState.uid, code)

                            != AppOpsManager.opToDefaultMode(code)) {

                final int rawMode = mAppOpsCheckingService.getUidMode(uidState.uid, code);

                return raw ? rawMode : uidState.evalMode(code, rawMode);

            }

            Op op = getOpLocked(code, uid, packageName, null, false, pvr.bypass, /* edit */ false);

            if (op == null) {

                return AppOpsManager.opToDefaultMode(code);

            }

            return raw ? op.getMode() : op.uidState.evalMode(op.op, op.getMode());

            return raw

                    ? mAppOpsCheckingService.getPackageMode(

                            op.packageName, op.op, UserHandle.getUserId(op.uid))

                    : op.uidState.evalMode(

                            op.op,

                            mAppOpsCheckingService.getPackageMode(

                                    op.packageName, op.op, UserHandle.getUserId(op.uid)));

        }

    }
@@ -2835,8 +2852,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
            }

            // If there is a non-default per UID policy (we set UID op mode only if

            // non-default) it takes over, otherwise use the per package policy.

            if (uidState.getUidMode(switchCode) != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode = uidState.evalMode(code, uidState.getUidMode(switchCode));

            if (mAppOpsCheckingService.getUidMode(uidState.uid, switchCode)

                    != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode =

                        uidState.evalMode(

                                code, mAppOpsCheckingService.getUidMode(uidState.uid, switchCode));

                if (uidMode != AppOpsManager.MODE_ALLOWED) {

                    if (DEBUG) Slog.d(TAG, "noteOperation: uid reject #" + uidMode + " for code "

                            + switchCode + " (" + code + ") uid " + uid + " package "
@@ -2849,7 +2869,13 @@ public class AppOpsService extends IAppOpsService.Stub { 
            } else {

                final Op switchOp = switchCode != code ? getOpLocked(ops, switchCode, uid, true)

                        : op;

                final int mode = switchOp.uidState.evalMode(switchOp.op, switchOp.getMode());

                final int mode =

                        switchOp.uidState.evalMode(

                                switchOp.op,

                                mAppOpsCheckingService.getPackageMode(

                                        switchOp.packageName,

                                        switchOp.op,

                                        UserHandle.getUserId(switchOp.uid)));

                if (mode != AppOpsManager.MODE_ALLOWED) {

                    if (DEBUG) Slog.d(TAG, "noteOperation: reject #" + mode + " for code "

                            + switchCode + " (" + code + ") uid " + uid + " package "
@@ -3371,8 +3397,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
            final int switchCode = AppOpsManager.opToSwitch(code);

            // If there is a non-default per UID policy (we set UID op mode only if

            // non-default) it takes over, otherwise use the per package policy.

            if (uidState.getUidMode(switchCode) != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode = uidState.evalMode(code, uidState.getUidMode(switchCode));

            if (mAppOpsCheckingService.getUidMode(uidState.uid, switchCode)

                    != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode =

                        uidState.evalMode(

                                code, mAppOpsCheckingService.getUidMode(uidState.uid, switchCode));

                if (!shouldStartForMode(uidMode, startIfModeDefault)) {

                    if (DEBUG) {

                        Slog.d(TAG, "startOperation: uid reject #" + uidMode + " for code "
@@ -3387,7 +3416,13 @@ public class AppOpsService extends IAppOpsService.Stub { 
            } else {

                final Op switchOp = switchCode != code ? getOpLocked(ops, switchCode, uid, true)

                        : op;

                final int mode = switchOp.uidState.evalMode(switchOp.op, switchOp.getMode());

                final int mode =

                        switchOp.uidState.evalMode(

                                switchOp.op,

                                mAppOpsCheckingService.getPackageMode(

                                        switchOp.packageName,

                                        switchOp.op,

                                        UserHandle.getUserId(switchOp.uid)));

                if (mode != AppOpsManager.MODE_ALLOWED

                        && (!startIfModeDefault || mode != MODE_DEFAULT)) {

                    if (DEBUG) Slog.d(TAG, "startOperation: reject #" + mode + " for code "
@@ -3477,8 +3512,11 @@ public class AppOpsService extends IAppOpsService.Stub { 
            final int switchCode = AppOpsManager.opToSwitch(code);

            // If there is a non-default mode per UID policy (we set UID op mode only if

            // non-default) it takes over, otherwise use the per package policy.

            if (uidState.getUidMode(switchCode) != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode = uidState.evalMode(code, uidState.getUidMode(switchCode));

            if (mAppOpsCheckingService.getUidMode(uidState.uid, switchCode)

                    != AppOpsManager.opToDefaultMode(switchCode)) {

                final int uidMode =

                        uidState.evalMode(

                                code, mAppOpsCheckingService.getUidMode(uidState.uid, switchCode));

                if (!shouldStartForMode(uidMode, startIfModeDefault)) {

                    if (DEBUG) {

                        Slog.d(TAG, "startOperation: uid reject #" + uidMode + " for code "
@@ -3490,7 +3528,13 @@ public class AppOpsService extends IAppOpsService.Stub { 
            } else {

                final Op switchOp = switchCode != code ? getOpLocked(ops, switchCode, uid, true)

                        : op;

                final int mode = switchOp.uidState.evalMode(switchOp.op, switchOp.getMode());

                final int mode =

                        switchOp.uidState.evalMode(

                                switchOp.op,

                                mAppOpsCheckingService.getPackageMode(

                                        switchOp.packageName,

                                        switchOp.op,

                                        UserHandle.getUserId(switchOp.uid)));

                if (mode != AppOpsManager.MODE_ALLOWED

                        && (!startIfModeDefault || mode != MODE_DEFAULT)) {

                    if (DEBUG) {
@@ -5619,7 +5663,8 @@ public class AppOpsService extends IAppOpsService.Stub { 
            }

            for (int i=0; i<mUidStates.size(); i++) {

                UidState uidState = mUidStates.valueAt(i);

                final SparseIntArray opModes = uidState.getNonDefaultUidModes();

                final SparseIntArray opModes =

                        mAppOpsCheckingService.getNonDefaultUidModes(uidState.uid);

                final ArrayMap<String, Ops> pkgOps = uidState.pkgOps;



                if (dumpWatchers || dumpHistory) {
@@ -5647,7 +5692,12 @@ public class AppOpsService extends IAppOpsService.Stub { 
                            }

                            if (!hasMode) {

                                for (int opi = 0; !hasMode && opi < ops.size(); opi++) {

                                    if (ops.valueAt(opi).getMode() == dumpMode) {

                                    final Op op = ops.valueAt(opi);

                                    if (mAppOpsCheckingService.getPackageMode(

                                                    op.packageName,

                                                    op.op,

                                                    UserHandle.getUserId(op.uid))

                                            == dumpMode) {

                                        hasMode = true;

                                    }

                                }
@@ -5698,7 +5748,12 @@ public class AppOpsService extends IAppOpsService.Stub { 
                        if (dumpOp >= 0 && dumpOp != opCode) {

                            continue;

                        }

                        if (dumpMode >= 0 && dumpMode != op.getMode()) {

                        if (dumpMode >= 0

                                && dumpMode

                                        != mAppOpsCheckingService.getPackageMode(

                                                op.packageName,

                                                op.op,

                                                UserHandle.getUserId(op.uid))) {

                            continue;

                        }

                        if (!printedPackage) {
@@ -5706,14 +5761,25 @@ public class AppOpsService extends IAppOpsService.Stub { 
                            printedPackage = true;

                        }

                        pw.print("      "); pw.print(AppOpsManager.opToName(opCode));

                        pw.print(" ("); pw.print(AppOpsManager.modeToName(op.getMode()));

                        pw.print(" (");

                        pw.print(

                                AppOpsManager.modeToName(

                                        mAppOpsCheckingService.getPackageMode(

                                                op.packageName,

                                                op.op,

                                                UserHandle.getUserId(op.uid))));

                        final int switchOp = AppOpsManager.opToSwitch(opCode);

                        if (switchOp != opCode) {

                            pw.print(" / switch ");

                            pw.print(AppOpsManager.opToName(switchOp));

                            final Op switchObj = ops.get(switchOp);

                            int mode = switchObj == null

                                    ? AppOpsManager.opToDefaultMode(switchOp) : switchObj.getMode();

                            int mode =

                                    switchObj == null

                                            ? AppOpsManager.opToDefaultMode(switchOp)

                                            : mAppOpsCheckingService.getPackageMode(

                                                    switchObj.packageName,

                                                    switchObj.op,

                                                    UserHandle.getUserId(switchObj.uid));

                            pw.print("="); pw.print(AppOpsManager.modeToName(mode));

                        }

                        pw.println("): ");
@@ -5847,7 +5913,13 @@ public class AppOpsService extends IAppOpsService.Stub { 
        for (int pkgNum = 0; pkgNum < numPkgOps; pkgNum++) {

            Ops ops = uidState.pkgOps.valueAt(pkgNum);

            Op op = ops != null ? ops.get(code) : null;

            if (op == null || (op.getMode() != MODE_ALLOWED && op.getMode() != MODE_FOREGROUND)) {

            if (op == null) {

                continue;

            }

            final int mode =

                    mAppOpsCheckingService.getPackageMode(

                            op.packageName, op.op, UserHandle.getUserId(op.uid));

            if (mode != MODE_ALLOWED && mode != MODE_FOREGROUND) {

                continue;

            }

            int numAttrTags = op.mAttributions.size();