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

Commit 1c1286fe authored by Stanislav Zholnin's avatar Stanislav Zholnin Committed by Nate Myren
Browse files

Add support of AttributionIds and AttributionChains to Discrete registry

Test: manually verified with dumpsys appops --include-discrete 0
Bug: 158792096
Change-Id: Ia6f89ff003f710c3b1b427da8788f34754723107
parent 49be55d1
Loading
Loading
Loading
Loading
+9 −6
Original line number Diff line number Diff line
@@ -848,7 +848,7 @@ public class AppOpsService extends IAppOpsService.Stub {
            return mAttributionFlags;
        }

        /** @return attributoin chiang id for the access */
        /** @return attribution chain id for the access */
        public int getAttributionChainId() {
            return mAttributionChainId;
        }
@@ -912,7 +912,8 @@ public class AppOpsService extends IAppOpsService.Stub {
                    proxyAttributionTag, uidState, flags);

            mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid, parent.packageName,
                    tag, uidState, flags, accessTime);
                    tag, uidState, flags, accessTime, AppOpsManager.ATTRIBUTION_FLAGS_NONE,
                    AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE);
        }

        /**
@@ -1053,9 +1054,9 @@ public class AppOpsService extends IAppOpsService.Stub {
            event.numUnfinishedStarts++;

            if (isStarted) {
                // TODO: Consider storing the attribution chain flags and id
                mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
                        parent.packageName, tag, uidState, flags, startTime);
                        parent.packageName, tag, uidState, flags, startTime, attributionFlags,
                        attributionChainId);
            }
        }

@@ -1112,7 +1113,8 @@ public class AppOpsService extends IAppOpsService.Stub {

                mHistoricalRegistry.increaseOpAccessDuration(parent.op, parent.uid,
                        parent.packageName, tag, event.getUidState(),
                        event.getFlags(), finishedEvent.getNoteTime(), finishedEvent.getDuration());
                        event.getFlags(), finishedEvent.getNoteTime(), finishedEvent.getDuration(),
                        event.getAttributionFlags(), event.getAttributionChainId());

                if (!isPausing) {
                    mInProgressStartOpEventPool.release(event);
@@ -1215,7 +1217,8 @@ public class AppOpsService extends IAppOpsService.Stub {
                event.mStartElapsedTime = SystemClock.elapsedRealtime();
                event.mStartTime = startTime;
                mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
                        parent.packageName, tag, event.mUidState, event.mFlags, startTime);
                        parent.packageName, tag, event.mUidState, event.mFlags, startTime,
                        event.getAttributionFlags(), event.getAttributionChainId());
                if (shouldSendActive) {
                    scheduleOpActiveChangedIfNeededLocked(parent.op, parent.uid, parent.packageName,
                            tag, true, event.getAttributionFlags(), event.getAttributionChainId());
+66 −24
Original line number Diff line number Diff line
@@ -26,6 +26,7 @@ import static android.app.AppOpsManager.OP_FINE_LOCATION;
import static android.app.AppOpsManager.OP_FLAGS_ALL;
import static android.app.AppOpsManager.OP_FLAG_SELF;
import static android.app.AppOpsManager.OP_FLAG_TRUSTED_PROXIED;
import static android.app.AppOpsManager.OP_FLAG_TRUSTED_PROXY;
import static android.app.AppOpsManager.OP_NONE;
import static android.app.AppOpsManager.OP_PHONE_CALL_CAMERA;
import static android.app.AppOpsManager.OP_PHONE_CALL_MICROPHONE;
@@ -156,8 +157,11 @@ final class DiscreteRegistry {
    private static final String ATTR_NOTE_DURATION = "nd";
    private static final String ATTR_UID_STATE = "us";
    private static final String ATTR_FLAGS = "f";
    private static final String ATTR_ATTRIBUTION_FLAGS = "af";
    private static final String ATTR_CHAIN_ID = "ci";

    private static final int OP_FLAGS_DISCRETE = OP_FLAG_SELF | OP_FLAG_TRUSTED_PROXIED;
    private static final int OP_FLAGS_DISCRETE = OP_FLAG_SELF | OP_FLAG_TRUSTED_PROXIED
            | OP_FLAG_TRUSTED_PROXY;

    // Lock for read/write access to on disk state
    private final Object mOnDiskLock = new Object();
@@ -227,13 +231,14 @@ final class DiscreteRegistry {

    void recordDiscreteAccess(int uid, String packageName, int op, @Nullable String attributionTag,
            @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState, long accessTime,
            long accessDuration) {
            long accessDuration, @AppOpsManager.AttributionFlags int attributionFlags,
            int attributionChainId) {
        if (!isDiscreteOp(op, flags)) {
            return;
        }
        synchronized (mInMemoryLock) {
            mDiscreteOps.addDiscreteAccess(op, uid, packageName, attributionTag, flags, uidState,
                    accessTime, accessDuration);
                    accessTime, accessDuration, attributionFlags, attributionChainId);
        }
    }

@@ -383,9 +388,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, int uid, @NonNull String packageName,
                @Nullable String attributionTag, @AppOpsManager.OpFlags int flags,
                @AppOpsManager.UidState int uidState, long accessTime, long accessDuration) {
                @AppOpsManager.UidState int uidState, long accessTime, long accessDuration,
                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscreteUidOps(uid).addDiscreteAccess(op, packageName, attributionTag, flags,
                    uidState, accessTime, accessDuration);
                    uidState, accessTime, accessDuration, attributionFlags, attributionChainId);
        }

        private void filter(long beginTimeMillis, long endTimeMillis,
@@ -613,9 +619,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, @NonNull String packageName, @Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
                long accessTime, long accessDuration) {
                long accessTime, long accessDuration,
                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscretePackageOps(packageName).addDiscreteAccess(op, attributionTag, flags,
                    uidState, accessTime, accessDuration);
                    uidState, accessTime, accessDuration, attributionFlags, attributionChainId);
        }

        private DiscretePackageOps getOrCreateDiscretePackageOps(String packageName) {
@@ -680,9 +687,10 @@ final class DiscreteRegistry {

        void addDiscreteAccess(int op, @Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
                long accessTime, long accessDuration) {
                long accessTime, long accessDuration,
                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            getOrCreateDiscreteOp(op).addDiscreteAccess(attributionTag, flags, uidState, accessTime,
                    accessDuration);
                    accessDuration, attributionFlags, attributionChainId);
        }

        void merge(DiscretePackageOps other) {
@@ -823,37 +831,39 @@ final class DiscreteRegistry {
                for (int j = 0; j < n; j++) {
                    DiscreteOpEvent event = list.get(j);
                    list.set(j, new DiscreteOpEvent(event.mNoteTime - offset, event.mNoteDuration,
                            event.mUidState, event.mOpFlag));
                            event.mUidState, event.mOpFlag, event.mAttributionFlags,
                            event.mAttributionChainId));
                }
            }
        }

        void addDiscreteAccess(@Nullable String attributionTag,
                @AppOpsManager.OpFlags int flags, @AppOpsManager.UidState int uidState,
                long accessTime, long accessDuration) {
                long accessTime, long accessDuration,
                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            List<DiscreteOpEvent> attributedOps = getOrCreateDiscreteOpEventsList(
                    attributionTag);
            accessTime = accessTime / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
            accessDuration = accessDuration == -1 ? -1
                    : (accessDuration + sDiscreteHistoryQuantization - 1)
                            / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;

            int nAttributedOps = attributedOps.size();
            int i = nAttributedOps;
            for (; i > 0; i--) {
                DiscreteOpEvent previousOp = attributedOps.get(i - 1);
                if (previousOp.mNoteTime < accessTime) {
                if (discretizeTimeStamp(previousOp.mNoteTime) < discretizeTimeStamp(accessTime)) {
                    break;
                }
                if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState) {
                    if (accessDuration != previousOp.mNoteDuration) {
                if (previousOp.mOpFlag == flags && previousOp.mUidState == uidState
                        && previousOp.mAttributionFlags == attributionFlags
                        && previousOp.mAttributionChainId == attributionChainId) {
                    if (discretizeDuration(accessDuration) != discretizeDuration(
                            previousOp.mNoteDuration)) {
                        break;
                    } else {
                        return;
                    }
                }
            }
            attributedOps.add(i, new DiscreteOpEvent(accessTime, accessDuration, uidState, flags));
            attributedOps.add(i, new DiscreteOpEvent(accessTime, accessDuration, uidState, flags,
                    attributionFlags, attributionChainId));
        }

        private List<DiscreteOpEvent> getOrCreateDiscreteOpEventsList(String attributionTag) {
@@ -875,7 +885,8 @@ final class DiscreteRegistry {
                for (int j = 0; j < nEvents; j++) {
                    DiscreteOpEvent event = events.get(j);
                    result.addDiscreteAccess(op, uid, packageName, tag, event.mUidState,
                            event.mOpFlag, event.mNoteTime, event.mNoteDuration);
                            event.mOpFlag, discretizeTimeStamp(event.mNoteTime),
                            discretizeDuration(event.mNoteDuration));
                }
            }
        }
@@ -932,11 +943,15 @@ final class DiscreteRegistry {
                                    -1);
                            int uidState = parser.getAttributeInt(null, ATTR_UID_STATE);
                            int opFlags = parser.getAttributeInt(null, ATTR_FLAGS);
                            int attributionFlags = parser.getAttributeInt(null,
                                    ATTR_ATTRIBUTION_FLAGS, AppOpsManager.ATTRIBUTION_FLAGS_NONE);
                            int attributionChainId = parser.getAttributeInt(null, ATTR_CHAIN_ID,
                                    AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE);
                            if (noteTime + noteDuration < beginTimeMillis) {
                                continue;
                            }
                            DiscreteOpEvent event = new DiscreteOpEvent(noteTime, noteDuration,
                                    uidState, opFlags);
                                    uidState, opFlags, attributionFlags, attributionChainId);
                            events.add(event);
                        }
                    }
@@ -952,13 +967,18 @@ final class DiscreteRegistry {
        final long mNoteDuration;
        final @AppOpsManager.UidState int mUidState;
        final @AppOpsManager.OpFlags int mOpFlag;
        final @AppOpsManager.AttributionFlags int mAttributionFlags;
        final int mAttributionChainId;

        DiscreteOpEvent(long noteTime, long noteDuration, @AppOpsManager.UidState int uidState,
                @AppOpsManager.OpFlags int opFlag) {
                @AppOpsManager.OpFlags int opFlag,
                @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
            mNoteTime = noteTime;
            mNoteDuration = noteDuration;
            mUidState = uidState;
            mOpFlag = opFlag;
            mAttributionFlags = attributionFlags;
            mAttributionChainId = attributionChainId;
        }

        private void dump(@NonNull PrintWriter pw, @NonNull SimpleDateFormat sdf,
@@ -969,13 +989,19 @@ final class DiscreteRegistry {
            pw.print("-");
            pw.print(flagsToString(mOpFlag));
            pw.print("] at ");
            date.setTime(mNoteTime);
            date.setTime(discretizeTimeStamp(mNoteTime));
            pw.print(sdf.format(date));
            if (mNoteDuration != -1) {
                pw.print(" for ");
                pw.print(mNoteDuration);
                pw.print(discretizeDuration(mNoteDuration));
                pw.print(" milliseconds ");
            }
            if (mAttributionFlags != AppOpsManager.ATTRIBUTION_FLAGS_NONE) {
                pw.print(" attribution flags=");
                pw.print(mAttributionFlags);
                pw.print(" with chainId=");
                pw.print(mAttributionChainId);
            }
            pw.println();
        }

@@ -984,6 +1010,12 @@ final class DiscreteRegistry {
            if (mNoteDuration != -1) {
                out.attributeLong(null, ATTR_NOTE_DURATION, mNoteDuration);
            }
            if (mAttributionFlags != AppOpsManager.ATTRIBUTION_FLAGS_NONE) {
                out.attributeInt(null, ATTR_ATTRIBUTION_FLAGS, mAttributionFlags);
            }
            if (mAttributionChainId != AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE) {
                out.attributeInt(null, ATTR_CHAIN_ID, mAttributionChainId);
            }
            out.attributeInt(null, ATTR_UID_STATE, mUidState);
            out.attributeInt(null, ATTR_FLAGS, mOpFlag);
        }
@@ -1055,6 +1087,16 @@ final class DiscreteRegistry {
        return true;
    }

    private static long discretizeTimeStamp(long timeStamp) {
        return timeStamp / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;

    }

    private static long discretizeDuration(long duration) {
        return duration == -1 ? -1 : (duration + sDiscreteHistoryQuantization - 1)
                        / sDiscreteHistoryQuantization * sDiscreteHistoryQuantization;
    }

    void setDebugMode(boolean debugMode) {
        this.mDebugMode = debugMode;
    }
+7 −4
Original line number Diff line number Diff line
@@ -487,7 +487,8 @@ final class HistoricalRegistry {

    void incrementOpAccessedCount(int op, int uid, @NonNull String packageName,
            @Nullable String attributionTag, @UidState int uidState, @OpFlags int flags,
            long accessTime) {
            long accessTime, @AppOpsManager.AttributionFlags int attributionFlags,
            int attributionChainId) {
        synchronized (mInMemoryLock) {
            if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_ACTIVE) {
                if (!isPersistenceInitializedMLocked()) {
@@ -499,7 +500,7 @@ final class HistoricalRegistry {
                        attributionTag, uidState, flags, 1);

                mDiscreteRegistry.recordDiscreteAccess(uid, packageName, op, attributionTag,
                        flags, uidState, accessTime, -1);
                        flags, uidState, accessTime, -1, attributionFlags, attributionChainId);
            }
        }
    }
@@ -521,7 +522,8 @@ final class HistoricalRegistry {

    void increaseOpAccessDuration(int op, int uid, @NonNull String packageName,
            @Nullable String attributionTag, @UidState int uidState, @OpFlags int flags,
            long eventStartTime, long increment) {
            long eventStartTime, long increment,
            @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId) {
        synchronized (mInMemoryLock) {
            if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_ACTIVE) {
                if (!isPersistenceInitializedMLocked()) {
@@ -532,7 +534,8 @@ final class HistoricalRegistry {
                        System.currentTimeMillis()).increaseAccessDuration(op, uid, packageName,
                        attributionTag, uidState, flags, increment);
                mDiscreteRegistry.recordDiscreteAccess(uid, packageName, op, attributionTag,
                        flags, uidState, eventStartTime, increment);
                        flags, uidState, eventStartTime, increment, attributionFlags,
                        attributionChainId);
            }
        }
    }