diff --git a/core/java/android/app/INotificationManager.aidl b/core/java/android/app/INotificationManager.aidl index cd127102f83..db7cc5c0c5a 100644 --- a/core/java/android/app/INotificationManager.aidl +++ b/core/java/android/app/INotificationManager.aidl @@ -65,6 +65,9 @@ interface INotificationManager boolean areNotificationsEnabled(String pkg); int getPackageImportance(String pkg); + void setPackagePriority(String pkg, int uid, int importance); + int getPackagePriority(String pkg, int uid); + void createNotificationChannelGroups(String pkg, in ParceledListSlice channelGroupList); void createNotificationChannels(String pkg, in ParceledListSlice channelsList); void createNotificationChannelsForPackage(String pkg, int uid, in ParceledListSlice channelsList); diff --git a/core/res/res/values/cerberusos_config.xml b/core/res/res/values/cerberusos_config.xml index 96fe1aa3093..71284c92ffa 100644 --- a/core/res/res/values/cerberusos_config.xml +++ b/core/res/res/values/cerberusos_config.xml @@ -2,7 +2,7 @@ - false + true diff --git a/core/res/res/values/cerberusos_symbols.xml b/core/res/res/values/cerberusos_symbols.xml index 5d8af675129..1f42caf9dfd 100644 --- a/core/res/res/values/cerberusos_symbols.xml +++ b/core/res/res/values/cerberusos_symbols.xml @@ -9,6 +9,9 @@ + + + diff --git a/services/core/java/com/android/server/IntentResolver.java b/services/core/java/com/android/server/IntentResolver.java index ea80ac1aece..68802559148 100644 --- a/services/core/java/com/android/server/IntentResolver.java +++ b/services/core/java/com/android/server/IntentResolver.java @@ -727,7 +727,7 @@ private void buildResolveList(Intent intent, FastImmutableArraySet categ final Uri data = intent.getData(); final String packageName = intent.getPackage(); - final boolean excludingStopped = intent.isExcludingStopped(); + final boolean excludingStopped = com.android.server.am.PreventRunningUtils.isExcludingStopped(intent); final Printer logPrinter; final PrintWriter logPrintWriter; @@ -781,7 +781,7 @@ private void buildResolveList(Intent intent, FastImmutableArraySet categ continue; } - match = filter.match(action, resolvedType, scheme, data, categories, TAG); + match = com.android.server.am.PreventRunningUtils.match(filter, action, resolvedType, scheme, data, categories, TAG); if (match >= 0) { if (debug) Slog.v(TAG, " Filter matched! match=0x" + Integer.toHexString(match) + " hasDefault=" diff --git a/services/core/java/com/android/server/am/ActivityManagerService.java b/services/core/java/com/android/server/am/ActivityManagerService.java index 972f7683e11..721830ee55e 100644 --- a/services/core/java/com/android/server/am/ActivityManagerService.java +++ b/services/core/java/com/android/server/am/ActivityManagerService.java @@ -4093,6 +4093,20 @@ final ProcessRecord startProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName, boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge, String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) { + if (PreventRunningUtils.hookStartProcessLocked(processName, info, knownToBeDead, intentFlags, hostingType, hostingName)) { + return startProcessLocked$Pr(processName, info, + knownToBeDead, intentFlags, hostingType, hostingName, + allowWhileBooting, isolated, isolatedUid, keepIfLarge, + abiOverride, entryPoint, entryPointArgs, crashHandler); + } else { + return null; + } + } + + final ProcessRecord startProcessLocked$Pr(String processName, ApplicationInfo info, + boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName, + boolean allowWhileBooting, boolean isolated, int isolatedUid, boolean keepIfLarge, + String abiOverride, String entryPoint, String[] entryPointArgs, Runnable crashHandler) { long startTime = SystemClock.elapsedRealtime(); ProcessRecord app; if (!isolated) { @@ -5100,6 +5114,14 @@ void reportUidInfoMessageLocked(String tag, String msg, int uid) { public final int startActivity(IApplicationThread caller, String callingPackage, Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) { + return PreventRunningUtils.onStartActivity(startActivity$Pr(caller, callingPackage, + intent, resolvedType, resultTo, resultWho, requestCode, + startFlags, profilerInfo, bOptions), caller, callingPackage, intent); + } + + public final int startActivity$Pr(IApplicationThread caller, String callingPackage, + Intent intent, String resolvedType, IBinder resultTo, String resultWho, int requestCode, + int startFlags, ProfilerInfo profilerInfo, Bundle bOptions) { return startActivityAsUser(caller, callingPackage, intent, resolvedType, resultTo, resultWho, requestCode, startFlags, profilerInfo, bOptions, UserHandle.getCallingUserId()); @@ -5906,6 +5928,14 @@ public void overridePendingTransition(IBinder token, String packageName, @GuardedBy("this") private final void handleAppDiedLocked(ProcessRecord app, boolean restarting, boolean allowRestart) { + handleAppDiedLocked$Pr(app, restarting, allowRestart); + if (!restarting && allowRestart && !app.killedByAm) { + PreventRunningUtils.onAppDied(app); + } + } + + private final void handleAppDiedLocked$Pr(ProcessRecord app, + boolean restarting, boolean allowRestart) { int pid = app.pid; boolean kept = cleanUpApplicationRecordLocked(app, restarting, allowRestart, -1, false /*replacingPid*/); @@ -7133,8 +7163,9 @@ private final boolean killPackageProcessesLocked(String packageName, int appId, // that match it. We need to qualify this by the processes // that are running under the specified app and user ID. } else { - final boolean isDep = app.pkgDeps != null + boolean isDep = app.pkgDeps != null && app.pkgDeps.contains(packageName); + isDep = PreventRunningUtils.returnFalse(isDep); if (!isDep && UserHandle.getAppId(app.uid) != appId) { continue; } @@ -11222,6 +11253,15 @@ void moveTaskToFrontLocked(int taskId, int flags, SafeActivityOptions options, */ @Override public boolean moveActivityTaskToBack(IBinder token, boolean nonRoot) { + if (moveActivityTaskToBack$Pr(token, nonRoot)) { + PreventRunningUtils.onMoveActivityTaskToBack(token); + return true; + } else { + return false; + } + } + + public boolean moveActivityTaskToBack$Pr(IBinder token, boolean nonRoot) { enforceNotIsolatedCaller("moveActivityTaskToBack"); synchronized(this) { final long origId = Binder.clearCallingIdentity(); @@ -20440,6 +20480,20 @@ public PendingIntent getRunningServiceControlPanel(ComponentName name) { public ComponentName startService(IApplicationThread caller, Intent service, String resolvedType, boolean requireForeground, String callingPackage, int userId) throws TransactionTooLargeException { + try { + PreventRunningUtils.setSender(caller); + if (PreventRunningUtils.hookStartService(caller, service)) { + return startService$Pr(caller, service, resolvedType, requireForeground, callingPackage, userId); + } + return null; + } finally { + PreventRunningUtils.clearSender(); + } + } + + public ComponentName startService$Pr(IApplicationThread caller, Intent service, + String resolvedType, boolean requireForeground, String callingPackage, int userId) + throws TransactionTooLargeException { enforceNotIsolatedCaller("startService"); // Refuse possible leaked file descriptors if (service != null && service.hasFileDescriptors() == true) { @@ -20590,6 +20644,22 @@ boolean isValidSingletonCall(int callingUid, int componentUid) { public int bindService(IApplicationThread caller, IBinder token, Intent service, String resolvedType, IServiceConnection connection, int flags, String callingPackage, int userId) throws TransactionTooLargeException { + try { + PreventRunningUtils.setSender(caller); + if (PreventRunningUtils.hookBindService(caller, token, service)) { + return bindService$Pr(caller, token, service, + resolvedType, connection, flags, callingPackage, userId); + } else { + return 0; + } + } finally { + PreventRunningUtils.clearSender(); + } + } + + public int bindService$Pr(IApplicationThread caller, IBinder token, Intent service, + String resolvedType, IServiceConnection connection, int flags, String callingPackage, + int userId) throws TransactionTooLargeException { enforceNotIsolatedCaller("bindService"); // Refuse possible leaked file descriptors @@ -22029,6 +22099,27 @@ public final int broadcastIntent(IApplicationThread caller, int resultCode, String resultData, Bundle resultExtras, String[] requiredPermissions, int appOp, Bundle bOptions, boolean serialized, boolean sticky, int userId) { + try { + PreventRunningUtils.setSender(caller); + int res = broadcastIntent$Pr(caller, + intent, resolvedType, resultTo, + resultCode, resultData, resultExtras, + requiredPermissions, appOp, bOptions, + serialized, sticky, userId); + if (res == 0) { + PreventRunningUtils.onBroadcastIntent(intent); + } + return res; + } finally { + PreventRunningUtils.clearSender(); + } + } + + public final int broadcastIntent$Pr(IApplicationThread caller, + Intent intent, String resolvedType, IIntentReceiver resultTo, + int resultCode, String resultData, Bundle resultExtras, + String[] requiredPermissions, int appOp, Bundle bOptions, + boolean serialized, boolean sticky, int userId) { enforceNotIsolatedCaller("broadcastIntent"); synchronized(this) { intent = verifyBroadcastLocked(intent); diff --git a/services/core/java/com/android/server/am/ActivityStack.java b/services/core/java/com/android/server/am/ActivityStack.java index c4926df632a..f57698902c7 100644 --- a/services/core/java/com/android/server/am/ActivityStack.java +++ b/services/core/java/com/android/server/am/ActivityStack.java @@ -1460,6 +1460,7 @@ final boolean startPausingLocked(boolean userLeaving, boolean uiSleeping, mService.getLifecycleManager().scheduleTransaction(prev.app.thread, prev.appToken, PauseActivityItem.obtain(prev.finishing, userLeaving, prev.configChangeFlags, pauseImmediately)); + PreventRunningUtils.onUserLeavingActivity(prev.appToken, prev.finishing, userLeaving); } catch (Exception e) { // Ignore exception, if process died other code will cleanup. Slog.w(TAG, "Exception thrown during pause", e); @@ -2706,6 +2707,7 @@ private boolean resumeTopActivityInnerLocked(ActivityRecord prev, ActivityOption ResumeActivityItem.obtain(next.app.repProcState, mService.isNextTransitionForward())); mService.getLifecycleManager().scheduleTransaction(transaction); + PreventRunningUtils.onResumeActivity(next.appToken); if (DEBUG_STATES) Slog.d(TAG_STATES, "resumeTopActivityLocked: Resumed " + next); @@ -4324,6 +4326,7 @@ final boolean destroyActivityLocked(ActivityRecord r, boolean removeFromApp, Str if (DEBUG_SWITCH) Slog.i(TAG_SWITCH, "Destroying: " + r); mService.getLifecycleManager().scheduleTransaction(r.app.thread, r.appToken, DestroyActivityItem.obtain(r.finishing, r.configChangeFlags)); + PreventRunningUtils.onDestroyActivity(r.appToken); } catch (Exception e) { // We can just ignore exceptions here... if the process // has crashed, our death notification will clean things diff --git a/services/core/java/com/android/server/am/ActivityStackSupervisor.java b/services/core/java/com/android/server/am/ActivityStackSupervisor.java index 1be3d3558d7..c7cf8d9b2f6 100644 --- a/services/core/java/com/android/server/am/ActivityStackSupervisor.java +++ b/services/core/java/com/android/server/am/ActivityStackSupervisor.java @@ -1524,6 +1524,7 @@ final boolean realStartActivityLocked(ActivityRecord r, ProcessRecord app, r.launchedFromPackage, task.voiceInteractor, app.repProcState, r.icicle, r.persistentState, results, newIntents, mService.isNextTransitionForward(), profilerInfo)); + PreventRunningUtils.onLaunchActivity(r.appToken); // Set desired final state. final ActivityLifecycleItem lifecycleItem; @@ -3079,6 +3080,17 @@ boolean removeTaskByIdLocked(int taskId, boolean killProcess, boolean removeFrom } void cleanUpRemovedTaskLocked(TaskRecord tr, boolean killProcess, boolean removeFromRecents) { + try { + cleanUpRemovedTaskLocked$Pr(tr, killProcess, removeFromRecents); + } finally { + if (killProcess) { + PreventRunningUtils.onCleanUpRemovedTask(tr.getBaseIntent()); + } + } + } + + private void cleanUpRemovedTaskLocked$Pr(TaskRecord tr, boolean killProcess, boolean removeFromRecents) { + if (removeFromRecents) { mRecentTasks.remove(tr); } diff --git a/services/core/java/com/android/server/am/PreventRunning.java b/services/core/java/com/android/server/am/PreventRunning.java new file mode 100644 index 00000000000..3548f60a118 --- /dev/null +++ b/services/core/java/com/android/server/am/PreventRunning.java @@ -0,0 +1,184 @@ +package com.android.server.am; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.pm.ApplicationInfo; +import android.net.Uri; +import android.util.Log; + +import java.io.File; +import java.util.Set; + +import dalvik.system.DexClassLoader; + +/** + * Created by thom on 15/10/27. + */ +public class PreventRunning implements PreventRunningHook { + + private static final String TAG = "Prevent"; + + public static final int VERSION = 20161024; + + private PreventRunningHook mPreventRunning; + + private static String[] APKS = { + "/data/app/me.piebridge.prevent-1/base.apk", + "/data/app/me.piebridge.prevent-2/base.apk", + "/data/app/me.piebridge.prevent-3/base.apk", + "/data/app/me.piebridge.prevent-1.apk", + "/data/app/me.piebridge.prevent-2.apk", + "/data/app/me.piebridge.prevent-3.apk", + "/system/app/ForceStop/me.piebridge.prevent.apk", + "/system/app/ForceStop/ForceStop.apk", + }; + + public PreventRunning() { + for (String apk : APKS) { + File file = new File(apk); + if (file.exists() && initPreventRunning(file)) { + break; + } + } + } + + private boolean initPreventRunning(File apk) { + try { + ClassLoader currentClassLoader = Thread.currentThread().getContextClassLoader(); + ClassLoader classLoader = new DexClassLoader(apk.getAbsolutePath(), "/cache", null, currentClassLoader); + Log.d(TAG, "loading PreventRunning(" + VERSION + ") from " + apk); + mPreventRunning = (PreventRunningHook) classLoader.loadClass("me.piebridge.prevent.framework.PreventRunning").newInstance(); + setVersion(VERSION); + setMethod("native"); + return true; + } catch (ClassNotFoundException e) { + Log.d(TAG, "cannot find class", e); + } catch (InstantiationException e) { + Log.d(TAG, "cannot instance class", e); + } catch (IllegalAccessException e) { + Log.d(TAG, "cannot access class", e); + } catch (Throwable t) { // NOSONAR + Log.d(TAG, "cannot load PreventRunning from " + apk, t); + } + return false; + } + + @Override + public void setSender(String sender) { + if (mPreventRunning != null) { + mPreventRunning.setSender(sender); + } + } + + @Override + public void onBroadcastIntent(Intent intent) { + if (mPreventRunning != null) { + mPreventRunning.onBroadcastIntent(intent); + } + } + + @Override + public void onCleanUpRemovedTask(String packageName) { + if (mPreventRunning != null) { + mPreventRunning.onCleanUpRemovedTask(packageName); + } + } + + @Override + public void onStartHomeActivity(String packageName) { + if (mPreventRunning != null) { + mPreventRunning.onStartHomeActivity(packageName); + } + } + + @Override + public void onMoveActivityTaskToBack(String packageName) { + if (mPreventRunning != null) { + mPreventRunning.onMoveActivityTaskToBack(packageName); + } + } + + @Override + public void onAppDied(Object processRecord) { + if (mPreventRunning != null) { + mPreventRunning.onAppDied(processRecord); + } + } + + @Override + public void onLaunchActivity(Object activityRecord) { + if (mPreventRunning != null) { + mPreventRunning.onLaunchActivity(activityRecord); + } + } + + @Override + public void onResumeActivity(Object activityRecord) { + if (mPreventRunning != null) { + mPreventRunning.onResumeActivity(activityRecord); + } + } + + @Override + public void onUserLeavingActivity(Object activityRecord) { + if (mPreventRunning != null) { + mPreventRunning.onUserLeavingActivity(activityRecord); + } + } + + @Override + public void onDestroyActivity(Object activityRecord) { + if (mPreventRunning != null) { + mPreventRunning.onDestroyActivity(activityRecord); + } + } + + @Override + public boolean isExcludingStopped(String action) { + return mPreventRunning == null || mPreventRunning.isExcludingStopped(action); + } + + @Override + public boolean hookStartProcessLocked(Context context, ApplicationInfo info, String hostingType, ComponentName hostingName) { + return mPreventRunning == null || mPreventRunning.hookStartProcessLocked(context, info, hostingType, hostingName); + } + + @Override + public int match(int match, Object filter, String action, String type, String scheme, Uri data, Set categories) { + if (mPreventRunning != null) { + return mPreventRunning.match(match, filter, action, type, scheme, data, categories); + } else { + return match; + } + } + + @Override + public void setVersion(int version) { + if (mPreventRunning != null) { + mPreventRunning.setVersion(version); + } + } + + @Override + public void setMethod(String method) { + if (mPreventRunning != null) { + mPreventRunning.setMethod(method); + } + } + + @Override + public boolean hookBindService(Intent service) { + return mPreventRunning == null || mPreventRunning.hookBindService(service); + } + + @Override + public boolean hookStartService(Intent service) { + return mPreventRunning == null || mPreventRunning.hookStartService(service); + } + + public boolean isActiviated() { + return mPreventRunning != null; + } + +} diff --git a/services/core/java/com/android/server/am/PreventRunningHook.java b/services/core/java/com/android/server/am/PreventRunningHook.java new file mode 100644 index 00000000000..89bf6311c1d --- /dev/null +++ b/services/core/java/com/android/server/am/PreventRunningHook.java @@ -0,0 +1,50 @@ +package com.android.server.am; + +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.pm.ApplicationInfo; +import android.net.Uri; + +import java.util.Set; + +/** + * Created by thom on 15/10/27. + */ +public interface PreventRunningHook { + + void setSender(String sender); + + void onBroadcastIntent(Intent intent); + + void onCleanUpRemovedTask(String packageName); + + void onStartHomeActivity(String sender); + + void onMoveActivityTaskToBack(String packageName); + + void onAppDied(Object processRecord); + + void onLaunchActivity(Object activityRecord); + + void onResumeActivity(Object activityRecord); + + void onUserLeavingActivity(Object activityRecord); + + void onDestroyActivity(Object activityRecord); + + boolean isExcludingStopped(String action); + + boolean hookStartProcessLocked(Context context, ApplicationInfo info, String hostingType, ComponentName hostingName); + + int match(int match, Object filter, String action, String type, String scheme, Uri data, Set categories); + + void setVersion(int version); + + void setMethod(String method); + + boolean hookBindService(Intent service); + + boolean hookStartService(Intent service); + +} diff --git a/services/core/java/com/android/server/am/PreventRunningUtils.java b/services/core/java/com/android/server/am/PreventRunningUtils.java new file mode 100644 index 00000000000..18fe6fa093e --- /dev/null +++ b/services/core/java/com/android/server/am/PreventRunningUtils.java @@ -0,0 +1,127 @@ +package com.android.server.am; + +import android.app.IApplicationThread; +import android.content.ComponentName; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.content.pm.ApplicationInfo; +import android.net.Uri; +import android.os.Binder; +import android.os.Build; +import android.os.IBinder; +import android.os.ServiceManager; + +import java.util.Set; + +public class PreventRunningUtils { + + private static ActivityManagerService ams; + + private static PreventRunning mPreventRunning = new PreventRunning(); + + private PreventRunningUtils() { + } + + private static ActivityManagerService getAms() { + if (ams == null) { + ams = (ActivityManagerService) ServiceManager.getService(Context.ACTIVITY_SERVICE); + } + return ams; + } + + public static boolean isExcludingStopped(Intent intent) { + String action = intent.getAction(); + return intent.isExcludingStopped() && action != null && mPreventRunning.isExcludingStopped(action); + } + + public static int match(IntentFilter filter, String action, String type, String scheme, Uri data, Set categories, String tag) { + int match = filter.match(action, type, scheme, data, categories, tag); + if (match >= 0) { + return mPreventRunning.match(match, filter, action, type, scheme, data, categories); + } else { + return match; + } + } + + public static boolean hookStartProcessLocked(String processName, ApplicationInfo info, boolean knownToBeDead, int intentFlags, String hostingType, ComponentName hostingName) { + return mPreventRunning.hookStartProcessLocked(getAms().mContext, info, hostingType, hostingName); + } + + public static int onStartActivity(int res, IApplicationThread caller, String callingPackage, Intent intent) { + if (res >= 0 && intent != null && (intent.hasCategory(Intent.CATEGORY_HOME) || intent.hasCategory(Intent.CATEGORY_LAUNCHER))) { + ProcessRecord callerApp = getAms().getRecordForAppLocked(caller); + if (callerApp != null) { + mPreventRunning.onStartHomeActivity(callerApp.info.packageName); + } + } + return res; + } + + public static void onAppDied(ProcessRecord app) { + mPreventRunning.onAppDied(app); + } + + public static boolean returnFalse(boolean res) { + if (mPreventRunning.isActiviated()) { + return false; + } else { + return res; + } + } + + public static void onCleanUpRemovedTask(Intent intent) { + if (intent != null && intent.getComponent() != null) { + mPreventRunning.onCleanUpRemovedTask(intent.getComponent().getPackageName()); + } + } + + public static void onMoveActivityTaskToBack(IBinder token) { + ActivityRecord ar = forToken(token); + mPreventRunning.onMoveActivityTaskToBack(ar != null ? ar.packageName : null); + } + + public static void setSender(IApplicationThread caller) { + final ProcessRecord callerApp = getAms().getRecordForAppLocked(caller); + mPreventRunning.setSender(callerApp != null ? callerApp.info.packageName : String.valueOf(Binder.getCallingUid())); + } + + public static void clearSender() { + mPreventRunning.setSender(null); + } + + public static boolean hookStartService(IApplicationThread caller, Intent service) { + return mPreventRunning.hookStartService(service); + } + + public static boolean hookBindService(IApplicationThread caller, IBinder token, Intent service) { + return mPreventRunning.hookBindService(service); + } + + public static void onBroadcastIntent(Intent intent) { + mPreventRunning.onBroadcastIntent(intent); + } + + public static void onUserLeavingActivity(IBinder token, boolean finishing, boolean userLeaving) { + if (userLeaving) { + mPreventRunning.onUserLeavingActivity(forToken(token)); + } + } + + public static void onResumeActivity(IBinder token) { + mPreventRunning.onResumeActivity(forToken(token)); + } + + public static void onDestroyActivity(IBinder token) { + mPreventRunning.onDestroyActivity(forToken(token)); + } + + public static void onLaunchActivity(IBinder token) { + mPreventRunning.onLaunchActivity(forToken(token)); + } + + private static ActivityRecord forToken(IBinder token) { + return ActivityRecord.forTokenLocked(token); + } + +} diff --git a/services/core/java/com/android/server/fingerprint/FingerprintService.java b/services/core/java/com/android/server/fingerprint/FingerprintService.java index 22dc07d1550..14d0258bab0 100644 --- a/services/core/java/com/android/server/fingerprint/FingerprintService.java +++ b/services/core/java/com/android/server/fingerprint/FingerprintService.java @@ -102,7 +102,6 @@ public class FingerprintService extends SystemService implements IHwBinder.DeathRecipient { static final String TAG = "FingerprintService"; static final boolean DEBUG = true; - private static final boolean CLEANUP_UNUSED_FP = true; private static final String FP_DATA_DIR = "fpdata"; private static final int MSG_USER_SWITCHING = 10; private static final String ACTION_LOCKOUT_RESET = @@ -148,6 +147,7 @@ private class PerformanceStats { private ClientMonitor mPendingClient; private PerformanceStats mPerformanceStats; private final boolean mNotifyClient; + private final boolean mCleanupUnusedFingerprints; private IBinder mToken = new Binder(); // used for internal FingerprintService enumeration private ArrayList mUnknownFingerprints = new ArrayList<>(); // hw fingerprints @@ -265,6 +265,8 @@ public FingerprintService(Context context) { .getService(); mNotifyClient = mContext.getResources().getBoolean( com.android.internal.R.bool.config_notifyClientOnFingerprintCancelSuccess); + mCleanupUnusedFingerprints = mContext.getResources().getBoolean( + com.android.internal.R.bool.config_cleanupUnusedFingerprints); } @Override @@ -337,7 +339,7 @@ private void loadAuthenticatorIds() { * @param userId */ private void doFingerprintCleanupForUser(int userId) { - if (SystemProperties.getBoolean("ro.fingerprint.cleanup.unused", CLEANUP_UNUSED_FP)) { + if (mCleanupUnusedFingerprints) { enumerateUser(userId); } } diff --git a/services/core/java/com/android/server/notification/NotificationManagerService.java b/services/core/java/com/android/server/notification/NotificationManagerService.java index 6de7b5af9fc..681e57008a3 100644 --- a/services/core/java/com/android/server/notification/NotificationManagerService.java +++ b/services/core/java/com/android/server/notification/NotificationManagerService.java @@ -2191,6 +2191,18 @@ public int getPackageImportance(String pkg) { return mRankingHelper.getImportance(pkg, Binder.getCallingUid()); } + @Override + public void setPackagePriority(String pkg, int uid, int importance) { + checkCallerIsSystem(); + mRankingHelper.setImportance(pkg, uid, importance); + savePolicyFile(); + } + @Override + public int getPackagePriority(String pkg, int uid) { + checkCallerIsSystem(); + return mRankingHelper.getImportance(pkg, uid); + } + @Override public boolean canShowBadge(String pkg, int uid) { checkCallerIsSystem();