From d34e0e61f195f888d1c3c760e08816b22f7856c5 Mon Sep 17 00:00:00 2001 From: Evan Severson Date: Tue, 13 Dec 2022 13:17:38 -0800 Subject: Move most of appops service code back into main class This is effectively a revert of 313162bfc6dd and 8fb6ff27de7b Test: atest -p frameworks/base/services/core/java/com/android/server/appop Bug: 256730492 Fixes: 261186662 Fixes: 261155210 Change-Id: If328baaca57f846455f9592a76d2c7a1cf8f5ee6 --- .../com/android/server/permission/access/AccessCheckingService.kt | 6 +++--- .../java/com/android/server/permission/access/appop/AppOpService.kt | 4 ++-- 2 files changed, 5 insertions(+), 5 deletions(-) (limited to 'services/permission/java') diff --git a/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt b/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt index 73c2cccc550d..45837e2cdeb3 100644 --- a/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt +++ b/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt @@ -21,9 +21,9 @@ import com.android.internal.annotations.Keep import com.android.server.LocalManagerRegistry import com.android.server.LocalServices import com.android.server.SystemService -import com.android.server.appop.AppOpsCheckingServiceInterface +import com.android.server.appop.AppOpsServiceInterface import com.android.server.permission.access.appop.AppOpService -import com.android.server.permission.access.collection.* // ktlint-disable no-wildcard-imports +import com.android.server.permission.access.collection.IntSet import com.android.server.permission.access.permission.PermissionService import com.android.server.pm.PackageManagerLocal import com.android.server.pm.UserManagerService @@ -51,7 +51,7 @@ class AccessCheckingService(context: Context) : SystemService(context) { appOpService = AppOpService(this) permissionService = PermissionService(this) - LocalServices.addService(AppOpsCheckingServiceInterface::class.java, appOpService) + LocalServices.addService(AppOpsServiceInterface::class.java, appOpService) LocalServices.addService(PermissionManagerServiceInterface::class.java, permissionService) } diff --git a/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt b/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt index b8d6aa3b4e49..f606f86281ea 100644 --- a/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt +++ b/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt @@ -19,14 +19,14 @@ package com.android.server.permission.access.appop import android.util.ArraySet import android.util.SparseBooleanArray import android.util.SparseIntArray -import com.android.server.appop.AppOpsCheckingServiceInterface +import com.android.server.appop.AppOpsServiceInterface import com.android.server.appop.OnOpModeChangedListener import com.android.server.permission.access.AccessCheckingService import java.io.PrintWriter class AppOpService( private val service: AccessCheckingService -) : AppOpsCheckingServiceInterface { +) : AppOpsServiceInterface { fun initialize() { TODO("Not yet implemented") } -- cgit v1.2.3-59-g8ed1b From 7bb6fbcb7c7707a1c22ab5eac3e160ca99940962 Mon Sep 17 00:00:00 2001 From: Evan Severson Date: Tue, 13 Dec 2022 15:35:14 -0800 Subject: Rename AppOpsServiceInterface to AppOpsCheckingServiceInterface Test: Build Bug: 256730492 Change-Id: I30a3323d7a6be34ddc5175515c8824192b64ee7f --- .../server/appop/AppOpsCheckingServiceImpl.java | 601 +++++++++++++++++++++ .../appop/AppOpsCheckingServiceInterface.java | 209 +++++++ .../server/appop/AppOpsRestrictionsImpl.java | 8 +- .../com/android/server/appop/AppOpsService.java | 75 +-- .../server/appop/AppOpsServiceInterface.java | 209 ------- .../appop/LegacyAppOpsServiceInterfaceImpl.java | 601 --------------------- .../permission/access/AccessCheckingService.kt | 4 +- .../server/permission/access/appop/AppOpService.kt | 4 +- .../server/appop/AppOpsLegacyRestrictionsTest.java | 2 +- 9 files changed, 857 insertions(+), 856 deletions(-) create mode 100644 services/core/java/com/android/server/appop/AppOpsCheckingServiceImpl.java create mode 100644 services/core/java/com/android/server/appop/AppOpsCheckingServiceInterface.java delete mode 100644 services/core/java/com/android/server/appop/AppOpsServiceInterface.java delete mode 100644 services/core/java/com/android/server/appop/LegacyAppOpsServiceInterfaceImpl.java (limited to 'services/permission/java') diff --git a/services/core/java/com/android/server/appop/AppOpsCheckingServiceImpl.java b/services/core/java/com/android/server/appop/AppOpsCheckingServiceImpl.java new file mode 100644 index 000000000000..ac25f4edfdb7 --- /dev/null +++ b/services/core/java/com/android/server/appop/AppOpsCheckingServiceImpl.java @@ -0,0 +1,601 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ + +package com.android.server.appop; + +import static android.app.AppOpsManager.OP_NONE; +import static android.app.AppOpsManager.WATCH_FOREGROUND_CHANGES; +import static android.app.AppOpsManager.opRestrictsRead; + +import static com.android.server.appop.AppOpsService.ModeCallback.ALL_OPS; + +import android.Manifest; +import android.annotation.NonNull; +import android.annotation.Nullable; +import android.annotation.UserIdInt; +import android.app.AppGlobals; +import android.app.AppOpsManager; +import android.app.AppOpsManager.Mode; +import android.content.Context; +import android.content.pm.PackageManager; +import android.os.Binder; +import android.os.Handler; +import android.os.RemoteException; +import android.os.UserHandle; +import android.util.ArrayMap; +import android.util.ArraySet; +import android.util.SparseArray; +import android.util.SparseBooleanArray; +import android.util.SparseIntArray; + +import com.android.internal.annotations.GuardedBy; +import com.android.internal.annotations.VisibleForTesting; +import com.android.internal.util.function.pooled.PooledLambda; + +import libcore.util.EmptyArray; + +import java.io.PrintWriter; +import java.util.Collections; +import java.util.Objects; + + +/** + * Legacy implementation for App-ops service's app-op mode (uid and package) storage and access. + * In the future this class will also include mode callbacks and op restrictions. + */ +public class AppOpsCheckingServiceImpl implements AppOpsCheckingServiceInterface { + + static final String TAG = "LegacyAppOpsServiceInterfaceImpl"; + + // Must be the same object that the AppOpsService is using for locking. + final Object mLock; + final Handler mHandler; + final Context mContext; + final SparseArray mSwitchedOps; + + @GuardedBy("mLock") + @VisibleForTesting + final SparseArray mUidModes = new SparseArray<>(); + + @GuardedBy("mLock") + final SparseArray> mUserPackageModes = new SparseArray<>(); + + final SparseArray> mOpModeWatchers = new SparseArray<>(); + final ArrayMap> mPackageModeWatchers = + new ArrayMap<>(); + + final PersistenceScheduler mPersistenceScheduler; + + + // Constant meaning that any UID should be matched when dispatching callbacks + private static final int UID_ANY = -2; + + + AppOpsCheckingServiceImpl(PersistenceScheduler persistenceScheduler, + @NonNull Object lock, Handler handler, Context context, + SparseArray switchedOps) { + this.mPersistenceScheduler = persistenceScheduler; + this.mLock = lock; + this.mHandler = handler; + this.mContext = context; + this.mSwitchedOps = switchedOps; + } + + @Override + public SparseIntArray getNonDefaultUidModes(int uid) { + synchronized (mLock) { + SparseIntArray opModes = mUidModes.get(uid, null); + if (opModes == null) { + return new SparseIntArray(); + } + return opModes.clone(); + } + } + + @Override + public int getUidMode(int uid, int op) { + synchronized (mLock) { + SparseIntArray opModes = mUidModes.get(uid, null); + if (opModes == null) { + return AppOpsManager.opToDefaultMode(op); + } + return opModes.get(op, AppOpsManager.opToDefaultMode(op)); + } + } + + @Override + public boolean setUidMode(int uid, int op, int mode) { + final int defaultMode = AppOpsManager.opToDefaultMode(op); + synchronized (mLock) { + SparseIntArray opModes = mUidModes.get(uid, null); + if (opModes == null) { + if (mode != defaultMode) { + opModes = new SparseIntArray(); + mUidModes.put(uid, opModes); + opModes.put(op, mode); + mPersistenceScheduler.scheduleWriteLocked(); + } + } else { + if (opModes.indexOfKey(op) >= 0 && opModes.get(op) == mode) { + return false; + } + if (mode == defaultMode) { + opModes.delete(op); + if (opModes.size() <= 0) { + opModes = null; + mUidModes.delete(uid); + } + } else { + opModes.put(op, mode); + } + mPersistenceScheduler.scheduleWriteLocked(); + } + } + return true; + } + + @Override + public int getPackageMode(String packageName, int op, @UserIdInt int userId) { + synchronized (mLock) { + ArrayMap packageModes = mUserPackageModes.get(userId, null); + if (packageModes == null) { + return AppOpsManager.opToDefaultMode(op); + } + SparseIntArray opModes = packageModes.getOrDefault(packageName, null); + if (opModes == null) { + return AppOpsManager.opToDefaultMode(op); + } + return opModes.get(op, AppOpsManager.opToDefaultMode(op)); + } + } + + @Override + public void setPackageMode(String packageName, int op, @Mode int mode, @UserIdInt int userId) { + final int defaultMode = AppOpsManager.opToDefaultMode(op); + synchronized (mLock) { + ArrayMap packageModes = mUserPackageModes.get(userId, null); + if (packageModes == null) { + packageModes = new ArrayMap<>(); + mUserPackageModes.put(userId, packageModes); + } + SparseIntArray opModes = packageModes.get(packageName); + if (opModes == null) { + if (mode != defaultMode) { + opModes = new SparseIntArray(); + packageModes.put(packageName, opModes); + opModes.put(op, mode); + mPersistenceScheduler.scheduleWriteLocked(); + } + } else { + if (opModes.indexOfKey(op) >= 0 && opModes.get(op) == mode) { + return; + } + if (mode == defaultMode) { + opModes.delete(op); + if (opModes.size() <= 0) { + opModes = null; + packageModes.remove(packageName); + } + } else { + opModes.put(op, mode); + } + mPersistenceScheduler.scheduleWriteLocked(); + } + } + } + + @Override + public void removeUid(int uid) { + synchronized (mLock) { + SparseIntArray opModes = mUidModes.get(uid); + if (opModes == null) { + return; + } + mUidModes.remove(uid); + mPersistenceScheduler.scheduleFastWriteLocked(); + } + } + + @Override + public boolean areUidModesDefault(int uid) { + synchronized (mLock) { + SparseIntArray opModes = mUidModes.get(uid); + return (opModes == null || opModes.size() <= 0); + } + } + + @Override + public boolean arePackageModesDefault(String packageMode, @UserIdInt int userId) { + synchronized (mLock) { + ArrayMap packageModes = mUserPackageModes.get(userId, null); + if (packageModes == null) { + return true; + } + SparseIntArray opModes = packageModes.get(packageMode); + return (opModes == null || opModes.size() <= 0); + } + } + + @Override + public boolean removePackage(String packageName, @UserIdInt int userId) { + synchronized (mLock) { + ArrayMap packageModes = mUserPackageModes.get(userId, null); + if (packageModes == null) { + return false; + } + SparseIntArray ops = packageModes.remove(packageName); + if (ops != null) { + mPersistenceScheduler.scheduleFastWriteLocked(); + return true; + } + return false; + } + } + + @Override + public void clearAllModes() { + synchronized (mLock) { + mUidModes.clear(); + mUserPackageModes.clear(); + } + } + + @Override + public void startWatchingOpModeChanged(@NonNull OnOpModeChangedListener changedListener, + int op) { + Objects.requireNonNull(changedListener); + synchronized (mLock) { + ArraySet modeWatcherSet = mOpModeWatchers.get(op); + if (modeWatcherSet == null) { + modeWatcherSet = new ArraySet<>(); + mOpModeWatchers.put(op, modeWatcherSet); + } + modeWatcherSet.add(changedListener); + } + } + + @Override + public void startWatchingPackageModeChanged(@NonNull OnOpModeChangedListener changedListener, + @NonNull String packageName) { + Objects.requireNonNull(changedListener); + Objects.requireNonNull(packageName); + synchronized (mLock) { + ArraySet modeWatcherSet = + mPackageModeWatchers.get(packageName); + if (modeWatcherSet == null) { + modeWatcherSet = new ArraySet<>(); + mPackageModeWatchers.put(packageName, modeWatcherSet); + } + modeWatcherSet.add(changedListener); + } + } + + @Override + public void removeListener(@NonNull OnOpModeChangedListener changedListener) { + Objects.requireNonNull(changedListener); + + synchronized (mLock) { + for (int i = mOpModeWatchers.size() - 1; i >= 0; i--) { + ArraySet cbs = mOpModeWatchers.valueAt(i); + cbs.remove(changedListener); + if (cbs.size() <= 0) { + mOpModeWatchers.removeAt(i); + } + } + + for (int i = mPackageModeWatchers.size() - 1; i >= 0; i--) { + ArraySet cbs = mPackageModeWatchers.valueAt(i); + cbs.remove(changedListener); + if (cbs.size() <= 0) { + mPackageModeWatchers.removeAt(i); + } + } + } + } + + @Override + public ArraySet getOpModeChangedListeners(int op) { + synchronized (mLock) { + ArraySet modeChangedListenersSet = mOpModeWatchers.get(op); + if (modeChangedListenersSet == null) { + return new ArraySet<>(); + } + return new ArraySet<>(modeChangedListenersSet); + } + } + + @Override + public ArraySet getPackageModeChangedListeners( + @NonNull String packageName) { + Objects.requireNonNull(packageName); + + synchronized (mLock) { + ArraySet modeChangedListenersSet = + mPackageModeWatchers.get(packageName); + if (modeChangedListenersSet == null) { + return new ArraySet<>(); + } + return new ArraySet<>(modeChangedListenersSet); + } + } + + @Override + public void notifyWatchersOfChange(int code, int uid) { + ArraySet listenerSet = getOpModeChangedListeners(code); + if (listenerSet == null) { + return; + } + for (int i = 0; i < listenerSet.size(); i++) { + final OnOpModeChangedListener listener = listenerSet.valueAt(i); + notifyOpChanged(listener, code, uid, null); + } + } + + @Override + public void notifyOpChanged(@NonNull OnOpModeChangedListener onModeChangedListener, int code, + int uid, @Nullable String packageName) { + Objects.requireNonNull(onModeChangedListener); + + if (uid != UID_ANY && onModeChangedListener.getWatchingUid() >= 0 + && onModeChangedListener.getWatchingUid() != uid) { + return; + } + + // See CALL_BACK_ON_CHANGED_LISTENER_WITH_SWITCHED_OP_CHANGE + int[] switchedCodes; + if (onModeChangedListener.getWatchedOpCode() == ALL_OPS) { + switchedCodes = mSwitchedOps.get(code); + } else if (onModeChangedListener.getWatchedOpCode() == OP_NONE) { + switchedCodes = new int[]{code}; + } else { + switchedCodes = new int[]{onModeChangedListener.getWatchedOpCode()}; + } + + for (int switchedCode : switchedCodes) { + // There are features watching for mode changes such as window manager + // and location manager which are in our process. The callbacks in these + // features may require permissions our remote caller does not have. + final long identity = Binder.clearCallingIdentity(); + try { + if (shouldIgnoreCallback(switchedCode, onModeChangedListener.getCallingPid(), + onModeChangedListener.getCallingUid())) { + continue; + } + onModeChangedListener.onOpModeChanged(switchedCode, uid, packageName); + } catch (RemoteException e) { + /* ignore */ + } finally { + Binder.restoreCallingIdentity(identity); + } + } + } + + private boolean shouldIgnoreCallback(int op, int watcherPid, int watcherUid) { + // If it's a restricted read op, ignore it if watcher doesn't have manage ops permission, + // as watcher should not use this to signal if the value is changed. + return opRestrictsRead(op) && mContext.checkPermission(Manifest.permission.MANAGE_APPOPS, + watcherPid, watcherUid) != PackageManager.PERMISSION_GRANTED; + } + + @Override + public void notifyOpChangedForAllPkgsInUid(int code, int uid, boolean onlyForeground, + @Nullable OnOpModeChangedListener callbackToIgnore) { + String[] uidPackageNames = getPackagesForUid(uid); + ArrayMap> callbackSpecs = null; + + synchronized (mLock) { + ArraySet callbacks = mOpModeWatchers.get(code); + if (callbacks != null) { + final int callbackCount = callbacks.size(); + for (int i = 0; i < callbackCount; i++) { + OnOpModeChangedListener callback = callbacks.valueAt(i); + + if (onlyForeground && (callback.getFlags() + & WATCH_FOREGROUND_CHANGES) == 0) { + continue; + } + + ArraySet changedPackages = new ArraySet<>(); + Collections.addAll(changedPackages, uidPackageNames); + if (callbackSpecs == null) { + callbackSpecs = new ArrayMap<>(); + } + callbackSpecs.put(callback, changedPackages); + } + } + + for (String uidPackageName : uidPackageNames) { + callbacks = mPackageModeWatchers.get(uidPackageName); + if (callbacks != null) { + if (callbackSpecs == null) { + callbackSpecs = new ArrayMap<>(); + } + final int callbackCount = callbacks.size(); + for (int i = 0; i < callbackCount; i++) { + OnOpModeChangedListener callback = callbacks.valueAt(i); + + if (onlyForeground && (callback.getFlags() + & WATCH_FOREGROUND_CHANGES) == 0) { + continue; + } + + ArraySet changedPackages = callbackSpecs.get(callback); + if (changedPackages == null) { + changedPackages = new ArraySet<>(); + callbackSpecs.put(callback, changedPackages); + } + changedPackages.add(uidPackageName); + } + } + } + + if (callbackSpecs != null && callbackToIgnore != null) { + callbackSpecs.remove(callbackToIgnore); + } + } + + if (callbackSpecs == null) { + return; + } + + for (int i = 0; i < callbackSpecs.size(); i++) { + final OnOpModeChangedListener callback = callbackSpecs.keyAt(i); + final ArraySet reportedPackageNames = callbackSpecs.valueAt(i); + if (reportedPackageNames == null) { + mHandler.sendMessage(PooledLambda.obtainMessage( + AppOpsCheckingServiceImpl::notifyOpChanged, + this, callback, code, uid, (String) null)); + + } else { + final int reportedPackageCount = reportedPackageNames.size(); + for (int j = 0; j < reportedPackageCount; j++) { + final String reportedPackageName = reportedPackageNames.valueAt(j); + mHandler.sendMessage(PooledLambda.obtainMessage( + AppOpsCheckingServiceImpl::notifyOpChanged, + this, callback, code, uid, reportedPackageName)); + } + } + } + } + + private static String[] getPackagesForUid(int uid) { + String[] packageNames = null; + + // Very early during boot the package manager is not yet or not yet fully started. At this + // time there are no packages yet. + if (AppGlobals.getPackageManager() != null) { + try { + packageNames = AppGlobals.getPackageManager().getPackagesForUid(uid); + } catch (RemoteException e) { + /* ignore - local call */ + } + } + if (packageNames == null) { + return EmptyArray.STRING; + } + return packageNames; + } + + @Override + public SparseBooleanArray evalForegroundUidOps(int uid, SparseBooleanArray foregroundOps) { + synchronized (mLock) { + return evalForegroundOps(mUidModes.get(uid), foregroundOps); + } + } + + @Override + public SparseBooleanArray evalForegroundPackageOps(String packageName, + SparseBooleanArray foregroundOps, @UserIdInt int userId) { + synchronized (mLock) { + ArrayMap packageModes = mUserPackageModes.get(userId, null); + return evalForegroundOps(packageModes == null ? null : packageModes.get(packageName), + foregroundOps); + } + } + + private SparseBooleanArray evalForegroundOps(SparseIntArray opModes, + SparseBooleanArray foregroundOps) { + SparseBooleanArray tempForegroundOps = foregroundOps; + if (opModes != null) { + for (int i = opModes.size() - 1; i >= 0; i--) { + if (opModes.valueAt(i) == AppOpsManager.MODE_FOREGROUND) { + if (tempForegroundOps == null) { + tempForegroundOps = new SparseBooleanArray(); + } + evalForegroundWatchers(opModes.keyAt(i), tempForegroundOps); + } + } + } + return tempForegroundOps; + } + + private void evalForegroundWatchers(int op, SparseBooleanArray foregroundOps) { + boolean curValue = foregroundOps.get(op, false); + ArraySet listenerSet = mOpModeWatchers.get(op); + if (listenerSet != null) { + for (int cbi = listenerSet.size() - 1; !curValue && cbi >= 0; cbi--) { + if ((listenerSet.valueAt(cbi).getFlags() + & AppOpsManager.WATCH_FOREGROUND_CHANGES) != 0) { + curValue = true; + } + } + } + foregroundOps.put(op, curValue); + } + + @Override + public boolean dumpListeners(int dumpOp, int dumpUid, String dumpPackage, + PrintWriter printWriter) { + boolean needSep = false; + if (mOpModeWatchers.size() > 0) { + boolean printedHeader = false; + for (int i = 0; i < mOpModeWatchers.size(); i++) { + if (dumpOp >= 0 && dumpOp != mOpModeWatchers.keyAt(i)) { + continue; + } + boolean printedOpHeader = false; + ArraySet modeChangedListenerSet = + mOpModeWatchers.valueAt(i); + for (int j = 0; j < modeChangedListenerSet.size(); j++) { + final OnOpModeChangedListener listener = modeChangedListenerSet.valueAt(j); + if (dumpPackage != null + && dumpUid != UserHandle.getAppId(listener.getWatchingUid())) { + continue; + } + needSep = true; + if (!printedHeader) { + printWriter.println(" Op mode watchers:"); + printedHeader = true; + } + if (!printedOpHeader) { + printWriter.print(" Op "); + printWriter.print(AppOpsManager.opToName(mOpModeWatchers.keyAt(i))); + printWriter.println(":"); + printedOpHeader = true; + } + printWriter.print(" #"); printWriter.print(j); printWriter.print(": "); + printWriter.println(listener.toString()); + } + } + } + + if (mPackageModeWatchers.size() > 0 && dumpOp < 0) { + boolean printedHeader = false; + for (int i = 0; i < mPackageModeWatchers.size(); i++) { + if (dumpPackage != null + && !dumpPackage.equals(mPackageModeWatchers.keyAt(i))) { + continue; + } + needSep = true; + if (!printedHeader) { + printWriter.println(" Package mode watchers:"); + printedHeader = true; + } + printWriter.print(" Pkg "); printWriter.print(mPackageModeWatchers.keyAt(i)); + printWriter.println(":"); + ArraySet modeChangedListenerSet = + mPackageModeWatchers.valueAt(i); + + for (int j = 0; j < modeChangedListenerSet.size(); j++) { + printWriter.print(" #"); printWriter.print(j); printWriter.print(": "); + printWriter.println(modeChangedListenerSet.valueAt(j).toString()); + } + } + } + return needSep; + } + +} \ No newline at end of file diff --git a/services/core/java/com/android/server/appop/AppOpsCheckingServiceInterface.java b/services/core/java/com/android/server/appop/AppOpsCheckingServiceInterface.java new file mode 100644 index 000000000000..d8d0d48965ea --- /dev/null +++ b/services/core/java/com/android/server/appop/AppOpsCheckingServiceInterface.java @@ -0,0 +1,209 @@ +/* + * Copyright (C) 2022 The Android Open Source Project + * + * Licensed under the Apache License, Version 2.0 (the "License"); + * you may not use this file except in compliance with the License. + * You may obtain a copy of the License at + * + * http://www.apache.org/licenses/LICENSE-2.0 + * + * Unless required by applicable law or agreed to in writing, software + * distributed under the License is distributed on an "AS IS" BASIS, + * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + * See the License for the specific language governing permissions and + * limitations under the License. + */ +package com.android.server.appop; + +import android.annotation.NonNull; +import android.annotation.Nullable; +import android.annotation.UserIdInt; +import android.app.AppOpsManager.Mode; +import android.util.ArraySet; +import android.util.SparseBooleanArray; +import android.util.SparseIntArray; + +import java.io.PrintWriter; + +/** + * Interface for accessing and modifying modes for app-ops i.e. package and uid modes. + * This interface also includes functions for added and removing op mode watchers. + * In the future this interface will also include op restrictions. + */ +public interface AppOpsCheckingServiceInterface { + /** + * Returns a copy of non-default app-ops with op as keys and their modes as values for a uid. + * Returns an empty SparseIntArray if nothing is set. + * @param uid for which we need the app-ops and their modes. + */ + SparseIntArray getNonDefaultUidModes(int uid); + + /** + * Returns the app-op mode for a particular app-op of a uid. + * Returns default op mode if the op mode for particular uid and op is not set. + * @param uid user id for which we need the mode. + * @param op app-op for which we need the mode. + * @return mode of the app-op. + */ + int getUidMode(int uid, int op); + + /** + * Set the app-op mode for a particular uid and op. + * The mode is not set if the mode is the same as the default mode for the op. + * @param uid user id for which we want to set the mode. + * @param op app-op for which we want to set the mode. + * @param mode mode for the app-op. + * @return true if op mode is changed. + */ + boolean setUidMode(int uid, int op, @Mode int mode); + + /** + * Gets the app-op mode for a particular package. + * Returns default op mode if the op mode for the particular package is not set. + * @param packageName package name for which we need the op mode. + * @param op app-op for which we need the mode. + * @param userId user id associated with the package. + * @return the mode of the app-op. + */ + int getPackageMode(@NonNull String packageName, int op, @UserIdInt int userId); + + /** + * Sets the app-op mode for a particular package. + * @param packageName package name for which we need to set the op mode. + * @param op app-op for which we need to set the mode. + * @param mode the mode of the app-op. + * @param userId user id associated with the package. + * + */ + void setPackageMode(@NonNull String packageName, int op, @Mode int mode, @UserIdInt int userId); + + /** + * Stop tracking any app-op modes for a package. + * @param packageName Name of the package for which we want to remove all mode tracking. + * @param userId user id associated with the package. + */ + boolean removePackage(@NonNull String packageName, @UserIdInt int userId); + + /** + * Stop tracking any app-op modes for this uid. + * @param uid user id for which we want to remove all tracking. + */ + void removeUid(int uid); + + /** + * Returns true if all uid modes for this uid are + * in default state. + * @param uid user id + */ + boolean areUidModesDefault(int uid); + + /** + * Returns true if all package modes for this package name are + * in default state. + * @param packageName package name. + * @param userId user id associated with the package. + */ + boolean arePackageModesDefault(String packageName, @UserIdInt int userId); + + /** + * Stop tracking app-op modes for all uid and packages. + */ + void clearAllModes(); + + /** + * Registers changedListener to listen to op's mode change. + * @param changedListener the listener that must be trigger on the op's mode change. + * @param op op representing the app-op whose mode change needs to be listened to. + */ + void startWatchingOpModeChanged(@NonNull OnOpModeChangedListener changedListener, int op); + + /** + * Registers changedListener to listen to package's app-op's mode change. + * @param changedListener the listener that must be trigger on the mode change. + * @param packageName of the package whose app-op's mode change needs to be listened to. + */ + void startWatchingPackageModeChanged(@NonNull OnOpModeChangedListener changedListener, + @NonNull String packageName); + + /** + * Stop the changedListener from triggering on any mode change. + * @param changedListener the listener that needs to be removed. + */ + void removeListener(@NonNull OnOpModeChangedListener changedListener); + + /** + * Temporary API which will be removed once we can safely untangle the methods that use this. + * Returns a set of OnOpModeChangedListener that are listening for op's mode changes. + * @param op app-op whose mode change is being listened to. + */ + ArraySet getOpModeChangedListeners(int op); + + /** + * Temporary API which will be removed once we can safely untangle the methods that use this. + * Returns a set of OnOpModeChangedListener that are listening for package's op's mode changes. + * @param packageName of package whose app-op's mode change is being listened to. + */ + ArraySet getPackageModeChangedListeners(@NonNull String packageName); + + /** + * Temporary API which will be removed once we can safely untangle the methods that use this. + * Notify that the app-op's mode is changed by triggering the change listener. + * @param op App-op whose mode has changed + * @param uid user id associated with the app-op (or, if UID_ANY, notifies all users) + */ + void notifyWatchersOfChange(int op, int uid); + + /** + * Temporary API which will be removed once we can safely untangle the methods that use this. + * Notify that the app-op's mode is changed by triggering the change listener. + * @param changedListener the change listener. + * @param op App-op whose mode has changed + * @param uid user id associated with the app-op + * @param packageName package name that is associated with the app-op + */ + void notifyOpChanged(@NonNull OnOpModeChangedListener changedListener, int op, int uid, + @Nullable String packageName); + + /** + * Temporary API which will be removed once we can safely untangle the methods that use this. + * Notify that the app-op's mode is changed to all packages associated with the uid by + * triggering the appropriate change listener. + * @param op App-op whose mode has changed + * @param uid user id associated with the app-op + * @param onlyForeground true if only watchers that + * @param callbackToIgnore callback that should be ignored. + */ + void notifyOpChangedForAllPkgsInUid(int op, int uid, boolean onlyForeground, + @Nullable OnOpModeChangedListener callbackToIgnore); + + /** + * TODO: Move hasForegroundWatchers and foregroundOps into this. + * Go over the list of app-ops for the uid and mark app-ops with MODE_FOREGROUND in + * foregroundOps. + * @param uid for which the app-op's mode needs to be marked. + * @param foregroundOps boolean array where app-ops that have MODE_FOREGROUND are marked true. + * @return foregroundOps. + */ + SparseBooleanArray evalForegroundUidOps(int uid, SparseBooleanArray foregroundOps); + + /** + * Go over the list of app-ops for the package name and mark app-ops with MODE_FOREGROUND in + * foregroundOps. + * @param packageName for which the app-op's mode needs to be marked. + * @param foregroundOps boolean array where app-ops that have MODE_FOREGROUND are marked true. + * @param userId user id associated with the package. + * @return foregroundOps. + */ + SparseBooleanArray evalForegroundPackageOps(String packageName, + SparseBooleanArray foregroundOps, @UserIdInt int userId); + + /** + * Dump op mode and package mode listeners and their details. + * @param dumpOp if -1 then op mode listeners for all app-ops are dumped. If it's set to an + * app-op, only the watchers for that app-op are dumped. + * @param dumpUid uid for which we want to dump op mode watchers. + * @param dumpPackage if not null and if dumpOp is -1, dumps watchers for the package name. + * @param printWriter writer to dump to. + */ + boolean dumpListeners(int dumpOp, int dumpUid, String dumpPackage, PrintWriter printWriter); +} diff --git a/services/core/java/com/android/server/appop/AppOpsRestrictionsImpl.java b/services/core/java/com/android/server/appop/AppOpsRestrictionsImpl.java index adfd2afffd78..f51200f2bf0c 100644 --- a/services/core/java/com/android/server/appop/AppOpsRestrictionsImpl.java +++ b/services/core/java/com/android/server/appop/AppOpsRestrictionsImpl.java @@ -42,7 +42,7 @@ public class AppOpsRestrictionsImpl implements AppOpsRestrictions { private Context mContext; private Handler mHandler; - private AppOpsServiceInterface mAppOpsServiceInterface; + private AppOpsCheckingServiceInterface mAppOpsCheckingServiceInterface; // Map from (Object token) to (int code) to (boolean restricted) private final ArrayMap mGlobalRestrictions = new ArrayMap<>(); @@ -56,10 +56,10 @@ public class AppOpsRestrictionsImpl implements AppOpsRestrictions { mUserRestrictionExcludedPackageTags = new ArrayMap<>(); public AppOpsRestrictionsImpl(Context context, Handler handler, - AppOpsServiceInterface appOpsServiceInterface) { + AppOpsCheckingServiceInterface appOpsCheckingServiceInterface) { mContext = context; mHandler = handler; - mAppOpsServiceInterface = appOpsServiceInterface; + mAppOpsCheckingServiceInterface = appOpsCheckingServiceInterface; } @Override @@ -219,7 +219,7 @@ public class AppOpsRestrictionsImpl implements AppOpsRestrictions { int restrictedCodesSize = allUserRestrictedCodes.size(); for (int j = 0; j < restrictedCodesSize; j++) { int code = allUserRestrictedCodes.keyAt(j); - mHandler.post(() -> mAppOpsServiceInterface.notifyWatchersOfChange(code, UID_ANY)); + mHandler.post(() -> mAppOpsCheckingServiceInterface.notifyWatchersOfChange(code, UID_ANY)); } } diff --git a/services/core/java/com/android/server/appop/AppOpsService.java b/services/core/java/com/android/server/appop/AppOpsService.java index cc0a77a6397f..934542291334 100644 --- a/services/core/java/com/android/server/appop/AppOpsService.java +++ b/services/core/java/com/android/server/appop/AppOpsService.java @@ -383,7 +383,8 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch private @Nullable PackageManagerInternal mPackageManagerInternal; /** Interface for app-op modes.*/ - @VisibleForTesting AppOpsServiceInterface mAppOpsServiceInterface; + @VisibleForTesting + AppOpsCheckingServiceInterface mAppOpsCheckingService; /** Interface for app-op restrictions.*/ @VisibleForTesting AppOpsRestrictions mAppOpsRestrictions; @@ -514,10 +515,10 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } public void clear() { - mAppOpsServiceInterface.removeUid(uid); + mAppOpsCheckingService.removeUid(uid); if (pkgOps != null) { for (String packageName : pkgOps.keySet()) { - mAppOpsServiceInterface.removePackage(packageName, UserHandle.getUserId(uid)); + mAppOpsCheckingService.removePackage(packageName, UserHandle.getUserId(uid)); } } pkgOps = null; @@ -527,7 +528,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch boolean areAllPackageModesDefault = true; if (pkgOps != null) { for (String packageName : pkgOps.keySet()) { - if (!mAppOpsServiceInterface.arePackageModesDefault(packageName, + if (!mAppOpsCheckingService.arePackageModesDefault(packageName, UserHandle.getUserId(uid))) { areAllPackageModesDefault = false; break; @@ -535,21 +536,21 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } } return (pkgOps == null || pkgOps.isEmpty()) - && mAppOpsServiceInterface.areUidModesDefault(uid) + && mAppOpsCheckingService.areUidModesDefault(uid) && areAllPackageModesDefault; } // Functions for uid mode access and manipulation. public SparseIntArray getNonDefaultUidModes() { - return mAppOpsServiceInterface.getNonDefaultUidModes(uid); + return mAppOpsCheckingService.getNonDefaultUidModes(uid); } public int getUidMode(int op) { - return mAppOpsServiceInterface.getUidMode(uid, op); + return mAppOpsCheckingService.getUidMode(uid, op); } public boolean setUidMode(int op, int mode) { - return mAppOpsServiceInterface.setUidMode(uid, op, mode); + return mAppOpsCheckingService.setUidMode(uid, op, mode); } @SuppressWarnings("GuardedBy") @@ -559,10 +560,10 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch public void evalForegroundOps() { foregroundOps = null; - foregroundOps = mAppOpsServiceInterface.evalForegroundUidOps(uid, foregroundOps); + foregroundOps = mAppOpsCheckingService.evalForegroundUidOps(uid, foregroundOps); if (pkgOps != null) { for (int i = pkgOps.size() - 1; i >= 0; i--) { - foregroundOps = mAppOpsServiceInterface + foregroundOps = mAppOpsCheckingService .evalForegroundPackageOps(pkgOps.valueAt(i).packageName, foregroundOps, UserHandle.getUserId(uid)); } @@ -643,11 +644,11 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } @Mode int getMode() { - return mAppOpsServiceInterface.getPackageMode(packageName, this.op, + return mAppOpsCheckingService.getPackageMode(packageName, this.op, UserHandle.getUserId(this.uid)); } void setMode(@Mode int mode) { - mAppOpsServiceInterface.setPackageMode(packageName, this.op, mode, + mAppOpsCheckingService.setPackageMode(packageName, this.op, mode, UserHandle.getUserId(this.uid)); } @@ -952,10 +953,10 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch mSwitchedOps.put(switchCode, ArrayUtils.appendInt(mSwitchedOps.get(switchCode), switchedCode)); } - mAppOpsServiceInterface = - new LegacyAppOpsServiceInterfaceImpl(this, this, handler, context, mSwitchedOps); + mAppOpsCheckingService = + new AppOpsCheckingServiceImpl(this, this, handler, context, mSwitchedOps); mAppOpsRestrictions = new AppOpsRestrictionsImpl(context, handler, - mAppOpsServiceInterface); + mAppOpsCheckingService); LockGuard.installLock(this, LockGuard.INDEX_APP_OPS); mFile = new AtomicFile(storagePath, "appops"); @@ -990,7 +991,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch if (uidState == null || uidState.pkgOps == null) { return; } - mAppOpsServiceInterface.removePackage(pkgName, UserHandle.getUserId(uid)); + mAppOpsCheckingService.removePackage(pkgName, UserHandle.getUserId(uid)); Ops removedOps = uidState.pkgOps.remove(pkgName); if (removedOps != null) { scheduleFastWriteLocked(); @@ -1134,7 +1135,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch ArraySet onModeChangedListeners; synchronized (AppOpsService.this) { onModeChangedListeners = - mAppOpsServiceInterface.getOpModeChangedListeners(code); + mAppOpsCheckingService.getOpModeChangedListeners(code); if (onModeChangedListeners == null) { continue; } @@ -1221,7 +1222,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch // Remove any package state if such. if (uidState.pkgOps != null) { removedOps = uidState.pkgOps.remove(packageName); - mAppOpsServiceInterface.removePackage(packageName, UserHandle.getUserId(uid)); + mAppOpsCheckingService.removePackage(packageName, UserHandle.getUserId(uid)); } // If we just nuked the last package state check if the UID is valid. @@ -1287,7 +1288,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch this, code, uidState.uid, true, null)); } else if (uidState.pkgOps != null) { final ArraySet listenerSet = - mAppOpsServiceInterface.getOpModeChangedListeners(code); + mAppOpsCheckingService.getOpModeChangedListeners(code); if (listenerSet != null) { for (int cbi = listenerSet.size() - 1; cbi >= 0; cbi--) { final OnOpModeChangedListener listener = listenerSet.valueAt(cbi); @@ -1680,7 +1681,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch ArrayMap pkgOps = uidState.pkgOps; if (pkgOps != null) { pkgOps.remove(ops.packageName); - mAppOpsServiceInterface.removePackage(ops.packageName, + mAppOpsCheckingService.removePackage(ops.packageName, UserHandle.getUserId(uidState.uid)); if (pkgOps.isEmpty()) { uidState.pkgOps = null; @@ -1776,7 +1777,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch @Nullable IAppOpsCallback callbackToIgnore) { ModeCallback listenerToIgnore = callbackToIgnore != null ? mModeWatchers.get(callbackToIgnore.asBinder()) : null; - mAppOpsServiceInterface.notifyOpChangedForAllPkgsInUid(code, uid, onlyForeground, + mAppOpsCheckingService.notifyOpChangedForAllPkgsInUid(code, uid, onlyForeground, listenerToIgnore); } @@ -1925,14 +1926,14 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch uidState.evalForegroundOps(); } ArraySet cbs = - mAppOpsServiceInterface.getOpModeChangedListeners(code); + mAppOpsCheckingService.getOpModeChangedListeners(code); if (cbs != null) { if (repCbs == null) { repCbs = new ArraySet<>(); } repCbs.addAll(cbs); } - cbs = mAppOpsServiceInterface.getPackageModeChangedListeners(packageName); + cbs = mAppOpsCheckingService.getPackageModeChangedListeners(packageName); if (cbs != null) { if (repCbs == null) { repCbs = new ArraySet<>(); @@ -1973,7 +1974,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch private void notifyOpChanged(OnOpModeChangedListener callback, int code, int uid, String packageName) { - mAppOpsServiceInterface.notifyOpChanged(callback, code, uid, packageName); + mAppOpsCheckingService.notifyOpChanged(callback, code, uid, packageName); } private static ArrayList addChange(ArrayList reports, @@ -2071,9 +2072,9 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch for (String packageName : getPackagesForUid(uidState.uid)) { callbacks = addCallbacks(callbacks, code, uidState.uid, packageName, previousMode, - mAppOpsServiceInterface.getOpModeChangedListeners(code)); + mAppOpsCheckingService.getOpModeChangedListeners(code)); callbacks = addCallbacks(callbacks, code, uidState.uid, packageName, - previousMode, mAppOpsServiceInterface + previousMode, mAppOpsCheckingService .getPackageModeChangedListeners(packageName)); allChanges = addChange(allChanges, code, uidState.uid, @@ -2119,9 +2120,9 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch final int uid = curOp.uidState.uid; callbacks = addCallbacks(callbacks, curOp.op, uid, packageName, previousMode, - mAppOpsServiceInterface.getOpModeChangedListeners(curOp.op)); + mAppOpsCheckingService.getOpModeChangedListeners(curOp.op)); callbacks = addCallbacks(callbacks, curOp.op, uid, packageName, - previousMode, mAppOpsServiceInterface + previousMode, mAppOpsCheckingService .getPackageModeChangedListeners(packageName)); allChanges = addChange(allChanges, curOp.op, uid, packageName, @@ -2134,7 +2135,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } if (pkgOps.size() == 0) { it.remove(); - mAppOpsServiceInterface.removePackage(packageName, + mAppOpsCheckingService.removePackage(packageName, UserHandle.getUserId(uidState.uid)); } } @@ -2238,10 +2239,10 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch mModeWatchers.put(callback.asBinder(), cb); } if (switchOp != AppOpsManager.OP_NONE) { - mAppOpsServiceInterface.startWatchingOpModeChanged(cb, switchOp); + mAppOpsCheckingService.startWatchingOpModeChanged(cb, switchOp); } if (mayWatchPackageName) { - mAppOpsServiceInterface.startWatchingPackageModeChanged(cb, packageName); + mAppOpsCheckingService.startWatchingPackageModeChanged(cb, packageName); } evalAllForegroundOpsLocked(); } @@ -2256,7 +2257,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch ModeCallback cb = mModeWatchers.remove(callback.asBinder()); if (cb != null) { cb.unlinkToDeath(); - mAppOpsServiceInterface.removeListener(cb); + mAppOpsCheckingService.removeListener(cb); } evalAllForegroundOpsLocked(); @@ -3911,7 +3912,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } boolean success = false; mUidStates.clear(); - mAppOpsServiceInterface.clearAllModes(); + mAppOpsCheckingService.clearAllModes(); try { TypedXmlPullParser parser = Xml.resolvePullParser(stream); int type; @@ -3960,7 +3961,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } finally { if (!success) { mUidStates.clear(); - mAppOpsServiceInterface.clearAllModes(); + mAppOpsCheckingService.clearAllModes(); } try { stream.close(); @@ -5131,7 +5132,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch } if (!dumpHistory) { - needSep |= mAppOpsServiceInterface.dumpListeners(dumpOp, dumpUid, dumpPackage, pw); + needSep |= mAppOpsCheckingService.dumpListeners(dumpOp, dumpUid, dumpPackage, pw); } if (mModeWatchers.size() > 0 && dumpOp < 0 && !dumpHistory) { @@ -5559,7 +5560,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch private void notifyWatchersOfChange(int code, int uid) { final ArraySet modeChangedListenerSet; synchronized (this) { - modeChangedListenerSet = mAppOpsServiceInterface.getOpModeChangedListeners(code); + modeChangedListenerSet = mAppOpsCheckingService.getOpModeChangedListeners(code); if (modeChangedListenerSet == null) { return; } @@ -5661,7 +5662,7 @@ public class AppOpsService extends IAppOpsService.Stub implements PersistenceSch return; } Ops removedOps = uidState.pkgOps.remove(packageName); - mAppOpsServiceInterface.removePackage(packageName, UserHandle.getUserId(uid)); + mAppOpsCheckingService.removePackage(packageName, UserHandle.getUserId(uid)); if (removedOps != null) { scheduleFastWriteLocked(); } diff --git a/services/core/java/com/android/server/appop/AppOpsServiceInterface.java b/services/core/java/com/android/server/appop/AppOpsServiceInterface.java deleted file mode 100644 index 18f659e4c62a..000000000000 --- a/services/core/java/com/android/server/appop/AppOpsServiceInterface.java +++ /dev/null @@ -1,209 +0,0 @@ -/* - * Copyright (C) 2022 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ -package com.android.server.appop; - -import android.annotation.NonNull; -import android.annotation.Nullable; -import android.annotation.UserIdInt; -import android.app.AppOpsManager.Mode; -import android.util.ArraySet; -import android.util.SparseBooleanArray; -import android.util.SparseIntArray; - -import java.io.PrintWriter; - -/** - * Interface for accessing and modifying modes for app-ops i.e. package and uid modes. - * This interface also includes functions for added and removing op mode watchers. - * In the future this interface will also include op restrictions. - */ -public interface AppOpsServiceInterface { - /** - * Returns a copy of non-default app-ops with op as keys and their modes as values for a uid. - * Returns an empty SparseIntArray if nothing is set. - * @param uid for which we need the app-ops and their modes. - */ - SparseIntArray getNonDefaultUidModes(int uid); - - /** - * Returns the app-op mode for a particular app-op of a uid. - * Returns default op mode if the op mode for particular uid and op is not set. - * @param uid user id for which we need the mode. - * @param op app-op for which we need the mode. - * @return mode of the app-op. - */ - int getUidMode(int uid, int op); - - /** - * Set the app-op mode for a particular uid and op. - * The mode is not set if the mode is the same as the default mode for the op. - * @param uid user id for which we want to set the mode. - * @param op app-op for which we want to set the mode. - * @param mode mode for the app-op. - * @return true if op mode is changed. - */ - boolean setUidMode(int uid, int op, @Mode int mode); - - /** - * Gets the app-op mode for a particular package. - * Returns default op mode if the op mode for the particular package is not set. - * @param packageName package name for which we need the op mode. - * @param op app-op for which we need the mode. - * @param userId user id associated with the package. - * @return the mode of the app-op. - */ - int getPackageMode(@NonNull String packageName, int op, @UserIdInt int userId); - - /** - * Sets the app-op mode for a particular package. - * @param packageName package name for which we need to set the op mode. - * @param op app-op for which we need to set the mode. - * @param mode the mode of the app-op. - * @param userId user id associated with the package. - * - */ - void setPackageMode(@NonNull String packageName, int op, @Mode int mode, @UserIdInt int userId); - - /** - * Stop tracking any app-op modes for a package. - * @param packageName Name of the package for which we want to remove all mode tracking. - * @param userId user id associated with the package. - */ - boolean removePackage(@NonNull String packageName, @UserIdInt int userId); - - /** - * Stop tracking any app-op modes for this uid. - * @param uid user id for which we want to remove all tracking. - */ - void removeUid(int uid); - - /** - * Returns true if all uid modes for this uid are - * in default state. - * @param uid user id - */ - boolean areUidModesDefault(int uid); - - /** - * Returns true if all package modes for this package name are - * in default state. - * @param packageName package name. - * @param userId user id associated with the package. - */ - boolean arePackageModesDefault(String packageName, @UserIdInt int userId); - - /** - * Stop tracking app-op modes for all uid and packages. - */ - void clearAllModes(); - - /** - * Registers changedListener to listen to op's mode change. - * @param changedListener the listener that must be trigger on the op's mode change. - * @param op op representing the app-op whose mode change needs to be listened to. - */ - void startWatchingOpModeChanged(@NonNull OnOpModeChangedListener changedListener, int op); - - /** - * Registers changedListener to listen to package's app-op's mode change. - * @param changedListener the listener that must be trigger on the mode change. - * @param packageName of the package whose app-op's mode change needs to be listened to. - */ - void startWatchingPackageModeChanged(@NonNull OnOpModeChangedListener changedListener, - @NonNull String packageName); - - /** - * Stop the changedListener from triggering on any mode change. - * @param changedListener the listener that needs to be removed. - */ - void removeListener(@NonNull OnOpModeChangedListener changedListener); - - /** - * Temporary API which will be removed once we can safely untangle the methods that use this. - * Returns a set of OnOpModeChangedListener that are listening for op's mode changes. - * @param op app-op whose mode change is being listened to. - */ - ArraySet getOpModeChangedListeners(int op); - - /** - * Temporary API which will be removed once we can safely untangle the methods that use this. - * Returns a set of OnOpModeChangedListener that are listening for package's op's mode changes. - * @param packageName of package whose app-op's mode change is being listened to. - */ - ArraySet getPackageModeChangedListeners(@NonNull String packageName); - - /** - * Temporary API which will be removed once we can safely untangle the methods that use this. - * Notify that the app-op's mode is changed by triggering the change listener. - * @param op App-op whose mode has changed - * @param uid user id associated with the app-op (or, if UID_ANY, notifies all users) - */ - void notifyWatchersOfChange(int op, int uid); - - /** - * Temporary API which will be removed once we can safely untangle the methods that use this. - * Notify that the app-op's mode is changed by triggering the change listener. - * @param changedListener the change listener. - * @param op App-op whose mode has changed - * @param uid user id associated with the app-op - * @param packageName package name that is associated with the app-op - */ - void notifyOpChanged(@NonNull OnOpModeChangedListener changedListener, int op, int uid, - @Nullable String packageName); - - /** - * Temporary API which will be removed once we can safely untangle the methods that use this. - * Notify that the app-op's mode is changed to all packages associated with the uid by - * triggering the appropriate change listener. - * @param op App-op whose mode has changed - * @param uid user id associated with the app-op - * @param onlyForeground true if only watchers that - * @param callbackToIgnore callback that should be ignored. - */ - void notifyOpChangedForAllPkgsInUid(int op, int uid, boolean onlyForeground, - @Nullable OnOpModeChangedListener callbackToIgnore); - - /** - * TODO: Move hasForegroundWatchers and foregroundOps into this. - * Go over the list of app-ops for the uid and mark app-ops with MODE_FOREGROUND in - * foregroundOps. - * @param uid for which the app-op's mode needs to be marked. - * @param foregroundOps boolean array where app-ops that have MODE_FOREGROUND are marked true. - * @return foregroundOps. - */ - SparseBooleanArray evalForegroundUidOps(int uid, SparseBooleanArray foregroundOps); - - /** - * Go over the list of app-ops for the package name and mark app-ops with MODE_FOREGROUND in - * foregroundOps. - * @param packageName for which the app-op's mode needs to be marked. - * @param foregroundOps boolean array where app-ops that have MODE_FOREGROUND are marked true. - * @param userId user id associated with the package. - * @return foregroundOps. - */ - SparseBooleanArray evalForegroundPackageOps(String packageName, - SparseBooleanArray foregroundOps, @UserIdInt int userId); - - /** - * Dump op mode and package mode listeners and their details. - * @param dumpOp if -1 then op mode listeners for all app-ops are dumped. If it's set to an - * app-op, only the watchers for that app-op are dumped. - * @param dumpUid uid for which we want to dump op mode watchers. - * @param dumpPackage if not null and if dumpOp is -1, dumps watchers for the package name. - * @param printWriter writer to dump to. - */ - boolean dumpListeners(int dumpOp, int dumpUid, String dumpPackage, PrintWriter printWriter); -} diff --git a/services/core/java/com/android/server/appop/LegacyAppOpsServiceInterfaceImpl.java b/services/core/java/com/android/server/appop/LegacyAppOpsServiceInterfaceImpl.java deleted file mode 100644 index f6fff351c232..000000000000 --- a/services/core/java/com/android/server/appop/LegacyAppOpsServiceInterfaceImpl.java +++ /dev/null @@ -1,601 +0,0 @@ -/* - * Copyright (C) 2022 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -package com.android.server.appop; - -import static android.app.AppOpsManager.OP_NONE; -import static android.app.AppOpsManager.WATCH_FOREGROUND_CHANGES; -import static android.app.AppOpsManager.opRestrictsRead; - -import static com.android.server.appop.AppOpsService.ModeCallback.ALL_OPS; - -import android.Manifest; -import android.annotation.NonNull; -import android.annotation.Nullable; -import android.annotation.UserIdInt; -import android.app.AppGlobals; -import android.app.AppOpsManager; -import android.app.AppOpsManager.Mode; -import android.content.Context; -import android.content.pm.PackageManager; -import android.os.Binder; -import android.os.Handler; -import android.os.RemoteException; -import android.os.UserHandle; -import android.util.ArrayMap; -import android.util.ArraySet; -import android.util.SparseArray; -import android.util.SparseBooleanArray; -import android.util.SparseIntArray; - -import com.android.internal.annotations.GuardedBy; -import com.android.internal.annotations.VisibleForTesting; -import com.android.internal.util.function.pooled.PooledLambda; - -import libcore.util.EmptyArray; - -import java.io.PrintWriter; -import java.util.Collections; -import java.util.Objects; - - -/** - * Legacy implementation for App-ops service's app-op mode (uid and package) storage and access. - * In the future this class will also include mode callbacks and op restrictions. - */ -public class LegacyAppOpsServiceInterfaceImpl implements AppOpsServiceInterface { - - static final String TAG = "LegacyAppOpsServiceInterfaceImpl"; - - // Must be the same object that the AppOpsService is using for locking. - final Object mLock; - final Handler mHandler; - final Context mContext; - final SparseArray mSwitchedOps; - - @GuardedBy("mLock") - @VisibleForTesting - final SparseArray mUidModes = new SparseArray<>(); - - @GuardedBy("mLock") - final SparseArray> mUserPackageModes = new SparseArray<>(); - - final SparseArray> mOpModeWatchers = new SparseArray<>(); - final ArrayMap> mPackageModeWatchers = - new ArrayMap<>(); - - final PersistenceScheduler mPersistenceScheduler; - - - // Constant meaning that any UID should be matched when dispatching callbacks - private static final int UID_ANY = -2; - - - LegacyAppOpsServiceInterfaceImpl(PersistenceScheduler persistenceScheduler, - @NonNull Object lock, Handler handler, Context context, - SparseArray switchedOps) { - this.mPersistenceScheduler = persistenceScheduler; - this.mLock = lock; - this.mHandler = handler; - this.mContext = context; - this.mSwitchedOps = switchedOps; - } - - @Override - public SparseIntArray getNonDefaultUidModes(int uid) { - synchronized (mLock) { - SparseIntArray opModes = mUidModes.get(uid, null); - if (opModes == null) { - return new SparseIntArray(); - } - return opModes.clone(); - } - } - - @Override - public int getUidMode(int uid, int op) { - synchronized (mLock) { - SparseIntArray opModes = mUidModes.get(uid, null); - if (opModes == null) { - return AppOpsManager.opToDefaultMode(op); - } - return opModes.get(op, AppOpsManager.opToDefaultMode(op)); - } - } - - @Override - public boolean setUidMode(int uid, int op, int mode) { - final int defaultMode = AppOpsManager.opToDefaultMode(op); - synchronized (mLock) { - SparseIntArray opModes = mUidModes.get(uid, null); - if (opModes == null) { - if (mode != defaultMode) { - opModes = new SparseIntArray(); - mUidModes.put(uid, opModes); - opModes.put(op, mode); - mPersistenceScheduler.scheduleWriteLocked(); - } - } else { - if (opModes.indexOfKey(op) >= 0 && opModes.get(op) == mode) { - return false; - } - if (mode == defaultMode) { - opModes.delete(op); - if (opModes.size() <= 0) { - opModes = null; - mUidModes.delete(uid); - } - } else { - opModes.put(op, mode); - } - mPersistenceScheduler.scheduleWriteLocked(); - } - } - return true; - } - - @Override - public int getPackageMode(String packageName, int op, @UserIdInt int userId) { - synchronized (mLock) { - ArrayMap packageModes = mUserPackageModes.get(userId, null); - if (packageModes == null) { - return AppOpsManager.opToDefaultMode(op); - } - SparseIntArray opModes = packageModes.getOrDefault(packageName, null); - if (opModes == null) { - return AppOpsManager.opToDefaultMode(op); - } - return opModes.get(op, AppOpsManager.opToDefaultMode(op)); - } - } - - @Override - public void setPackageMode(String packageName, int op, @Mode int mode, @UserIdInt int userId) { - final int defaultMode = AppOpsManager.opToDefaultMode(op); - synchronized (mLock) { - ArrayMap packageModes = mUserPackageModes.get(userId, null); - if (packageModes == null) { - packageModes = new ArrayMap<>(); - mUserPackageModes.put(userId, packageModes); - } - SparseIntArray opModes = packageModes.get(packageName); - if (opModes == null) { - if (mode != defaultMode) { - opModes = new SparseIntArray(); - packageModes.put(packageName, opModes); - opModes.put(op, mode); - mPersistenceScheduler.scheduleWriteLocked(); - } - } else { - if (opModes.indexOfKey(op) >= 0 && opModes.get(op) == mode) { - return; - } - if (mode == defaultMode) { - opModes.delete(op); - if (opModes.size() <= 0) { - opModes = null; - packageModes.remove(packageName); - } - } else { - opModes.put(op, mode); - } - mPersistenceScheduler.scheduleWriteLocked(); - } - } - } - - @Override - public void removeUid(int uid) { - synchronized (mLock) { - SparseIntArray opModes = mUidModes.get(uid); - if (opModes == null) { - return; - } - mUidModes.remove(uid); - mPersistenceScheduler.scheduleFastWriteLocked(); - } - } - - @Override - public boolean areUidModesDefault(int uid) { - synchronized (mLock) { - SparseIntArray opModes = mUidModes.get(uid); - return (opModes == null || opModes.size() <= 0); - } - } - - @Override - public boolean arePackageModesDefault(String packageMode, @UserIdInt int userId) { - synchronized (mLock) { - ArrayMap packageModes = mUserPackageModes.get(userId, null); - if (packageModes == null) { - return true; - } - SparseIntArray opModes = packageModes.get(packageMode); - return (opModes == null || opModes.size() <= 0); - } - } - - @Override - public boolean removePackage(String packageName, @UserIdInt int userId) { - synchronized (mLock) { - ArrayMap packageModes = mUserPackageModes.get(userId, null); - if (packageModes == null) { - return false; - } - SparseIntArray ops = packageModes.remove(packageName); - if (ops != null) { - mPersistenceScheduler.scheduleFastWriteLocked(); - return true; - } - return false; - } - } - - @Override - public void clearAllModes() { - synchronized (mLock) { - mUidModes.clear(); - mUserPackageModes.clear(); - } - } - - @Override - public void startWatchingOpModeChanged(@NonNull OnOpModeChangedListener changedListener, - int op) { - Objects.requireNonNull(changedListener); - synchronized (mLock) { - ArraySet modeWatcherSet = mOpModeWatchers.get(op); - if (modeWatcherSet == null) { - modeWatcherSet = new ArraySet<>(); - mOpModeWatchers.put(op, modeWatcherSet); - } - modeWatcherSet.add(changedListener); - } - } - - @Override - public void startWatchingPackageModeChanged(@NonNull OnOpModeChangedListener changedListener, - @NonNull String packageName) { - Objects.requireNonNull(changedListener); - Objects.requireNonNull(packageName); - synchronized (mLock) { - ArraySet modeWatcherSet = - mPackageModeWatchers.get(packageName); - if (modeWatcherSet == null) { - modeWatcherSet = new ArraySet<>(); - mPackageModeWatchers.put(packageName, modeWatcherSet); - } - modeWatcherSet.add(changedListener); - } - } - - @Override - public void removeListener(@NonNull OnOpModeChangedListener changedListener) { - Objects.requireNonNull(changedListener); - - synchronized (mLock) { - for (int i = mOpModeWatchers.size() - 1; i >= 0; i--) { - ArraySet cbs = mOpModeWatchers.valueAt(i); - cbs.remove(changedListener); - if (cbs.size() <= 0) { - mOpModeWatchers.removeAt(i); - } - } - - for (int i = mPackageModeWatchers.size() - 1; i >= 0; i--) { - ArraySet cbs = mPackageModeWatchers.valueAt(i); - cbs.remove(changedListener); - if (cbs.size() <= 0) { - mPackageModeWatchers.removeAt(i); - } - } - } - } - - @Override - public ArraySet getOpModeChangedListeners(int op) { - synchronized (mLock) { - ArraySet modeChangedListenersSet = mOpModeWatchers.get(op); - if (modeChangedListenersSet == null) { - return new ArraySet<>(); - } - return new ArraySet<>(modeChangedListenersSet); - } - } - - @Override - public ArraySet getPackageModeChangedListeners( - @NonNull String packageName) { - Objects.requireNonNull(packageName); - - synchronized (mLock) { - ArraySet modeChangedListenersSet = - mPackageModeWatchers.get(packageName); - if (modeChangedListenersSet == null) { - return new ArraySet<>(); - } - return new ArraySet<>(modeChangedListenersSet); - } - } - - @Override - public void notifyWatchersOfChange(int code, int uid) { - ArraySet listenerSet = getOpModeChangedListeners(code); - if (listenerSet == null) { - return; - } - for (int i = 0; i < listenerSet.size(); i++) { - final OnOpModeChangedListener listener = listenerSet.valueAt(i); - notifyOpChanged(listener, code, uid, null); - } - } - - @Override - public void notifyOpChanged(@NonNull OnOpModeChangedListener onModeChangedListener, int code, - int uid, @Nullable String packageName) { - Objects.requireNonNull(onModeChangedListener); - - if (uid != UID_ANY && onModeChangedListener.getWatchingUid() >= 0 - && onModeChangedListener.getWatchingUid() != uid) { - return; - } - - // See CALL_BACK_ON_CHANGED_LISTENER_WITH_SWITCHED_OP_CHANGE - int[] switchedCodes; - if (onModeChangedListener.getWatchedOpCode() == ALL_OPS) { - switchedCodes = mSwitchedOps.get(code); - } else if (onModeChangedListener.getWatchedOpCode() == OP_NONE) { - switchedCodes = new int[]{code}; - } else { - switchedCodes = new int[]{onModeChangedListener.getWatchedOpCode()}; - } - - for (int switchedCode : switchedCodes) { - // There are features watching for mode changes such as window manager - // and location manager which are in our process. The callbacks in these - // features may require permissions our remote caller does not have. - final long identity = Binder.clearCallingIdentity(); - try { - if (shouldIgnoreCallback(switchedCode, onModeChangedListener.getCallingPid(), - onModeChangedListener.getCallingUid())) { - continue; - } - onModeChangedListener.onOpModeChanged(switchedCode, uid, packageName); - } catch (RemoteException e) { - /* ignore */ - } finally { - Binder.restoreCallingIdentity(identity); - } - } - } - - private boolean shouldIgnoreCallback(int op, int watcherPid, int watcherUid) { - // If it's a restricted read op, ignore it if watcher doesn't have manage ops permission, - // as watcher should not use this to signal if the value is changed. - return opRestrictsRead(op) && mContext.checkPermission(Manifest.permission.MANAGE_APPOPS, - watcherPid, watcherUid) != PackageManager.PERMISSION_GRANTED; - } - - @Override - public void notifyOpChangedForAllPkgsInUid(int code, int uid, boolean onlyForeground, - @Nullable OnOpModeChangedListener callbackToIgnore) { - String[] uidPackageNames = getPackagesForUid(uid); - ArrayMap> callbackSpecs = null; - - synchronized (mLock) { - ArraySet callbacks = mOpModeWatchers.get(code); - if (callbacks != null) { - final int callbackCount = callbacks.size(); - for (int i = 0; i < callbackCount; i++) { - OnOpModeChangedListener callback = callbacks.valueAt(i); - - if (onlyForeground && (callback.getFlags() - & WATCH_FOREGROUND_CHANGES) == 0) { - continue; - } - - ArraySet changedPackages = new ArraySet<>(); - Collections.addAll(changedPackages, uidPackageNames); - if (callbackSpecs == null) { - callbackSpecs = new ArrayMap<>(); - } - callbackSpecs.put(callback, changedPackages); - } - } - - for (String uidPackageName : uidPackageNames) { - callbacks = mPackageModeWatchers.get(uidPackageName); - if (callbacks != null) { - if (callbackSpecs == null) { - callbackSpecs = new ArrayMap<>(); - } - final int callbackCount = callbacks.size(); - for (int i = 0; i < callbackCount; i++) { - OnOpModeChangedListener callback = callbacks.valueAt(i); - - if (onlyForeground && (callback.getFlags() - & WATCH_FOREGROUND_CHANGES) == 0) { - continue; - } - - ArraySet changedPackages = callbackSpecs.get(callback); - if (changedPackages == null) { - changedPackages = new ArraySet<>(); - callbackSpecs.put(callback, changedPackages); - } - changedPackages.add(uidPackageName); - } - } - } - - if (callbackSpecs != null && callbackToIgnore != null) { - callbackSpecs.remove(callbackToIgnore); - } - } - - if (callbackSpecs == null) { - return; - } - - for (int i = 0; i < callbackSpecs.size(); i++) { - final OnOpModeChangedListener callback = callbackSpecs.keyAt(i); - final ArraySet reportedPackageNames = callbackSpecs.valueAt(i); - if (reportedPackageNames == null) { - mHandler.sendMessage(PooledLambda.obtainMessage( - LegacyAppOpsServiceInterfaceImpl::notifyOpChanged, - this, callback, code, uid, (String) null)); - - } else { - final int reportedPackageCount = reportedPackageNames.size(); - for (int j = 0; j < reportedPackageCount; j++) { - final String reportedPackageName = reportedPackageNames.valueAt(j); - mHandler.sendMessage(PooledLambda.obtainMessage( - LegacyAppOpsServiceInterfaceImpl::notifyOpChanged, - this, callback, code, uid, reportedPackageName)); - } - } - } - } - - private static String[] getPackagesForUid(int uid) { - String[] packageNames = null; - - // Very early during boot the package manager is not yet or not yet fully started. At this - // time there are no packages yet. - if (AppGlobals.getPackageManager() != null) { - try { - packageNames = AppGlobals.getPackageManager().getPackagesForUid(uid); - } catch (RemoteException e) { - /* ignore - local call */ - } - } - if (packageNames == null) { - return EmptyArray.STRING; - } - return packageNames; - } - - @Override - public SparseBooleanArray evalForegroundUidOps(int uid, SparseBooleanArray foregroundOps) { - synchronized (mLock) { - return evalForegroundOps(mUidModes.get(uid), foregroundOps); - } - } - - @Override - public SparseBooleanArray evalForegroundPackageOps(String packageName, - SparseBooleanArray foregroundOps, @UserIdInt int userId) { - synchronized (mLock) { - ArrayMap packageModes = mUserPackageModes.get(userId, null); - return evalForegroundOps(packageModes == null ? null : packageModes.get(packageName), - foregroundOps); - } - } - - private SparseBooleanArray evalForegroundOps(SparseIntArray opModes, - SparseBooleanArray foregroundOps) { - SparseBooleanArray tempForegroundOps = foregroundOps; - if (opModes != null) { - for (int i = opModes.size() - 1; i >= 0; i--) { - if (opModes.valueAt(i) == AppOpsManager.MODE_FOREGROUND) { - if (tempForegroundOps == null) { - tempForegroundOps = new SparseBooleanArray(); - } - evalForegroundWatchers(opModes.keyAt(i), tempForegroundOps); - } - } - } - return tempForegroundOps; - } - - private void evalForegroundWatchers(int op, SparseBooleanArray foregroundOps) { - boolean curValue = foregroundOps.get(op, false); - ArraySet listenerSet = mOpModeWatchers.get(op); - if (listenerSet != null) { - for (int cbi = listenerSet.size() - 1; !curValue && cbi >= 0; cbi--) { - if ((listenerSet.valueAt(cbi).getFlags() - & AppOpsManager.WATCH_FOREGROUND_CHANGES) != 0) { - curValue = true; - } - } - } - foregroundOps.put(op, curValue); - } - - @Override - public boolean dumpListeners(int dumpOp, int dumpUid, String dumpPackage, - PrintWriter printWriter) { - boolean needSep = false; - if (mOpModeWatchers.size() > 0) { - boolean printedHeader = false; - for (int i = 0; i < mOpModeWatchers.size(); i++) { - if (dumpOp >= 0 && dumpOp != mOpModeWatchers.keyAt(i)) { - continue; - } - boolean printedOpHeader = false; - ArraySet modeChangedListenerSet = - mOpModeWatchers.valueAt(i); - for (int j = 0; j < modeChangedListenerSet.size(); j++) { - final OnOpModeChangedListener listener = modeChangedListenerSet.valueAt(j); - if (dumpPackage != null - && dumpUid != UserHandle.getAppId(listener.getWatchingUid())) { - continue; - } - needSep = true; - if (!printedHeader) { - printWriter.println(" Op mode watchers:"); - printedHeader = true; - } - if (!printedOpHeader) { - printWriter.print(" Op "); - printWriter.print(AppOpsManager.opToName(mOpModeWatchers.keyAt(i))); - printWriter.println(":"); - printedOpHeader = true; - } - printWriter.print(" #"); printWriter.print(j); printWriter.print(": "); - printWriter.println(listener.toString()); - } - } - } - - if (mPackageModeWatchers.size() > 0 && dumpOp < 0) { - boolean printedHeader = false; - for (int i = 0; i < mPackageModeWatchers.size(); i++) { - if (dumpPackage != null - && !dumpPackage.equals(mPackageModeWatchers.keyAt(i))) { - continue; - } - needSep = true; - if (!printedHeader) { - printWriter.println(" Package mode watchers:"); - printedHeader = true; - } - printWriter.print(" Pkg "); printWriter.print(mPackageModeWatchers.keyAt(i)); - printWriter.println(":"); - ArraySet modeChangedListenerSet = - mPackageModeWatchers.valueAt(i); - - for (int j = 0; j < modeChangedListenerSet.size(); j++) { - printWriter.print(" #"); printWriter.print(j); printWriter.print(": "); - printWriter.println(modeChangedListenerSet.valueAt(j).toString()); - } - } - } - return needSep; - } - -} \ No newline at end of file diff --git a/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt b/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt index 45837e2cdeb3..96270f79e710 100644 --- a/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt +++ b/services/permission/java/com/android/server/permission/access/AccessCheckingService.kt @@ -21,7 +21,7 @@ import com.android.internal.annotations.Keep import com.android.server.LocalManagerRegistry import com.android.server.LocalServices import com.android.server.SystemService -import com.android.server.appop.AppOpsServiceInterface +import com.android.server.appop.AppOpsCheckingServiceInterface import com.android.server.permission.access.appop.AppOpService import com.android.server.permission.access.collection.IntSet import com.android.server.permission.access.permission.PermissionService @@ -51,7 +51,7 @@ class AccessCheckingService(context: Context) : SystemService(context) { appOpService = AppOpService(this) permissionService = PermissionService(this) - LocalServices.addService(AppOpsServiceInterface::class.java, appOpService) + LocalServices.addService(AppOpsCheckingServiceInterface::class.java, appOpService) LocalServices.addService(PermissionManagerServiceInterface::class.java, permissionService) } diff --git a/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt b/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt index f606f86281ea..b8d6aa3b4e49 100644 --- a/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt +++ b/services/permission/java/com/android/server/permission/access/appop/AppOpService.kt @@ -19,14 +19,14 @@ package com.android.server.permission.access.appop import android.util.ArraySet import android.util.SparseBooleanArray import android.util.SparseIntArray -import com.android.server.appop.AppOpsServiceInterface +import com.android.server.appop.AppOpsCheckingServiceInterface import com.android.server.appop.OnOpModeChangedListener import com.android.server.permission.access.AccessCheckingService import java.io.PrintWriter class AppOpService( private val service: AccessCheckingService -) : AppOpsServiceInterface { +) : AppOpsCheckingServiceInterface { fun initialize() { TODO("Not yet implemented") } diff --git a/services/tests/mockingservicestests/src/com/android/server/appop/AppOpsLegacyRestrictionsTest.java b/services/tests/mockingservicestests/src/com/android/server/appop/AppOpsLegacyRestrictionsTest.java index 5dc12510368c..021d01cca381 100644 --- a/services/tests/mockingservicestests/src/com/android/server/appop/AppOpsLegacyRestrictionsTest.java +++ b/services/tests/mockingservicestests/src/com/android/server/appop/AppOpsLegacyRestrictionsTest.java @@ -57,7 +57,7 @@ public class AppOpsLegacyRestrictionsTest { Handler mHandler; @Mock - AppOpsServiceInterface mLegacyAppOpsService; + AppOpsCheckingServiceInterface mLegacyAppOpsService; AppOpsRestrictions mAppOpsRestrictions; -- cgit v1.2.3-59-g8ed1b