Merge "Revert "Batch noteOperation binder calls in the client to reduce..."" into main

9 files changed, 67 insertions, 304 deletions

diff --git a/core/java/android/app/AppOpsManager.aidl b/core/java/android/app/AppOpsManager.aidl
index 56ed290baf2e..b4dee2e937cb 100644
--- a/core/java/android/app/AppOpsManager.aidl
+++ b/core/java/android/app/AppOpsManager.aidl
@@ -19,7 +19,6 @@ package android.app;
 parcelable AppOpsManager.PackageOps;
 parcelable AppOpsManager.NoteOpEventProxyInfo;
 parcelable AppOpsManager.NoteOpEvent;
-parcelable AppOpsManager.NotedOp;
 parcelable AppOpsManager.OpFeatureEntry;
 parcelable AppOpsManager.OpEntry;
 
diff --git a/core/java/android/app/AppOpsManager.java b/core/java/android/app/AppOpsManager.java
index c789e28cdbab..19138126698c 100644
--- a/core/java/android/app/AppOpsManager.java
+++ b/core/java/android/app/AppOpsManager.java
@@ -262,24 +262,6 @@ public class AppOpsManager {
 
     private static final Object sLock = new Object();
 
-    // A map that records noted times for each op.
-    private final ArrayMap<NotedOp, Integer> mPendingNotedOps = new ArrayMap<>();
-    private final HandlerThread mHandlerThread;
-    private final Handler mHandler;
-    private static final int NOTE_OP_BATCHING_DELAY_MILLIS = 1000;
-
-    private boolean isNoteOpBatchingSupported() {
-        // If noteOp is called from system server no IPC is made, hence we don't need batching.
-        if (Process.myUid() == Process.SYSTEM_UID) {
-            return false;
-        }
-        return Flags.noteOpBatchingEnabled();
-    }
-
-    private final Object mBatchedNoteOpLock = new Object();
-    @GuardedBy("mBatchedNoteOpLock")
-    private boolean mIsBatchedNoteOpCallScheduled = false;
-
     /** Current {@link OnOpNotedCallback}. Change via {@link #setOnOpNotedCallback} */
     @GuardedBy("sLock")
     private static @Nullable OnOpNotedCallback sOnOpNotedCallback;
@@ -7484,135 +7466,6 @@ public class AppOpsManager {
     }
 
     /**
-     * A NotedOp is an app op grouped in noteOp API and sent to the system server in a batch
-     *
-     * @hide
-     */
-    public static final class NotedOp implements Parcelable {
-        private final @IntRange(from = 0, to = _NUM_OP - 1) int mOp;
-        private final @IntRange(from = 0) int mUid;
-        private final @Nullable String mPackageName;
-        private final @Nullable String mAttributionTag;
-        private final int mVirtualDeviceId;
-        private final @Nullable String mMessage;
-        private final boolean mShouldCollectAsyncNotedOp;
-        private final boolean mShouldCollectMessage;
-
-        public NotedOp(int op, int uid, @Nullable String packageName,
-                @Nullable String attributionTag, int virtualDeviceId, @Nullable String message,
-                boolean shouldCollectAsyncNotedOp, boolean shouldCollectMessage) {
-            mOp = op;
-            mUid = uid;
-            mPackageName = packageName;
-            mAttributionTag = attributionTag;
-            mVirtualDeviceId = virtualDeviceId;
-            mMessage = message;
-            mShouldCollectAsyncNotedOp = shouldCollectAsyncNotedOp;
-            mShouldCollectMessage = shouldCollectMessage;
-        }
-
-        NotedOp(Parcel source) {
-            mOp = source.readInt();
-            mUid = source.readInt();
-            mPackageName = source.readString();
-            mAttributionTag = source.readString();
-            mVirtualDeviceId = source.readInt();
-            mMessage = source.readString();
-            mShouldCollectAsyncNotedOp = source.readBoolean();
-            mShouldCollectMessage = source.readBoolean();
-        }
-
-        public int getOp() {
-            return mOp;
-        }
-
-        public int getUid() {
-            return mUid;
-        }
-
-        public @Nullable String getPackageName() {
-            return mPackageName;
-        }
-
-        public @Nullable String getAttributionTag() {
-            return mAttributionTag;
-        }
-
-        public int getVirtualDeviceId() {
-            return mVirtualDeviceId;
-        }
-
-        public @Nullable String getMessage() {
-            return mMessage;
-        }
-
-        public boolean getShouldCollectAsyncNotedOp() {
-            return mShouldCollectAsyncNotedOp;
-        }
-
-        public boolean getShouldCollectMessage() {
-            return mShouldCollectMessage;
-        }
-
-        @Override
-        public int describeContents() {
-            return 0;
-        }
-
-        @Override
-        public void writeToParcel(@NonNull Parcel dest, int flags) {
-            dest.writeInt(mOp);
-            dest.writeInt(mUid);
-            dest.writeString(mPackageName);
-            dest.writeString(mAttributionTag);
-            dest.writeInt(mVirtualDeviceId);
-            dest.writeString(mMessage);
-            dest.writeBoolean(mShouldCollectAsyncNotedOp);
-            dest.writeBoolean(mShouldCollectMessage);
-        }
-
-        @Override
-        public boolean equals(Object o) {
-            if (this == o) return true;
-            if (o == null || getClass() != o.getClass()) return false;
-            NotedOp that = (NotedOp) o;
-            return mOp == that.mOp && mUid == that.mUid && Objects.equals(mPackageName,
-                    that.mPackageName) && Objects.equals(mAttributionTag, that.mAttributionTag)
-                    && mVirtualDeviceId == that.mVirtualDeviceId && Objects.equals(mMessage,
-                    that.mMessage) && Objects.equals(mShouldCollectAsyncNotedOp,
-                    that.mShouldCollectAsyncNotedOp) && Objects.equals(mShouldCollectMessage,
-                    that.mShouldCollectMessage);
-        }
-
-        @Override
-        public int hashCode() {
-            return Objects.hash(mOp, mUid, mPackageName, mAttributionTag, mVirtualDeviceId,
-                    mMessage, mShouldCollectAsyncNotedOp, mShouldCollectMessage);
-        }
-
-        @Override
-        public String toString() {
-            return "NotedOp{" + "mOp=" + mOp + ", mUid=" + mUid + ", mPackageName=" + mPackageName
-                    + ", mAttributionTag=" + mAttributionTag + ", mVirtualDeviceId="
-                    + mVirtualDeviceId + ", mMessage=" + mMessage + ", mShouldCollectAsyncNotedOp="
-                    + mShouldCollectAsyncNotedOp + ", mShouldCollectMessage="
-                    + mShouldCollectMessage + "}";
-        }
-
-
-        public static final @NonNull Creator<NotedOp> CREATOR =
-                new Creator<>() {
-                    @Override public NotedOp createFromParcel(Parcel source) {
-                        return new NotedOp(source);
-                    }
-
-                    @Override public NotedOp[] newArray(int size) {
-                        return new NotedOp[size];
-                    }
-                };
-    }
-
-    /**
      * Computes the sum of the counts for the given flags in between the begin and
      * end UID states.
      *
@@ -8126,9 +7979,6 @@ public class AppOpsManager {
     AppOpsManager(Context context, IAppOpsService service) {
         mContext = context;
         mService = service;
-        mHandlerThread = new HandlerThread("AppOpsManager");
-        mHandlerThread.start();
-        mHandler = mHandlerThread.getThreadHandler();
 
         if (mContext != null) {
             final PackageManager pm = mContext.getPackageManager();
@@ -9465,74 +9315,15 @@ public class AppOpsManager {
                 }
             }
 
-            SyncNotedAppOp syncOp = null;
-            boolean skipBinderCall = false;
-            if (isNoteOpBatchingSupported()) {
-                int mode = sAppOpModeCache.query(
-                        new AppOpModeQuery(op, uid, packageName, virtualDeviceId, attributionTag,
-                                "noteOpNoThrow"));
-                // For FOREGROUND mode, we still need to make a binder call to the system service
-                // to translate it to ALLOWED or IGNORED. So no batching is needed.
-                if (mode != MODE_FOREGROUND) {
-                    synchronized (mBatchedNoteOpLock) {
-                        NotedOp notedOp = new NotedOp(op, uid, packageName, attributionTag,
-                                virtualDeviceId, message, collectionMode == COLLECT_ASYNC,
-                                shouldCollectMessage);
-
-                        // Batch same noteOp calls and send them with their counters to the system
-                        // service asynchronously. The time window for batching is specified in
-                        // NOTE_OP_BATCHING_DELAY_MILLIS. Always allow the first noteOp call to go
-                        // through binder API. Accumulate subsequent same noteOp calls during the
-                        // time window in mPendingNotedOps.
-                        if (!mPendingNotedOps.containsKey(notedOp)) {
-                            mPendingNotedOps.put(notedOp, 0);
-                        } else {
-                            skipBinderCall = true;
-                            mPendingNotedOps.merge(notedOp, 1, Integer::sum);
-                        }
-
-                        if (!mIsBatchedNoteOpCallScheduled) {
-                            mHandler.postDelayed(() -> {
-                                ArrayMap<NotedOp, Integer> pendingNotedOpsCopy;
-                                synchronized(mBatchedNoteOpLock) {
-                                    mIsBatchedNoteOpCallScheduled = false;
-                                    pendingNotedOpsCopy =
-                                            new ArrayMap<NotedOp, Integer>(mPendingNotedOps);
-                                    mPendingNotedOps.clear();
-                                }
-                                for (int i = pendingNotedOpsCopy.size() - 1; i >= 0; i--) {
-                                    if (pendingNotedOpsCopy.valueAt(i) == 0) {
-                                        pendingNotedOpsCopy.removeAt(i);
-                                    }
-                                }
-                                if (!pendingNotedOpsCopy.isEmpty()) {
-                                    try {
-                                        mService.noteOperationsInBatch(pendingNotedOpsCopy);
-                                    } catch (RemoteException e) {
-                                        throw e.rethrowFromSystemServer();
-                                    }
-                                }
-                            }, NOTE_OP_BATCHING_DELAY_MILLIS);
-
-                            mIsBatchedNoteOpCallScheduled = true;
-                        }
-                    }
-
-                    syncOp = new SyncNotedAppOp(mode, op, attributionTag, packageName);
-                }
-            }
-
-            if (!skipBinderCall) {
-                if (virtualDeviceId == Context.DEVICE_ID_DEFAULT) {
-                    syncOp = mService.noteOperation(op, uid, packageName, attributionTag,
-                            collectionMode == COLLECT_ASYNC, message, shouldCollectMessage);
-                } else {
-                    syncOp = mService.noteOperationForDevice(op, uid, packageName, attributionTag,
-                            virtualDeviceId, collectionMode == COLLECT_ASYNC, message,
-                            shouldCollectMessage);
-                }
+            SyncNotedAppOp syncOp;
+            if (virtualDeviceId == Context.DEVICE_ID_DEFAULT) {
+                syncOp = mService.noteOperation(op, uid, packageName, attributionTag,
+                        collectionMode == COLLECT_ASYNC, message, shouldCollectMessage);
+            } else {
+                syncOp = mService.noteOperationForDevice(op, uid, packageName, attributionTag,
+                    virtualDeviceId, collectionMode == COLLECT_ASYNC, message,
+                    shouldCollectMessage);
             }
-
             if (syncOp.getOpMode() == MODE_ALLOWED) {
                 if (collectionMode == COLLECT_SELF) {
                     collectNotedOpForSelf(syncOp);
diff --git a/core/java/android/app/AppOpsManagerInternal.java b/core/java/android/app/AppOpsManagerInternal.java
index 8b7ea0f8b46a..b21defbcc0e3 100644
--- a/core/java/android/app/AppOpsManagerInternal.java
+++ b/core/java/android/app/AppOpsManagerInternal.java
@@ -29,7 +29,7 @@ import com.android.internal.app.IAppOpsCallback;
 import com.android.internal.util.function.DodecFunction;
 import com.android.internal.util.function.HexConsumer;
 import com.android.internal.util.function.HexFunction;
-import com.android.internal.util.function.NonaFunction;
+import com.android.internal.util.function.OctFunction;
 import com.android.internal.util.function.QuadFunction;
 import com.android.internal.util.function.UndecFunction;
 
@@ -86,9 +86,9 @@ public abstract class AppOpsManagerInternal {
          */
         SyncNotedAppOp noteOperation(int code, int uid, @Nullable String packageName,
                 @Nullable String featureId, int virtualDeviceId, boolean shouldCollectAsyncNotedOp,
-                @Nullable String message, boolean shouldCollectMessage, int notedCount,
-                @NonNull NonaFunction<Integer, Integer, String, String, Integer, Boolean, String,
-                        Boolean, Integer, SyncNotedAppOp> superImpl);
+                @Nullable String message, boolean shouldCollectMessage,
+                @NonNull OctFunction<Integer, Integer, String, String, Integer, Boolean, String,
+                        Boolean, SyncNotedAppOp> superImpl);
 
         /**
          * Allows overriding note proxy operation behavior.
diff --git a/core/java/com/android/internal/app/IAppOpsService.aidl b/core/java/com/android/internal/app/IAppOpsService.aidl
index f01aa80fab4f..2cfc680a3fe8 100644
--- a/core/java/com/android/internal/app/IAppOpsService.aidl
+++ b/core/java/com/android/internal/app/IAppOpsService.aidl
@@ -163,5 +163,4 @@ interface IAppOpsService {
     void finishOperationForDevice(IBinder clientId, int code, int uid, String packageName,
             @nullable String attributionTag, int virtualDeviceId);
    List<AppOpsManager.PackageOps> getPackagesForOpsForDevice(in int[] ops, String persistentDeviceId);
-   oneway void noteOperationsInBatch(in Map batchedNoteOps);
 }
diff --git a/services/core/java/com/android/server/appop/AppOpsService.java b/services/core/java/com/android/server/appop/AppOpsService.java
index 295e0443371d..06c586f5e9c2 100644
--- a/services/core/java/com/android/server/appop/AppOpsService.java
+++ b/services/core/java/com/android/server/appop/AppOpsService.java
@@ -3191,7 +3191,7 @@ public class AppOpsService extends IAppOpsService.Stub {
                     resolveProxyPackageName, proxyAttributionTag, proxyVirtualDeviceId,
                     Process.INVALID_UID, null, null,
                     Context.DEVICE_ID_DEFAULT, proxyFlags, !isProxyTrusted,
-                    "proxy " + message, shouldCollectMessage, 1);
+                    "proxy " + message, shouldCollectMessage);
             if (proxyReturn.getOpMode() != AppOpsManager.MODE_ALLOWED) {
                 return new SyncNotedAppOp(proxyReturn.getOpMode(), code, proxiedAttributionTag,
                         proxiedPackageName);
@@ -3210,20 +3210,7 @@ public class AppOpsService extends IAppOpsService.Stub {
         return noteOperationUnchecked(code, proxiedUid, resolveProxiedPackageName,
                 proxiedAttributionTag, proxiedVirtualDeviceId, proxyUid, resolveProxyPackageName,
                 proxyAttributionTag, proxyVirtualDeviceId, proxiedFlags, shouldCollectAsyncNotedOp,
-                message, shouldCollectMessage, 1);
-    }
-
-    @Override
-    public void noteOperationsInBatch(Map batchedNoteOps) {
-        for (var entry : ((Map<AppOpsManager.NotedOp, Integer>) batchedNoteOps).entrySet()) {
-            AppOpsManager.NotedOp notedOp = entry.getKey();
-            int notedCount = entry.getValue();
-            mCheckOpsDelegateDispatcher.noteOperation(
-                    notedOp.getOp(), notedOp.getUid(), notedOp.getPackageName(),
-                    notedOp.getAttributionTag(), notedOp.getVirtualDeviceId(),
-                    notedOp.getShouldCollectAsyncNotedOp(), notedOp.getMessage(),
-                    notedOp.getShouldCollectMessage(), notedCount);
-        }
+                message, shouldCollectMessage);
     }
 
     @Override
@@ -3241,7 +3228,7 @@ public class AppOpsService extends IAppOpsService.Stub {
         }
         return mCheckOpsDelegateDispatcher.noteOperation(code, uid, packageName,
                 attributionTag, Context.DEVICE_ID_DEFAULT, shouldCollectAsyncNotedOp, message,
-                shouldCollectMessage, 1);
+                shouldCollectMessage);
     }
 
     @Override
@@ -3250,12 +3237,13 @@ public class AppOpsService extends IAppOpsService.Stub {
             String message, boolean shouldCollectMessage) {
         return mCheckOpsDelegateDispatcher.noteOperation(code, uid, packageName,
                 attributionTag, virtualDeviceId, shouldCollectAsyncNotedOp, message,
-                shouldCollectMessage, 1);
+                shouldCollectMessage);
     }
 
     private SyncNotedAppOp noteOperationImpl(int code, int uid, @Nullable String packageName,
-            @Nullable String attributionTag, int virtualDeviceId, boolean shouldCollectAsyncNotedOp,
-            @Nullable String message, boolean shouldCollectMessage, int notedCount) {
+             @Nullable String attributionTag, int virtualDeviceId,
+             boolean shouldCollectAsyncNotedOp, @Nullable String message,
+             boolean shouldCollectMessage) {
         String resolvedPackageName;
         if (!shouldUseNewCheckOp()) {
             verifyIncomingUid(uid);
@@ -3290,14 +3278,14 @@ public class AppOpsService extends IAppOpsService.Stub {
         return noteOperationUnchecked(code, uid, resolvedPackageName, attributionTag,
                 virtualDeviceId, Process.INVALID_UID, null, null,
                 Context.DEVICE_ID_DEFAULT, AppOpsManager.OP_FLAG_SELF, shouldCollectAsyncNotedOp,
-                message, shouldCollectMessage, notedCount);
+                message, shouldCollectMessage);
     }
 
     private SyncNotedAppOp noteOperationUnchecked(int code, int uid, @NonNull String packageName,
             @Nullable String attributionTag, int virtualDeviceId, int proxyUid,
             String proxyPackageName, @Nullable String proxyAttributionTag, int proxyVirtualDeviceId,
             @OpFlags int flags, boolean shouldCollectAsyncNotedOp, @Nullable String message,
-            boolean shouldCollectMessage, int notedCount) {
+            boolean shouldCollectMessage) {
         PackageVerificationResult pvr;
         try {
             pvr = verifyAndGetBypass(uid, packageName, attributionTag, proxyPackageName);
@@ -3400,11 +3388,11 @@ public class AppOpsService extends IAppOpsService.Stub {
                     virtualDeviceId, flags, AppOpsManager.MODE_ALLOWED);
 
             attributedOp.accessed(proxyUid, proxyPackageName, proxyAttributionTag,
-                    getPersistentId(proxyVirtualDeviceId), uidState.getState(), flags, notedCount);
+                    getPersistentId(proxyVirtualDeviceId), uidState.getState(), flags);
 
             if (shouldCollectAsyncNotedOp) {
                 collectAsyncNotedOp(uid, packageName, code, attributionTag, flags, message,
-                        shouldCollectMessage, notedCount);
+                        shouldCollectMessage);
             }
 
             return new SyncNotedAppOp(AppOpsManager.MODE_ALLOWED, code, attributionTag,
@@ -3563,7 +3551,7 @@ public class AppOpsService extends IAppOpsService.Stub {
      */
     private void collectAsyncNotedOp(int uid, @NonNull String packageName, int opCode,
             @Nullable String attributionTag, @OpFlags int flags, @NonNull String message,
-            boolean shouldCollectMessage, int notedCount) {
+            boolean shouldCollectMessage) {
         Objects.requireNonNull(message);
 
         int callingUid = Binder.getCallingUid();
@@ -3571,51 +3559,42 @@ public class AppOpsService extends IAppOpsService.Stub {
         final long token = Binder.clearCallingIdentity();
         try {
             synchronized (this) {
+                Pair<String, Integer> key = getAsyncNotedOpsKey(packageName, uid);
+
+                RemoteCallbackList<IAppOpsAsyncNotedCallback> callbacks = mAsyncOpWatchers.get(key);
+                AsyncNotedAppOp asyncNotedOp = new AsyncNotedAppOp(opCode, callingUid,
+                        attributionTag, message, System.currentTimeMillis());
+                final boolean[] wasNoteForwarded = {false};
+
                 if ((flags & (OP_FLAG_SELF | OP_FLAG_TRUSTED_PROXIED)) != 0
                         && shouldCollectMessage) {
                     reportRuntimeAppOpAccessMessageAsyncLocked(uid, packageName, opCode,
                             attributionTag, message);
                 }
 
-                Pair<String, Integer> key = getAsyncNotedOpsKey(packageName, uid);
-                RemoteCallbackList<IAppOpsAsyncNotedCallback> callbacks = mAsyncOpWatchers.get(key);
-                if (callbacks == null) {
-                    return;
-                }
-
-                final boolean[] wasNoteForwarded = {false};
-                if (Flags.rateLimitBatchedNoteOpAsyncCallbacksEnabled()) {
-                    notedCount = 1;
-                }
-
-                for (int i = 0; i < notedCount; i++) {
-                    AsyncNotedAppOp asyncNotedOp = new AsyncNotedAppOp(opCode, callingUid,
-                            attributionTag, message, System.currentTimeMillis());
-                    wasNoteForwarded[0] = false;
+                if (callbacks != null) {
                     callbacks.broadcast((cb) -> {
                         try {
                             cb.opNoted(asyncNotedOp);
                             wasNoteForwarded[0] = true;
                         } catch (RemoteException e) {
                             Slog.e(TAG,
-                                    "Could not forward noteOp of " + opCode + " to "
-                                            + packageName
+                                    "Could not forward noteOp of " + opCode + " to " + packageName
                                             + "/" + uid + "(" + attributionTag + ")", e);
                         }
                     });
+                }
 
-                    if (!wasNoteForwarded[0]) {
-                        ArrayList<AsyncNotedAppOp> unforwardedOps = mUnforwardedAsyncNotedOps.get(
-                                key);
-                        if (unforwardedOps == null) {
-                            unforwardedOps = new ArrayList<>(1);
-                            mUnforwardedAsyncNotedOps.put(key, unforwardedOps);
-                        }
+                if (!wasNoteForwarded[0]) {
+                    ArrayList<AsyncNotedAppOp> unforwardedOps = mUnforwardedAsyncNotedOps.get(key);
+                    if (unforwardedOps == null) {
+                        unforwardedOps = new ArrayList<>(1);
+                        mUnforwardedAsyncNotedOps.put(key, unforwardedOps);
+                    }
 
-                        unforwardedOps.add(asyncNotedOp);
-                        if (unforwardedOps.size() > MAX_UNFORWARDED_OPS) {
-                            unforwardedOps.remove(0);
-                        }
+                    unforwardedOps.add(asyncNotedOp);
+                    if (unforwardedOps.size() > MAX_UNFORWARDED_OPS) {
+                        unforwardedOps.remove(0);
                     }
                 }
             }
@@ -4047,7 +4026,7 @@ public class AppOpsService extends IAppOpsService.Stub {
 
         if (shouldCollectAsyncNotedOp && !isRestricted) {
             collectAsyncNotedOp(uid, packageName, code, attributionTag, AppOpsManager.OP_FLAG_SELF,
-                    message, shouldCollectMessage, 1);
+                    message, shouldCollectMessage);
         }
 
         return new SyncNotedAppOp(isRestricted ? MODE_IGNORED : MODE_ALLOWED, code, attributionTag,
@@ -7595,36 +7574,34 @@ public class AppOpsService extends IAppOpsService.Stub {
 
         public SyncNotedAppOp noteOperation(int code, int uid, String packageName,
                 String attributionTag, int virtualDeviceId, boolean shouldCollectAsyncNotedOp,
-                String message, boolean shouldCollectMessage, int notedCount) {
+                String message, boolean shouldCollectMessage) {
             if (mPolicy != null) {
                 if (mCheckOpsDelegate != null) {
                     return mPolicy.noteOperation(code, uid, packageName, attributionTag,
                             virtualDeviceId, shouldCollectAsyncNotedOp, message,
-                            shouldCollectMessage, notedCount, this::noteDelegateOperationImpl
+                            shouldCollectMessage, this::noteDelegateOperationImpl
                     );
                 } else {
                     return mPolicy.noteOperation(code, uid, packageName, attributionTag,
                             virtualDeviceId, shouldCollectAsyncNotedOp, message,
-                            shouldCollectMessage, notedCount, AppOpsService.this::noteOperationImpl
+                            shouldCollectMessage, AppOpsService.this::noteOperationImpl
                     );
                 }
             } else if (mCheckOpsDelegate != null) {
                 return noteDelegateOperationImpl(code, uid, packageName, attributionTag,
-                        virtualDeviceId, shouldCollectAsyncNotedOp, message, shouldCollectMessage,
-                        notedCount);
+                        virtualDeviceId, shouldCollectAsyncNotedOp, message, shouldCollectMessage);
             }
             return noteOperationImpl(code, uid, packageName, attributionTag,
-                    virtualDeviceId, shouldCollectAsyncNotedOp, message, shouldCollectMessage,
-                    notedCount);
+                    virtualDeviceId, shouldCollectAsyncNotedOp, message, shouldCollectMessage);
         }
 
         private SyncNotedAppOp noteDelegateOperationImpl(int code, int uid,
                 @Nullable String packageName, @Nullable String featureId, int virtualDeviceId,
                 boolean shouldCollectAsyncNotedOp, @Nullable String message,
-                boolean shouldCollectMessage, int notedCount) {
+                boolean shouldCollectMessage) {
             return mCheckOpsDelegate.noteOperation(code, uid, packageName, featureId,
                     virtualDeviceId, shouldCollectAsyncNotedOp, message, shouldCollectMessage,
-                    notedCount, AppOpsService.this::noteOperationImpl
+                    AppOpsService.this::noteOperationImpl
             );
         }
 
diff --git a/services/core/java/com/android/server/appop/AttributedOp.java b/services/core/java/com/android/server/appop/AttributedOp.java
index 4d114b4ad4ac..314664b0a79d 100644
--- a/services/core/java/com/android/server/appop/AttributedOp.java
+++ b/services/core/java/com/android/server/appop/AttributedOp.java
@@ -100,12 +100,10 @@ final class AttributedOp {
      * @param proxyDeviceId       The device Id of the proxy
      * @param uidState            UID state of the app noteOp/startOp was called for
      * @param flags               OpFlags of the call
-     * @param accessCount         The number of times the op is accessed
      */
     public void accessed(int proxyUid, @Nullable String proxyPackageName,
             @Nullable String proxyAttributionTag, @Nullable String proxyDeviceId,
-            @AppOpsManager.UidState int uidState, @AppOpsManager.OpFlags int flags,
-            int accessCount) {
+            @AppOpsManager.UidState int uidState, @AppOpsManager.OpFlags int flags) {
         long accessTime = System.currentTimeMillis();
         accessed(accessTime, -1, proxyUid, proxyPackageName, proxyAttributionTag, proxyDeviceId,
                 uidState, flags);
@@ -113,7 +111,7 @@ final class AttributedOp {
         mAppOpsService.mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
                 parent.packageName, persistentDeviceId, tag, uidState, flags, accessTime,
                 AppOpsManager.ATTRIBUTION_FLAGS_NONE, AppOpsManager.ATTRIBUTION_CHAIN_ID_NONE,
-                DiscreteRegistry.ACCESS_TYPE_NOTE_OP, accessCount);
+                DiscreteRegistry.ACCESS_TYPE_NOTE_OP);
     }
 
     /**
@@ -257,7 +255,7 @@ final class AttributedOp {
         if (isStarted) {
             mAppOpsService.mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
                     parent.packageName, persistentDeviceId, tag, uidState, flags, startTime,
-                    attributionFlags, attributionChainId, DiscreteRegistry.ACCESS_TYPE_START_OP, 1);
+                    attributionFlags, attributionChainId, DiscreteRegistry.ACCESS_TYPE_START_OP);
         }
     }
 
@@ -453,7 +451,7 @@ final class AttributedOp {
             mAppOpsService.mHistoricalRegistry.incrementOpAccessedCount(parent.op, parent.uid,
                     parent.packageName, persistentDeviceId, tag, event.getUidState(),
                     event.getFlags(), startTime, event.getAttributionFlags(),
-                    event.getAttributionChainId(), DiscreteRegistry.ACCESS_TYPE_RESUME_OP, 1);
+                    event.getAttributionChainId(), DiscreteRegistry.ACCESS_TYPE_RESUME_OP);
             if (shouldSendActive) {
                 mAppOpsService.scheduleOpActiveChangedIfNeededLocked(parent.op, parent.uid,
                         parent.packageName, tag, event.getVirtualDeviceId(), true,
diff --git a/services/core/java/com/android/server/appop/HistoricalRegistry.java b/services/core/java/com/android/server/appop/HistoricalRegistry.java
index 5e67f26ba1f6..6b0253864e2b 100644
--- a/services/core/java/com/android/server/appop/HistoricalRegistry.java
+++ b/services/core/java/com/android/server/appop/HistoricalRegistry.java
@@ -475,7 +475,7 @@ final class HistoricalRegistry {
             @NonNull String deviceId, @Nullable String attributionTag, @UidState int uidState,
             @OpFlags int flags, long accessTime,
             @AppOpsManager.AttributionFlags int attributionFlags, int attributionChainId,
-            @DiscreteRegistry.AccessType int accessType, int accessCount) {
+            @DiscreteRegistry.AccessType int accessType) {
         synchronized (mInMemoryLock) {
             if (mMode == AppOpsManager.HISTORICAL_MODE_ENABLED_ACTIVE) {
                 if (!isPersistenceInitializedMLocked()) {
@@ -484,7 +484,7 @@ final class HistoricalRegistry {
                 }
                 getUpdatedPendingHistoricalOpsMLocked(
                         System.currentTimeMillis()).increaseAccessCount(op, uid, packageName,
-                        attributionTag, uidState, flags, accessCount);
+                        attributionTag, uidState, flags, 1);
 
                 mDiscreteRegistry.recordDiscreteAccess(uid, packageName, deviceId, op,
                         attributionTag, flags, uidState, accessTime, -1, attributionFlags,
diff --git a/services/core/java/com/android/server/pm/permission/AccessCheckDelegate.java b/services/core/java/com/android/server/pm/permission/AccessCheckDelegate.java
index e989d6875d15..e9cb279439a6 100644
--- a/services/core/java/com/android/server/pm/permission/AccessCheckDelegate.java
+++ b/services/core/java/com/android/server/pm/permission/AccessCheckDelegate.java
@@ -40,7 +40,7 @@ import com.android.internal.util.ArrayUtils;
 import com.android.internal.util.function.DodecFunction;
 import com.android.internal.util.function.HexConsumer;
 import com.android.internal.util.function.HexFunction;
-import com.android.internal.util.function.NonaFunction;
+import com.android.internal.util.function.OctFunction;
 import com.android.internal.util.function.QuadFunction;
 import com.android.internal.util.function.TriFunction;
 import com.android.internal.util.function.UndecFunction;
@@ -351,22 +351,22 @@ public interface AccessCheckDelegate extends CheckPermissionDelegate, CheckOpsDe
         @Override
         public SyncNotedAppOp noteOperation(int code, int uid, @Nullable String packageName,
                 @Nullable String featureId, int virtualDeviceId, boolean shouldCollectAsyncNotedOp,
-                @Nullable String message, boolean shouldCollectMessage, int notedCount,
-                @NonNull NonaFunction<Integer, Integer, String, String, Integer, Boolean, String,
-                                        Boolean, Integer, SyncNotedAppOp> superImpl) {
+                @Nullable String message, boolean shouldCollectMessage,
+                @NonNull OctFunction<Integer, Integer, String, String, Integer, Boolean, String,
+                        Boolean, SyncNotedAppOp> superImpl) {
             if (uid == mDelegateAndOwnerUid && isDelegateOp(code)) {
                 final int shellUid = UserHandle.getUid(UserHandle.getUserId(uid),
                         Process.SHELL_UID);
                 final long identity = Binder.clearCallingIdentity();
                 try {
                     return superImpl.apply(code, shellUid, SHELL_PKG, featureId, virtualDeviceId,
-                            shouldCollectAsyncNotedOp, message, shouldCollectMessage, notedCount);
+                            shouldCollectAsyncNotedOp, message, shouldCollectMessage);
                 } finally {
                     Binder.restoreCallingIdentity(identity);
                 }
             }
             return superImpl.apply(code, uid, packageName, featureId, virtualDeviceId,
-                    shouldCollectAsyncNotedOp, message, shouldCollectMessage, notedCount);
+                    shouldCollectAsyncNotedOp, message, shouldCollectMessage);
         }
 
         @Override
diff --git a/services/core/java/com/android/server/policy/AppOpsPolicy.java b/services/core/java/com/android/server/policy/AppOpsPolicy.java
index 33210e28281e..ecffd382f542 100644
--- a/services/core/java/com/android/server/policy/AppOpsPolicy.java
+++ b/services/core/java/com/android/server/policy/AppOpsPolicy.java
@@ -53,7 +53,7 @@ import com.android.internal.annotations.GuardedBy;
 import com.android.internal.util.function.DodecFunction;
 import com.android.internal.util.function.HexConsumer;
 import com.android.internal.util.function.HexFunction;
-import com.android.internal.util.function.NonaFunction;
+import com.android.internal.util.function.OctFunction;
 import com.android.internal.util.function.QuadFunction;
 import com.android.internal.util.function.UndecFunction;
 import com.android.server.LocalServices;
@@ -246,12 +246,11 @@ public final class AppOpsPolicy implements AppOpsManagerInternal.CheckOpsDelegat
     public SyncNotedAppOp noteOperation(int code, int uid, @Nullable String packageName,
             @Nullable String attributionTag, int virtualDeviceId,
             boolean shouldCollectAsyncNotedOp, @Nullable String message,
-            boolean shouldCollectMessage, int notedCount,
-            @NonNull NonaFunction<Integer, Integer, String, String,
-                    Integer, Boolean, String, Boolean, Integer, SyncNotedAppOp> superImpl) {
+            boolean shouldCollectMessage, @NonNull OctFunction<Integer, Integer, String, String,
+                    Integer, Boolean, String, Boolean, SyncNotedAppOp> superImpl) {
         return superImpl.apply(resolveDatasourceOp(code, uid, packageName, attributionTag),
                 resolveUid(code, uid), packageName, attributionTag, virtualDeviceId,
-                shouldCollectAsyncNotedOp, message, shouldCollectMessage, notedCount);
+                shouldCollectAsyncNotedOp, message, shouldCollectMessage);
     }
 
     @Override