package com.android.server.notification;
+import static android.service.notification.NotificationRankerService.REASON_APP_CANCEL;
+import static android.service.notification.NotificationRankerService.REASON_APP_CANCEL_ALL;
+import static android.service.notification.NotificationRankerService.REASON_DELEGATE_CANCEL;
+import static android.service.notification.NotificationRankerService.REASON_DELEGATE_CANCEL_ALL;
+import static android.service.notification.NotificationRankerService.REASON_DELEGATE_CLICK;
+import static android.service.notification.NotificationRankerService.REASON_DELEGATE_ERROR;
+import static android.service.notification.NotificationRankerService.REASON_GROUP_SUMMARY_CANCELED;
+import static android.service.notification.NotificationRankerService.REASON_LISTENER_CANCEL;
+import static android.service.notification.NotificationRankerService.REASON_LISTENER_CANCEL_ALL;
+import static android.service.notification.NotificationRankerService.REASON_PACKAGE_BANNED;
+import static android.service.notification.NotificationRankerService.REASON_PACKAGE_CHANGED;
+import static android.service.notification.NotificationRankerService.REASON_PACKAGE_SUSPENDED;
+import static android.service.notification.NotificationRankerService.REASON_PROFILE_TURNED_OFF;
+import static android.service.notification.NotificationRankerService.REASON_UNAUTOBUNDLED;
+import static android.service.notification.NotificationRankerService.REASON_USER_STOPPED;
import static android.service.notification.NotificationListenerService.HINT_HOST_DISABLE_EFFECTS;
+import static android.service.notification.NotificationListenerService.HINT_HOST_DISABLE_NOTIFICATION_EFFECTS;
+import static android.service.notification.NotificationListenerService.HINT_HOST_DISABLE_CALL_EFFECTS;
+import static android.service.notification.NotificationListenerService.SUPPRESSED_EFFECT_SCREEN_OFF;
+import static android.service.notification.NotificationListenerService.SUPPRESSED_EFFECT_SCREEN_ON;
import static android.service.notification.NotificationListenerService.TRIM_FULL;
import static android.service.notification.NotificationListenerService.TRIM_LIGHT;
+import static android.service.notification.NotificationListenerService.Ranking.IMPORTANCE_DEFAULT;
+import static android.service.notification.NotificationListenerService.Ranking.IMPORTANCE_NONE;
+
import static org.xmlpull.v1.XmlPullParser.END_DOCUMENT;
-import static org.xmlpull.v1.XmlPullParser.END_TAG;
-import static org.xmlpull.v1.XmlPullParser.START_TAG;
+import android.Manifest;
+import android.annotation.Nullable;
import android.app.ActivityManager;
+import android.app.ActivityManagerInternal;
import android.app.ActivityManagerNative;
import android.app.AppGlobals;
import android.app.AppOpsManager;
+import android.app.AutomaticZenRule;
import android.app.IActivityManager;
import android.app.INotificationManager;
import android.app.ITransientNotification;
import android.app.NotificationManager;
import android.app.NotificationManager.Policy;
import android.app.PendingIntent;
+import android.app.RemoteInput;
import android.app.StatusBarManager;
import android.app.backup.BackupManager;
import android.app.usage.UsageEvents;
import android.media.IRingtonePlayer;
import android.net.Uri;
import android.os.Binder;
-import android.os.Build;
import android.os.Bundle;
import android.os.Environment;
import android.os.Handler;
import android.os.IInterface;
import android.os.Looper;
import android.os.Message;
+import android.os.Parcelable;
import android.os.Process;
import android.os.RemoteException;
+import android.os.SystemClock;
import android.os.SystemProperties;
import android.os.UserHandle;
import android.os.UserManager;
import android.os.Vibrator;
import android.provider.Settings;
+import android.service.notification.Adjustment;
import android.service.notification.Condition;
-import android.service.notification.IConditionListener;
import android.service.notification.IConditionProvider;
import android.service.notification.INotificationListener;
import android.service.notification.IStatusBarNotificationHolder;
+import android.service.notification.NotificationRankerService;
import android.service.notification.NotificationListenerService;
import android.service.notification.NotificationRankingUpdate;
import android.service.notification.StatusBarNotification;
import android.util.AtomicFile;
import android.util.Log;
import android.util.Slog;
+import android.util.SparseArray;
import android.util.Xml;
import android.view.accessibility.AccessibilityEvent;
import android.view.accessibility.AccessibilityManager;
import android.widget.Toast;
import com.android.internal.R;
+import com.android.internal.annotations.VisibleForTesting;
import com.android.internal.statusbar.NotificationVisibility;
import com.android.internal.util.FastXmlSerializer;
+import com.android.internal.util.Preconditions;
+import com.android.server.DeviceIdleController;
import com.android.server.EventLogTags;
import com.android.server.LocalServices;
import com.android.server.SystemService;
import com.android.server.lights.Light;
import com.android.server.lights.LightsManager;
import com.android.server.notification.ManagedServices.ManagedServiceInfo;
-import com.android.server.notification.ManagedServices.UserProfiles;
import com.android.server.statusbar.StatusBarManagerInternal;
+import com.android.server.vr.VrManagerInternal;
+import com.android.server.notification.ManagedServices.UserProfiles;
import libcore.io.IoUtils;
-import org.json.JSONArray;
import org.json.JSONException;
import org.json.JSONObject;
import org.xmlpull.v1.XmlPullParser;
import java.nio.charset.StandardCharsets;
import java.util.ArrayDeque;
import java.util.ArrayList;
-import java.util.HashSet;
+import java.util.Arrays;
import java.util.Iterator;
import java.util.List;
+import java.util.Map;
import java.util.Map.Entry;
-import java.util.Objects;
+import java.util.Set;
+import java.util.concurrent.TimeUnit;
/** {@hide} */
public class NotificationManagerService extends SystemService {
static final String TAG = "NotificationService";
static final boolean DBG = Log.isLoggable(TAG, Log.DEBUG);
- public static final boolean ENABLE_CHILD_NOTIFICATIONS = Build.IS_DEBUGGABLE
- && SystemProperties.getBoolean("debug.child_notifs", false);
+ public static final boolean ENABLE_CHILD_NOTIFICATIONS
+ = SystemProperties.getBoolean("debug.child_notifs", true);
static final int MAX_PACKAGE_NOTIFICATIONS = 50;
+ static final float DEFAULT_MAX_NOTIFICATION_ENQUEUE_RATE = 50f;
// message codes
static final int MESSAGE_TIMEOUT = 2;
static final int MESSAGE_SAVE_POLICY_FILE = 3;
- static final int MESSAGE_RECONSIDER_RANKING = 4;
- static final int MESSAGE_RANKING_CONFIG_CHANGE = 5;
- static final int MESSAGE_SEND_RANKING_UPDATE = 6;
- static final int MESSAGE_LISTENER_HINTS_CHANGED = 7;
- static final int MESSAGE_LISTENER_NOTIFICATION_FILTER_CHANGED = 8;
+ static final int MESSAGE_SEND_RANKING_UPDATE = 4;
+ static final int MESSAGE_LISTENER_HINTS_CHANGED = 5;
+ static final int MESSAGE_LISTENER_NOTIFICATION_FILTER_CHANGED = 6;
+
+ // ranking thread messages
+ private static final int MESSAGE_RECONSIDER_RANKING = 1000;
+ private static final int MESSAGE_RANKING_SORT = 1001;
static final int LONG_DELAY = 3500; // 3.5 seconds
static final int SHORT_DELAY = 2000; // 2 seconds
static final int VIBRATE_PATTERN_MAXLEN = 8 * 2 + 1; // up to eight bumps
static final int DEFAULT_STREAM_TYPE = AudioManager.STREAM_NOTIFICATION;
- static final boolean SCORE_ONGOING_HIGHER = false;
-
- static final int JUNK_SCORE = -1000;
- static final int NOTIFICATION_PRIORITY_MULTIPLIER = 10;
- static final int SCORE_DISPLAY_THRESHOLD = Notification.PRIORITY_MIN * NOTIFICATION_PRIORITY_MULTIPLIER;
-
- // Notifications with scores below this will not interrupt the user, either via LED or
- // sound or vibration
- static final int SCORE_INTERRUPTION_THRESHOLD =
- Notification.PRIORITY_LOW * NOTIFICATION_PRIORITY_MULTIPLIER;
static final boolean ENABLE_BLOCKED_NOTIFICATIONS = true;
static final boolean ENABLE_BLOCKED_TOASTS = true;
/** notification_enqueue status value for an ignored notification. */
private static final int EVENTLOG_ENQUEUE_STATUS_IGNORED = 2;
+ private static final long MIN_PACKAGE_OVERRATE_LOG_INTERVAL = 5000; // milliseconds
+ private String mRankerServicePackageName;
private IActivityManager mAm;
AudioManager mAudioManager;
AudioManagerInternal mAudioManagerInternal;
- StatusBarManagerInternal mStatusBar;
+ @Nullable StatusBarManagerInternal mStatusBar;
Vibrator mVibrator;
+ private VrManagerInternal mVrManagerInternal;
final IBinder mForegroundToken = new Binder();
- private WorkerHandler mHandler;
+ private Handler mHandler;
private final HandlerThread mRankingThread = new HandlerThread("ranker",
Process.THREAD_PRIORITY_BACKGROUND);
private String mSoundNotificationKey;
private String mVibrateNotificationKey;
- private final ArraySet<ManagedServiceInfo> mListenersDisablingEffects = new ArraySet<>();
- private ComponentName mEffectsSuppressor;
+ private final SparseArray<ArraySet<ManagedServiceInfo>> mListenersDisablingEffects =
+ new SparseArray<ArraySet<ManagedServiceInfo>>();
+ private List<ComponentName> mEffectsSuppressors = new ArrayList<ComponentName>();
private int mListenerHints; // right now, all hints are global
private int mInterruptionFilter = NotificationListenerService.INTERRUPTION_FILTER_UNKNOWN;
new ArrayList<NotificationRecord>();
final ArrayMap<String, NotificationRecord> mNotificationsByKey =
new ArrayMap<String, NotificationRecord>();
+ final ArrayMap<Integer, ArrayMap<String, String>> mAutobundledSummaries = new ArrayMap<>();
final ArrayList<ToastRecord> mToastQueue = new ArrayList<ToastRecord>();
final ArrayMap<String, NotificationRecord> mSummaryByGroupKey = new ArrayMap<>();
final PolicyAccess mPolicyAccess = new PolicyAccess();
// Persistent storage for notification policy
private AtomicFile mPolicyFile;
- // Temporary holder for <blocked-packages> config coming from old policy files.
- private HashSet<String> mBlockedPackages = new HashSet<String>();
-
private static final int DB_VERSION = 1;
private static final String TAG_NOTIFICATION_POLICY = "notification-policy";
private static final String ATTR_VERSION = "version";
- // Obsolete: converted if present, but not resaved to disk.
- private static final String TAG_BLOCKED_PKGS = "blocked-packages";
- private static final String TAG_PACKAGE = "package";
- private static final String ATTR_NAME = "name";
-
private RankingHelper mRankingHelper;
private final UserProfiles mUserProfiles = new UserProfiles();
private NotificationListeners mListeners;
+ private NotificationRankers mRankerServices;
private ConditionProviders mConditionProviders;
private NotificationUsageStats mUsageStats;
private static final int MY_UID = Process.myUid();
private static final int MY_PID = Process.myPid();
- private static final int REASON_DELEGATE_CLICK = 1;
- private static final int REASON_DELEGATE_CANCEL = 2;
- private static final int REASON_DELEGATE_CANCEL_ALL = 3;
- private static final int REASON_DELEGATE_ERROR = 4;
- private static final int REASON_PACKAGE_CHANGED = 5;
- private static final int REASON_USER_STOPPED = 6;
- private static final int REASON_PACKAGE_BANNED = 7;
- private static final int REASON_NOMAN_CANCEL = 8;
- private static final int REASON_NOMAN_CANCEL_ALL = 9;
- private static final int REASON_LISTENER_CANCEL = 10;
- private static final int REASON_LISTENER_CANCEL_ALL = 11;
- private static final int REASON_GROUP_SUMMARY_CANCELED = 12;
- private static final int REASON_GROUP_OPTIMIZATION = 13;
+ private RankingHandler mRankingHandler;
+ private long mLastOverRateLogTime;
+ private float mMaxPackageEnqueueRate = DEFAULT_MAX_NOTIFICATION_ENQUEUE_RATE;
+ private String mSystemNotificationSound;
private static class Archive {
final int mBufferSize;
final XmlPullParser parser = Xml.newPullParser();
parser.setInput(stream, StandardCharsets.UTF_8.name());
- int type;
- String tag;
- int version = DB_VERSION;
- while ((type = parser.next()) != END_DOCUMENT) {
- tag = parser.getName();
- if (type == START_TAG) {
- if (TAG_NOTIFICATION_POLICY.equals(tag)) {
- version = Integer.parseInt(
- parser.getAttributeValue(null, ATTR_VERSION));
- } else if (TAG_BLOCKED_PKGS.equals(tag)) {
- while ((type = parser.next()) != END_DOCUMENT) {
- tag = parser.getName();
- if (TAG_PACKAGE.equals(tag)) {
- mBlockedPackages.add(
- parser.getAttributeValue(null, ATTR_NAME));
- } else if (TAG_BLOCKED_PKGS.equals(tag) && type == END_TAG) {
- break;
- }
- }
- }
- }
+ while (parser.next() != END_DOCUMENT) {
mZenModeHelper.readXml(parser, forRestore);
mRankingHelper.readXml(parser, forRestore);
}
private void loadPolicyFile() {
if (DBG) Slog.d(TAG, "loadPolicyFile");
synchronized(mPolicyFile) {
- mBlockedPackages.clear();
FileInputStream infile = null;
try {
/** Use this to check if a package can post a notification or toast. */
private boolean checkNotificationOp(String pkg, int uid) {
return mAppOps.checkOp(AppOpsManager.OP_POST_NOTIFICATION, uid, pkg)
- == AppOpsManager.MODE_ALLOWED;
+ == AppOpsManager.MODE_ALLOWED && !isPackageSuspendedForUser(pkg, uid);
}
private static final class ToastRecord
public void clearEffects() {
synchronized (mNotificationList) {
if (DBG) Slog.d(TAG, "clearEffects");
-
- // sound
- mSoundNotificationKey = null;
-
- long identity = Binder.clearCallingIdentity();
- try {
- final IRingtonePlayer player = mAudioManager.getRingtonePlayer();
- if (player != null) {
- player.stopAsync();
- }
- } catch (RemoteException e) {
- } finally {
- Binder.restoreCallingIdentity(identity);
- }
-
- // vibrate
- mVibrateNotificationKey = null;
- identity = Binder.clearCallingIdentity();
- try {
- mVibrator.cancel();
- } finally {
- Binder.restoreCallingIdentity(identity);
- }
-
- // light
- mLights.clear();
- updateLightsLocked();
+ clearSoundLocked();
+ clearVibrateLocked();
+ clearLightsLocked();
}
}
}
};
+ private void clearSoundLocked() {
+ mSoundNotificationKey = null;
+ long identity = Binder.clearCallingIdentity();
+ try {
+ final IRingtonePlayer player = mAudioManager.getRingtonePlayer();
+ if (player != null) {
+ player.stopAsync();
+ }
+ } catch (RemoteException e) {
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ private void clearVibrateLocked() {
+ mVibrateNotificationKey = null;
+ long identity = Binder.clearCallingIdentity();
+ try {
+ mVibrator.cancel();
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ private void clearLightsLocked() {
+ // light
+ mLights.clear();
+ updateLightsLocked();
+ }
+
private final BroadcastReceiver mPackageIntentReceiver = new BroadcastReceiver() {
@Override
public void onReceive(Context context, Intent intent) {
boolean queryRemove = false;
boolean packageChanged = false;
boolean cancelNotifications = true;
+ int reason = REASON_PACKAGE_CHANGED;
if (action.equals(Intent.ACTION_PACKAGE_ADDED)
|| (queryRemove=action.equals(Intent.ACTION_PACKAGE_REMOVED))
|| action.equals(Intent.ACTION_PACKAGE_RESTARTED)
|| (packageChanged=action.equals(Intent.ACTION_PACKAGE_CHANGED))
|| (queryRestart=action.equals(Intent.ACTION_QUERY_PACKAGE_RESTART))
- || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) {
+ || action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)
+ || action.equals(Intent.ACTION_PACKAGES_SUSPENDED)) {
int changeUserId = intent.getIntExtra(Intent.EXTRA_USER_HANDLE,
UserHandle.USER_ALL);
String pkgList[] = null;
if (DBG) Slog.i(TAG, "action=" + action + " queryReplace=" + queryReplace);
if (action.equals(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE)) {
pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
+ } else if (action.equals(Intent.ACTION_PACKAGES_SUSPENDED)) {
+ pkgList = intent.getStringArrayExtra(Intent.EXTRA_CHANGED_PACKAGE_LIST);
+ reason = REASON_PACKAGE_SUSPENDED;
} else if (queryRestart) {
pkgList = intent.getStringArrayExtra(Intent.EXTRA_PACKAGES);
} else {
final IPackageManager pm = AppGlobals.getPackageManager();
final int enabled = pm.getApplicationEnabledSetting(pkgName,
changeUserId != UserHandle.USER_ALL ? changeUserId :
- UserHandle.USER_OWNER);
+ UserHandle.USER_SYSTEM);
if (enabled == PackageManager.COMPONENT_ENABLED_STATE_ENABLED
|| enabled == PackageManager.COMPONENT_ENABLED_STATE_DEFAULT) {
cancelNotifications = false;
for (String pkgName : pkgList) {
if (cancelNotifications) {
cancelAllNotificationsInt(MY_UID, MY_PID, pkgName, 0, 0, !queryRestart,
- changeUserId, REASON_PACKAGE_CHANGED, null);
+ changeUserId, reason, null);
}
}
}
mListeners.onPackagesChanged(queryReplace, pkgList);
+ mRankerServices.onPackagesChanged(queryReplace, pkgList);
mConditionProviders.onPackagesChanged(queryReplace, pkgList);
mRankingHelper.onPackagesChanged(queryReplace, pkgList);
}
cancelAllNotificationsInt(MY_UID, MY_PID, null, 0, 0, true, userHandle,
REASON_USER_STOPPED, null);
}
+ } else if (action.equals(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE)) {
+ int userHandle = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, -1);
+ if (userHandle >= 0) {
+ cancelAllNotificationsInt(MY_UID, MY_PID, null, 0, 0, true, userHandle,
+ REASON_PROFILE_TURNED_OFF, null);
+ }
} else if (action.equals(Intent.ACTION_USER_PRESENT)) {
// turn off LED when user passes through lock screen
mNotificationLight.turnOff();
- mStatusBar.notificationLightOff();
+ if (mStatusBar != null) {
+ mStatusBar.notificationLightOff();
+ }
} else if (action.equals(Intent.ACTION_USER_SWITCHED)) {
final int user = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
// reload per-user settings
// Refresh managed services
mConditionProviders.onUserSwitched(user);
mListeners.onUserSwitched(user);
+ mRankerServices.onUserSwitched(user);
mZenModeHelper.onUserSwitched(user);
} else if (action.equals(Intent.ACTION_USER_ADDED)) {
mUserProfiles.updateCache(context);
} else if (action.equals(Intent.ACTION_USER_REMOVED)) {
final int user = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
mZenModeHelper.onUserRemoved(user);
+ } else if (action.equals(Intent.ACTION_USER_UNLOCKED)) {
+ final int user = intent.getIntExtra(Intent.EXTRA_USER_HANDLE, UserHandle.USER_NULL);
+ mConditionProviders.onUserUnlocked(user);
+ mListeners.onUserUnlocked(user);
+ mRankerServices.onUserUnlocked(user);
+ mZenModeHelper.onUserUnlocked(user);
}
}
};
private final class SettingsObserver extends ContentObserver {
private final Uri NOTIFICATION_LIGHT_PULSE_URI
= Settings.System.getUriFor(Settings.System.NOTIFICATION_LIGHT_PULSE);
+ private final Uri NOTIFICATION_SOUND_URI
+ = Settings.System.getUriFor(Settings.System.NOTIFICATION_SOUND);
+ private final Uri NOTIFICATION_RATE_LIMIT_URI
+ = Settings.Global.getUriFor(Settings.Global.MAX_NOTIFICATION_ENQUEUE_RATE);
SettingsObserver(Handler handler) {
super(handler);
ContentResolver resolver = getContext().getContentResolver();
resolver.registerContentObserver(NOTIFICATION_LIGHT_PULSE_URI,
false, this, UserHandle.USER_ALL);
+ resolver.registerContentObserver(NOTIFICATION_SOUND_URI,
+ false, this, UserHandle.USER_ALL);
+ resolver.registerContentObserver(NOTIFICATION_RATE_LIMIT_URI,
+ false, this, UserHandle.USER_ALL);
update(null);
}
updateNotificationPulse();
}
}
+ if (uri == null || NOTIFICATION_RATE_LIMIT_URI.equals(uri)) {
+ mMaxPackageEnqueueRate = Settings.Global.getFloat(resolver,
+ Settings.Global.MAX_NOTIFICATION_ENQUEUE_RATE, mMaxPackageEnqueueRate);
+ }
+ if (uri == null || NOTIFICATION_SOUND_URI.equals(uri)) {
+ mSystemNotificationSound = Settings.System.getString(resolver,
+ Settings.System.NOTIFICATION_SOUND);
+ }
}
}
private final Runnable mBuzzBeepBlinked = new Runnable() {
@Override
public void run() {
- mStatusBar.buzzBeepBlinked();
+ if (mStatusBar != null) {
+ mStatusBar.buzzBeepBlinked();
+ }
}
};
super(context);
}
+ @VisibleForTesting
+ void setAudioManager(AudioManager audioMananger) {
+ mAudioManager = audioMananger;
+ }
+
+ @VisibleForTesting
+ void setVibrator(Vibrator vibrator) {
+ mVibrator = vibrator;
+ }
+
+ @VisibleForTesting
+ void setSystemReady(boolean systemReady) {
+ mSystemReady = systemReady;
+ }
+
+ @VisibleForTesting
+ void setHandler(Handler handler) {
+ mHandler = handler;
+ }
+
+ @VisibleForTesting
+ void setSystemNotificationSound(String systemNotificationSound) {
+ mSystemNotificationSound = systemNotificationSound;
+ }
+
@Override
public void onStart() {
Resources resources = getContext().getResources();
+ mMaxPackageEnqueueRate = Settings.Global.getFloat(getContext().getContentResolver(),
+ Settings.Global.MAX_NOTIFICATION_ENQUEUE_RATE,
+ DEFAULT_MAX_NOTIFICATION_ENQUEUE_RATE);
+
mAm = ActivityManagerNative.getDefault();
mAppOps = (AppOpsManager) getContext().getSystemService(Context.APP_OPS_SERVICE);
mVibrator = (Vibrator) getContext().getSystemService(Context.VIBRATOR_SERVICE);
mAppUsageStats = LocalServices.getService(UsageStatsManagerInternal.class);
+ // This is the package that contains the AOSP framework update.
+ mRankerServicePackageName = getContext().getPackageManager()
+ .getServicesSystemSharedLibraryPackageName();
+
mHandler = new WorkerHandler();
mRankingThread.start();
String[] extractorNames;
extractorNames = new String[0];
}
mUsageStats = new NotificationUsageStats(getContext());
+ mRankingHandler = new RankingHandlerWorker(mRankingThread.getLooper());
mRankingHelper = new RankingHelper(getContext(),
- new RankingWorkerHandler(mRankingThread.getLooper()),
+ mRankingHandler,
mUsageStats,
extractorNames);
mConditionProviders = new ConditionProviders(getContext(), mHandler, mUserProfiles);
@Override
void onZenModeChanged() {
sendRegisteredOnlyBroadcast(NotificationManager.ACTION_INTERRUPTION_FILTER_CHANGED);
+ getContext().sendBroadcastAsUser(
+ new Intent(NotificationManager.ACTION_INTERRUPTION_FILTER_CHANGED_INTERNAL)
+ .addFlags(Intent.FLAG_RECEIVER_REGISTERED_ONLY_BEFORE_BOOT),
+ UserHandle.ALL, android.Manifest.permission.MANAGE_NOTIFICATIONS);
synchronized(mNotificationList) {
updateInterruptionFilterLocked();
}
final File systemDir = new File(Environment.getDataDirectory(), "system");
mPolicyFile = new AtomicFile(new File(systemDir, "notification_policy.xml"));
- importOldBlockDb();
+ syncBlockDb();
+ // This is a MangedServices object that keeps track of the listeners.
mListeners = new NotificationListeners();
+
+ // This is a MangedServices object that keeps track of the ranker.
+ mRankerServices = new NotificationRankers();
+ // Find the updatable ranker and register it.
+ mRankerServices.registerRanker();
+
mStatusBar = getLocalService(StatusBarManagerInternal.class);
- mStatusBar.setNotificationDelegate(mNotificationDelegate);
+ if (mStatusBar != null) {
+ mStatusBar.setNotificationDelegate(mNotificationDelegate);
+ }
final LightsManager lights = getLocalService(LightsManager.class);
mNotificationLight = lights.getLight(LightsManager.LIGHT_ID_NOTIFICATIONS);
filter.addAction(Intent.ACTION_USER_SWITCHED);
filter.addAction(Intent.ACTION_USER_ADDED);
filter.addAction(Intent.ACTION_USER_REMOVED);
+ filter.addAction(Intent.ACTION_USER_UNLOCKED);
+ filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
getContext().registerReceiver(mIntentReceiver, filter);
IntentFilter pkgFilter = new IntentFilter();
getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL, pkgFilter, null,
null);
+ IntentFilter suspendedPkgFilter = new IntentFilter();
+ suspendedPkgFilter.addAction(Intent.ACTION_PACKAGES_SUSPENDED);
+ getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL,
+ suspendedPkgFilter, null, null);
+
IntentFilter sdFilter = new IntentFilter(Intent.ACTION_EXTERNAL_APPLICATIONS_UNAVAILABLE);
getContext().registerReceiverAsUser(mPackageIntentReceiver, UserHandle.ALL, sdFilter, null,
null);
}
/**
- * Read the old XML-based app block database and import those blockages into the AppOps system.
+ * Make sure the XML config and the the AppOps system agree about blocks.
*/
- private void importOldBlockDb() {
+ private void syncBlockDb() {
loadPolicyFile();
- PackageManager pm = getContext().getPackageManager();
- for (String pkg : mBlockedPackages) {
- PackageInfo info = null;
- try {
- info = pm.getPackageInfo(pkg, 0);
- setNotificationsEnabledForPackageImpl(pkg, info.applicationInfo.uid, false);
- } catch (NameNotFoundException e) {
- // forget you
+ // sync bans from ranker into app opps
+ Map<Integer, String> packageBans = mRankingHelper.getPackageBans();
+ for(Entry<Integer, String> ban : packageBans.entrySet()) {
+ final int uid = ban.getKey();
+ final String packageName = ban.getValue();
+ setNotificationsEnabledForPackageImpl(packageName, uid, false);
+ }
+
+ // sync bans from app opps into ranker
+ packageBans.clear();
+ for (UserInfo user : UserManager.get(getContext()).getUsers()) {
+ final int userId = user.getUserHandle().getIdentifier();
+ final PackageManager packageManager = getContext().getPackageManager();
+ List<PackageInfo> packages = packageManager.getInstalledPackagesAsUser(0, userId);
+ final int packageCount = packages.size();
+ for (int p = 0; p < packageCount; p++) {
+ final String packageName = packages.get(p).packageName;
+ try {
+ final int uid = packageManager.getPackageUidAsUser(packageName, userId);
+ if (!checkNotificationOp(packageName, uid)) {
+ packageBans.put(uid, packageName);
+ }
+ } catch (NameNotFoundException e) {
+ // forget you
+ }
}
}
- mBlockedPackages.clear();
+ for (Entry<Integer, String> ban : packageBans.entrySet()) {
+ mRankingHelper.setImportance(ban.getValue(), ban.getKey(), IMPORTANCE_NONE);
+ }
+
+ savePolicyFile();
}
@Override
// Grab our optional AudioService
mAudioManager = (AudioManager) getContext().getSystemService(Context.AUDIO_SERVICE);
mAudioManagerInternal = getLocalService(AudioManagerInternal.class);
+ mVrManagerInternal = getLocalService(VrManagerInternal.class);
mZenModeHelper.onSystemReady();
} else if (phase == SystemService.PHASE_THIRD_PARTY_APPS_CAN_START) {
// This observer will force an update when observe is called, causing us to
// bind to listener services.
mSettingsObserver.observe();
mListeners.onBootPhaseAppsCanStart();
+ mRankerServices.onBootPhaseAppsCanStart();
mConditionProviders.onBootPhaseAppsCanStart();
}
}
}
private void updateListenerHintsLocked() {
- final int hints = mListenersDisablingEffects.isEmpty() ? 0 : HINT_HOST_DISABLE_EFFECTS;
+ final int hints = calculateHints();
if (hints == mListenerHints) return;
- ZenLog.traceListenerHintsChanged(mListenerHints, hints, mListenersDisablingEffects.size());
+ ZenLog.traceListenerHintsChanged(mListenerHints, hints, mEffectsSuppressors.size());
mListenerHints = hints;
scheduleListenerHintsChanged(hints);
}
private void updateEffectsSuppressorLocked() {
- final ComponentName suppressor = !mListenersDisablingEffects.isEmpty()
- ? mListenersDisablingEffects.valueAt(0).component : null;
- if (Objects.equals(suppressor, mEffectsSuppressor)) return;
- ZenLog.traceEffectsSuppressorChanged(mEffectsSuppressor, suppressor);
- mEffectsSuppressor = suppressor;
- mZenModeHelper.setEffectsSuppressed(suppressor != null);
+ final long updatedSuppressedEffects = calculateSuppressedEffects();
+ if (updatedSuppressedEffects == mZenModeHelper.getSuppressedEffects()) return;
+ final List<ComponentName> suppressors = getSuppressors();
+ ZenLog.traceEffectsSuppressorChanged(mEffectsSuppressors, suppressors, updatedSuppressedEffects);
+ mEffectsSuppressors = suppressors;
+ mZenModeHelper.setSuppressedEffects(updatedSuppressedEffects);
sendRegisteredOnlyBroadcast(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED);
}
+ private ArrayList<ComponentName> getSuppressors() {
+ ArrayList<ComponentName> names = new ArrayList<ComponentName>();
+ for (int i = mListenersDisablingEffects.size() - 1; i >= 0; --i) {
+ ArraySet<ManagedServiceInfo> serviceInfoList = mListenersDisablingEffects.valueAt(i);
+
+ for (ManagedServiceInfo info : serviceInfoList) {
+ names.add(info.component);
+ }
+ }
+
+ return names;
+ }
+
+ private boolean removeDisabledHints(ManagedServiceInfo info) {
+ return removeDisabledHints(info, 0);
+ }
+
+ private boolean removeDisabledHints(ManagedServiceInfo info, int hints) {
+ boolean removed = false;
+
+ for (int i = mListenersDisablingEffects.size() - 1; i >= 0; --i) {
+ final int hint = mListenersDisablingEffects.keyAt(i);
+ final ArraySet<ManagedServiceInfo> listeners =
+ mListenersDisablingEffects.valueAt(i);
+
+ if (hints == 0 || (hint & hints) == hint) {
+ removed = removed || listeners.remove(info);
+ }
+ }
+
+ return removed;
+ }
+
+ private void addDisabledHints(ManagedServiceInfo info, int hints) {
+ if ((hints & HINT_HOST_DISABLE_EFFECTS) != 0) {
+ addDisabledHint(info, HINT_HOST_DISABLE_EFFECTS);
+ }
+
+ if ((hints & HINT_HOST_DISABLE_NOTIFICATION_EFFECTS) != 0) {
+ addDisabledHint(info, HINT_HOST_DISABLE_NOTIFICATION_EFFECTS);
+ }
+
+ if ((hints & HINT_HOST_DISABLE_CALL_EFFECTS) != 0) {
+ addDisabledHint(info, HINT_HOST_DISABLE_CALL_EFFECTS);
+ }
+ }
+
+ private void addDisabledHint(ManagedServiceInfo info, int hint) {
+ if (mListenersDisablingEffects.indexOfKey(hint) < 0) {
+ mListenersDisablingEffects.put(hint, new ArraySet<ManagedServiceInfo>());
+ }
+
+ ArraySet<ManagedServiceInfo> hintListeners = mListenersDisablingEffects.get(hint);
+ hintListeners.add(info);
+ }
+
+ private int calculateHints() {
+ int hints = 0;
+ for (int i = mListenersDisablingEffects.size() - 1; i >= 0; --i) {
+ int hint = mListenersDisablingEffects.keyAt(i);
+ ArraySet<ManagedServiceInfo> serviceInfoList = mListenersDisablingEffects.valueAt(i);
+
+ if (!serviceInfoList.isEmpty()) {
+ hints |= hint;
+ }
+ }
+
+ return hints;
+ }
+
+ private long calculateSuppressedEffects() {
+ int hints = calculateHints();
+ long suppressedEffects = 0;
+
+ if ((hints & HINT_HOST_DISABLE_EFFECTS) != 0) {
+ suppressedEffects |= ZenModeHelper.SUPPRESSED_EFFECT_ALL;
+ }
+
+ if ((hints & HINT_HOST_DISABLE_NOTIFICATION_EFFECTS) != 0) {
+ suppressedEffects |= ZenModeHelper.SUPPRESSED_EFFECT_NOTIFICATIONS;
+ }
+
+ if ((hints & HINT_HOST_DISABLE_CALL_EFFECTS) != 0) {
+ suppressedEffects |= ZenModeHelper.SUPPRESSED_EFFECT_CALLS;
+ }
+
+ return suppressedEffects;
+ }
+
private void updateInterruptionFilterLocked() {
int interruptionFilter = mZenModeHelper.getZenModeListenerInterruptionFilter();
if (interruptionFilter == mInterruptionFilter) return;
}
final boolean isSystemToast = isCallerSystem() || ("android".equals(pkg));
+ final boolean isPackageSuspended =
+ isPackageSuspendedForUser(pkg, Binder.getCallingUid());
- if (ENABLE_BLOCKED_TOASTS && !noteNotificationOp(pkg, Binder.getCallingUid())) {
+ if (ENABLE_BLOCKED_TOASTS && (!noteNotificationOp(pkg, Binder.getCallingUid())
+ || isPackageSuspended)) {
if (!isSystemToast) {
- Slog.e(TAG, "Suppressing toast from package " + pkg + " by user request.");
+ Slog.e(TAG, "Suppressing toast from package " + pkg
+ + (isPackageSuspended
+ ? " due to package suspended by administrator."
+ : " by user request."));
return;
}
}
checkCallerIsSystemOrSameApp(pkg);
userId = ActivityManager.handleIncomingUser(Binder.getCallingPid(),
Binder.getCallingUid(), userId, true, false, "cancelNotificationWithTag", pkg);
- // Don't allow client applications to cancel foreground service notis.
+ // Don't allow client applications to cancel foreground service notis or autobundled
+ // summaries.
cancelNotification(Binder.getCallingUid(), Binder.getCallingPid(), pkg, tag, id, 0,
- Binder.getCallingUid() == Process.SYSTEM_UID
- ? 0 : Notification.FLAG_FOREGROUND_SERVICE, false, userId, REASON_NOMAN_CANCEL,
- null);
+ (Binder.getCallingUid() == Process.SYSTEM_UID
+ ? 0 : Notification.FLAG_FOREGROUND_SERVICE)
+ | (Binder.getCallingUid() == Process.SYSTEM_UID
+ ? 0 : Notification.FLAG_AUTOGROUP_SUMMARY), false, userId,
+ REASON_APP_CANCEL, null);
}
@Override
// running foreground services.
cancelAllNotificationsInt(Binder.getCallingUid(), Binder.getCallingPid(),
pkg, 0, Notification.FLAG_FOREGROUND_SERVICE, true, userId,
- REASON_NOMAN_CANCEL_ALL, null);
+ REASON_APP_CANCEL_ALL, null);
}
@Override
checkCallerIsSystem();
setNotificationsEnabledForPackageImpl(pkg, uid, enabled);
+ mRankingHelper.setEnabled(pkg, uid, enabled);
+ savePolicyFile();
+ }
+
+ /**
+ * Use this when you just want to know if notifications are OK for this package.
+ */
+ @Override
+ public boolean areNotificationsEnabled(String pkg) {
+ return areNotificationsEnabledForPackage(pkg, Binder.getCallingUid());
}
/**
*/
@Override
public boolean areNotificationsEnabledForPackage(String pkg, int uid) {
- checkCallerIsSystem();
+ checkCallerIsSystemOrSameApp(pkg);
return (mAppOps.checkOpNoThrow(AppOpsManager.OP_POST_NOTIFICATION, uid, pkg)
- == AppOpsManager.MODE_ALLOWED);
+ == AppOpsManager.MODE_ALLOWED) && !isPackageSuspendedForUser(pkg, uid);
}
@Override
- public void setPackagePriority(String pkg, int uid, int priority) {
+ public void setPriority(String pkg, int uid, int priority) {
checkCallerIsSystem();
- mRankingHelper.setPackagePriority(pkg, uid, priority);
+ mRankingHelper.setPriority(pkg, uid, priority);
savePolicyFile();
}
@Override
- public int getPackagePriority(String pkg, int uid) {
+ public int getPriority(String pkg, int uid) {
checkCallerIsSystem();
- return mRankingHelper.getPackagePriority(pkg, uid);
+ return mRankingHelper.getPriority(pkg, uid);
}
@Override
- public void setPackagePeekable(String pkg, int uid, boolean peekable) {
+ public void setVisibilityOverride(String pkg, int uid, int visibility) {
checkCallerIsSystem();
-
- mRankingHelper.setPackagePeekable(pkg, uid, peekable);
+ mRankingHelper.setVisibilityOverride(pkg, uid, visibility);
+ savePolicyFile();
}
@Override
- public boolean getPackagePeekable(String pkg, int uid) {
+ public int getVisibilityOverride(String pkg, int uid) {
checkCallerIsSystem();
- return mRankingHelper.getPackagePeekable(pkg, uid);
+ return mRankingHelper.getVisibilityOverride(pkg, uid);
}
@Override
- public void setPackageVisibilityOverride(String pkg, int uid, int visibility) {
- checkCallerIsSystem();
- mRankingHelper.setPackageVisibilityOverride(pkg, uid, visibility);
+ public void setImportance(String pkg, int uid, int importance) {
+ enforceSystemOrSystemUI("Caller not system or systemui");
+ setNotificationsEnabledForPackageImpl(pkg, uid,
+ importance != NotificationListenerService.Ranking.IMPORTANCE_NONE);
+ mRankingHelper.setImportance(pkg, uid, importance);
savePolicyFile();
}
@Override
- public int getPackageVisibilityOverride(String pkg, int uid) {
- checkCallerIsSystem();
- return mRankingHelper.getPackageVisibilityOverride(pkg, uid);
+ public int getPackageImportance(String pkg) {
+ checkCallerIsSystemOrSameApp(pkg);
+ return mRankingHelper.getImportance(pkg, Binder.getCallingUid());
+ }
+
+ @Override
+ public int getImportance(String pkg, int uid) {
+ enforceSystemOrSystemUI("Caller not system or systemui");
+ return mRankingHelper.getImportance(pkg, uid);
}
/**
Binder.getCallingUid(), incomingUserId, true, false,
"getAppActiveNotifications", pkg);
- final int N = mNotificationList.size();
- final ArrayList<StatusBarNotification> list = new ArrayList<StatusBarNotification>(N);
+ final ArrayList<StatusBarNotification> list
+ = new ArrayList<StatusBarNotification>(mNotificationList.size());
synchronized (mNotificationList) {
+ final int N = mNotificationList.size();
for (int i = 0; i < N; i++) {
final StatusBarNotification sbn = mNotificationList.get(i).sbn;
- if (sbn.getPackageName().equals(pkg) && sbn.getUserId() == userId) {
+ if (sbn.getPackageName().equals(pkg) && sbn.getUserId() == userId
+ && (sbn.getNotification().flags
+ & Notification.FLAG_AUTOGROUP_SUMMARY) == 0) {
// We could pass back a cloneLight() but clients might get confused and
// try to send this thing back to notify() again, which would not work
// very well.
* Remove a listener binder directly
*/
@Override
- public void unregisterListener(INotificationListener listener, int userid) {
- mListeners.unregisterService(listener, userid);
+ public void unregisterListener(INotificationListener token, int userid) {
+ mListeners.unregisterService(token, userid);
}
/**
}
}
+ /**
+ * Handle request from an approved listener to re-enable itself.
+ *
+ * @param component The componenet to be re-enabled, caller must match package.
+ */
+ @Override
+ public void requestBindListener(ComponentName component) {
+ checkCallerIsSystemOrSameApp(component.getPackageName());
+ long identity = Binder.clearCallingIdentity();
+ try {
+ ManagedServices manager =
+ mRankerServices.isComponentEnabledForCurrentProfiles(component)
+ ? mRankerServices
+ : mListeners;
+ manager.setComponentState(component, true);
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
+ @Override
+ public void requestUnbindListener(INotificationListener token) {
+ long identity = Binder.clearCallingIdentity();
+ try {
+ // allow bound services to disable themselves
+ final ManagedServiceInfo info = mListeners.checkServiceTokenLocked(token);
+ info.getOwner().setComponentState(info.component, false);
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+
@Override
public void setNotificationsShownFromListener(INotificationListener token, String[] keys) {
long identity = Binder.clearCallingIdentity();
if (!r.isSeen()) {
if (DBG) Slog.d(TAG, "Marking notification as seen " + keys[i]);
mAppUsageStats.reportEvent(r.sbn.getPackageName(),
- userId == UserHandle.USER_ALL ? UserHandle.USER_OWNER
+ userId == UserHandle.USER_ALL ? UserHandle.USER_SYSTEM
: userId,
UsageEvents.Event.USER_INTERACTION);
r.setSeen();
try {
synchronized (mNotificationList) {
final ManagedServiceInfo info = mListeners.checkServiceTokenLocked(token);
- final boolean disableEffects = (hints & HINT_HOST_DISABLE_EFFECTS) != 0;
+ final int disableEffectsMask = HINT_HOST_DISABLE_EFFECTS
+ | HINT_HOST_DISABLE_NOTIFICATION_EFFECTS
+ | HINT_HOST_DISABLE_CALL_EFFECTS;
+ final boolean disableEffects = (hints & disableEffectsMask) != 0;
if (disableEffects) {
- mListenersDisablingEffects.add(info);
+ addDisabledHints(info, hints);
} else {
- mListenersDisablingEffects.remove(info);
+ removeDisabledHints(info, hints);
}
updateListenerHintsLocked();
updateEffectsSuppressorLocked();
}
@Override
- public boolean setZenModeConfig(ZenModeConfig config, String reason) {
- checkCallerIsSystem();
- return mZenModeHelper.setConfig(config, reason);
- }
-
- @Override
public void setZenMode(int mode, Uri conditionId, String reason) throws RemoteException {
enforceSystemOrSystemUIOrVolume("INotificationManager.setZenMode");
final long identity = Binder.clearCallingIdentity();
}
@Override
+ public List<ZenModeConfig.ZenRule> getZenRules() throws RemoteException {
+ enforcePolicyAccess(Binder.getCallingUid(), "getAutomaticZenRules");
+ return mZenModeHelper.getZenRules();
+ }
+
+ @Override
+ public AutomaticZenRule getAutomaticZenRule(String id) throws RemoteException {
+ Preconditions.checkNotNull(id, "Id is null");
+ enforcePolicyAccess(Binder.getCallingUid(), "getAutomaticZenRule");
+ return mZenModeHelper.getAutomaticZenRule(id);
+ }
+
+ @Override
+ public String addAutomaticZenRule(AutomaticZenRule automaticZenRule)
+ throws RemoteException {
+ Preconditions.checkNotNull(automaticZenRule, "automaticZenRule is null");
+ Preconditions.checkNotNull(automaticZenRule.getName(), "Name is null");
+ Preconditions.checkNotNull(automaticZenRule.getOwner(), "Owner is null");
+ Preconditions.checkNotNull(automaticZenRule.getConditionId(), "ConditionId is null");
+ enforcePolicyAccess(Binder.getCallingUid(), "addAutomaticZenRule");
+
+ return mZenModeHelper.addAutomaticZenRule(automaticZenRule,
+ "addAutomaticZenRule");
+ }
+
+ @Override
+ public boolean updateAutomaticZenRule(String id, AutomaticZenRule automaticZenRule)
+ throws RemoteException {
+ Preconditions.checkNotNull(automaticZenRule, "automaticZenRule is null");
+ Preconditions.checkNotNull(automaticZenRule.getName(), "Name is null");
+ Preconditions.checkNotNull(automaticZenRule.getOwner(), "Owner is null");
+ Preconditions.checkNotNull(automaticZenRule.getConditionId(), "ConditionId is null");
+ enforcePolicyAccess(Binder.getCallingUid(), "updateAutomaticZenRule");
+
+ return mZenModeHelper.updateAutomaticZenRule(id, automaticZenRule,
+ "updateAutomaticZenRule");
+ }
+
+ @Override
+ public boolean removeAutomaticZenRule(String id) throws RemoteException {
+ Preconditions.checkNotNull(id, "Id is null");
+ // Verify that they can modify zen rules.
+ enforcePolicyAccess(Binder.getCallingUid(), "removeAutomaticZenRule");
+
+ return mZenModeHelper.removeAutomaticZenRule(id, "removeAutomaticZenRule");
+ }
+
+ @Override
+ public boolean removeAutomaticZenRules(String packageName) throws RemoteException {
+ Preconditions.checkNotNull(packageName, "Package name is null");
+ enforceSystemOrSystemUI("removeAutomaticZenRules");
+
+ return mZenModeHelper.removeAutomaticZenRules(packageName, "removeAutomaticZenRules");
+ }
+
+ @Override
+ public int getRuleInstanceCount(ComponentName owner) throws RemoteException {
+ Preconditions.checkNotNull(owner, "Owner is null");
+ enforceSystemOrSystemUI("getRuleInstanceCount");
+
+ return mZenModeHelper.getCurrentInstanceCount(owner);
+ }
+
+ @Override
public void setInterruptionFilter(String pkg, int filter) throws RemoteException {
enforcePolicyAccess(pkg, "setInterruptionFilter");
final int zen = NotificationManager.zenModeFromInterruptionFilter(filter, -1);
});
}
- @Override
- public void requestZenModeConditions(IConditionListener callback, int relevance) {
- enforceSystemOrSystemUIOrVolume("INotificationManager.requestZenModeConditions");
- mZenModeHelper.requestZenModeConditions(callback, relevance);
- }
-
private void enforceSystemOrSystemUIOrVolume(String message) {
if (mAudioManagerInternal != null) {
final int vcuid = mAudioManagerInternal.getVolumeControllerUid();
message);
}
+ private void enforceSystemOrSystemUIOrSamePackage(String pkg, String message) {
+ try {
+ checkCallerIsSystemOrSameApp(pkg);
+ } catch (SecurityException e) {
+ getContext().enforceCallingPermission(
+ android.Manifest.permission.STATUS_BAR_SERVICE,
+ message);
+ }
+ }
+
+ private void enforcePolicyAccess(int uid, String method) {
+ if (PackageManager.PERMISSION_GRANTED == getContext().checkCallingPermission(
+ android.Manifest.permission.MANAGE_NOTIFICATIONS)) {
+ return;
+ }
+ boolean accessAllowed = false;
+ String[] packages = getContext().getPackageManager().getPackagesForUid(uid);
+ final int packageCount = packages.length;
+ for (int i = 0; i < packageCount; i++) {
+ if (checkPolicyAccess(packages[i])) {
+ accessAllowed = true;
+ }
+ }
+ if (!accessAllowed) {
+ Slog.w(TAG, "Notification policy access denied calling " + method);
+ throw new SecurityException("Notification policy access denied");
+ }
+ }
+
private void enforcePolicyAccess(String pkg, String method) {
+ if (PackageManager.PERMISSION_GRANTED == getContext().checkCallingPermission(
+ android.Manifest.permission.MANAGE_NOTIFICATIONS)) {
+ return;
+ }
+ checkCallerIsSameApp(pkg);
if (!checkPolicyAccess(pkg)) {
Slog.w(TAG, "Notification policy access denied calling " + method);
throw new SecurityException("Notification policy access denied");
}
private boolean checkPolicyAccess(String pkg) {
+ try {
+ int uid = getContext().getPackageManager().getPackageUidAsUser(
+ pkg, UserHandle.getCallingUserId());
+ if (PackageManager.PERMISSION_GRANTED == ActivityManager.checkComponentPermission(
+ android.Manifest.permission.MANAGE_NOTIFICATIONS, uid,
+ -1, true)) {
+ return true;
+ }
+ } catch (NameNotFoundException e) {
+ return false;
+ }
return checkPackagePolicyAccess(pkg) || mListeners.isComponentEnabledForPackage(pkg);
}
@Override
public ComponentName getEffectsSuppressor() {
enforceSystemOrSystemUIOrVolume("INotificationManager.getEffectsSuppressor");
- return mEffectsSuppressor;
+ return !mEffectsSuppressors.isEmpty() ? mEffectsSuppressors.get(0) : null;
}
@Override
public boolean matchesCallFilter(Bundle extras) {
enforceSystemOrSystemUI("INotificationManager.matchesCallFilter");
return mZenModeHelper.matchesCallFilter(
- UserHandle.getCallingUserHandle(),
+ Binder.getCallingUserHandle(),
extras,
mRankingHelper.findExtractor(ValidateNotificationPeople.class),
MATCHES_CALL_FILTER_CONTACTS_TIMEOUT_MS,
@Override
public byte[] getBackupPayload(int user) {
if (DBG) Slog.d(TAG, "getBackupPayload u=" + user);
- if (user != UserHandle.USER_OWNER) {
+ //TODO: http://b/22388012
+ if (user != UserHandle.USER_SYSTEM) {
Slog.w(TAG, "getBackupPayload: cannot backup policy for user " + user);
return null;
}
Slog.w(TAG, "applyRestore: no payload to restore for user " + user);
return;
}
- if (user != UserHandle.USER_OWNER) {
+ //TODO: http://b/22388012
+ if (user != UserHandle.USER_SYSTEM) {
Slog.w(TAG, "applyRestore: cannot restore policy for user " + user);
return;
}
}
@Override
- public boolean isNotificationPolicyAccessGrantedForPackage(String pkg) {
- enforceSystemOrSystemUI("request policy access status for another package");
- return checkPackagePolicyAccess(pkg);
+ public boolean isNotificationPolicyAccessGrantedForPackage(String pkg) {;
+ enforceSystemOrSystemUIOrSamePackage(pkg,
+ "request policy access status for another package");
+ return checkPolicyAccess(pkg);
}
@Override
Binder.restoreCallingIdentity(identity);
}
}
- };
- private String disableNotificationEffects(NotificationRecord record) {
- if (mDisableNotificationEffects) {
- return "booleanState";
- }
- if ((mListenerHints & HINT_HOST_DISABLE_EFFECTS) != 0) {
- return "listenerHints";
- }
- if (mCallState != TelephonyManager.CALL_STATE_IDLE && !mZenModeHelper.isCall(record)) {
- return "callState";
+ @Override
+ public void applyAdjustmentFromRankerService(INotificationListener token,
+ Adjustment adjustment) throws RemoteException {
+ final long identity = Binder.clearCallingIdentity();
+ try {
+ synchronized (mNotificationList) {
+ mRankerServices.checkServiceTokenLocked(token);
+ applyAdjustmentLocked(adjustment);
+ }
+ maybeAddAutobundleSummary(adjustment);
+ mRankingHandler.requestSort();
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
}
- return null;
- };
- private void dumpJson(PrintWriter pw, DumpFilter filter) {
- JSONObject dump = new JSONObject();
- try {
- dump.put("service", "Notification Manager");
- JSONArray bans = new JSONArray();
+ @Override
+ public void applyAdjustmentsFromRankerService(INotificationListener token,
+ List<Adjustment> adjustments) throws RemoteException {
+
+ final long identity = Binder.clearCallingIdentity();
try {
- ArrayMap<Integer, ArrayList<String>> packageBans = getPackageBans(filter);
- for (Integer userId : packageBans.keySet()) {
- for (String packageName : packageBans.get(userId)) {
- JSONObject ban = new JSONObject();
- ban.put("userId", userId);
- ban.put("packageName", packageName);
- bans.put(ban);
+ synchronized (mNotificationList) {
+ mRankerServices.checkServiceTokenLocked(token);
+ for (Adjustment adjustment : adjustments) {
+ applyAdjustmentLocked(adjustment);
}
}
- } catch (NameNotFoundException e) {
- // pass
+ for (Adjustment adjustment : adjustments) {
+ maybeAddAutobundleSummary(adjustment);
+ }
+ mRankingHandler.requestSort();
+ } finally {
+ Binder.restoreCallingIdentity(identity);
}
- dump.put("bans", bans);
- dump.put("stats", mUsageStats.dumpJson(filter));
- } catch (JSONException e) {
+ }
+ };
+
+ private void applyAdjustmentLocked(Adjustment adjustment) {
+ maybeClearAutobundleSummaryLocked(adjustment);
+ NotificationRecord n = mNotificationsByKey.get(adjustment.getKey());
+ if (n == null) {
+ return;
+ }
+ if (adjustment.getImportance() != IMPORTANCE_NONE) {
+ n.setImportance(adjustment.getImportance(), adjustment.getExplanation());
+ }
+ if (adjustment.getSignals() != null) {
+ Bundle.setDefusable(adjustment.getSignals(), true);
+ final String autoGroupKey = adjustment.getSignals().getString(
+ Adjustment.GROUP_KEY_OVERRIDE_KEY, null);
+ if (autoGroupKey == null) {
+ EventLogTags.writeNotificationUnautogrouped(adjustment.getKey());
+ } else {
+ EventLogTags.writeNotificationAutogrouped(adjustment.getKey());
+ }
+ n.sbn.setOverrideGroupKey(autoGroupKey);
+ }
+ }
+
+ // Clears the 'fake' auto-bunding summary.
+ private void maybeClearAutobundleSummaryLocked(Adjustment adjustment) {
+ if (adjustment.getSignals() != null) {
+ Bundle.setDefusable(adjustment.getSignals(), true);
+ if (adjustment.getSignals().containsKey(Adjustment.NEEDS_AUTOGROUPING_KEY)
+ && !adjustment.getSignals().getBoolean(Adjustment.NEEDS_AUTOGROUPING_KEY, false)) {
+ ArrayMap<String, String> summaries =
+ mAutobundledSummaries.get(adjustment.getUser());
+ if (summaries != null && summaries.containsKey(adjustment.getPackage())) {
+ // Clear summary.
+ final NotificationRecord removed = mNotificationsByKey.get(
+ summaries.remove(adjustment.getPackage()));
+ if (removed != null) {
+ mNotificationList.remove(removed);
+ cancelNotificationLocked(removed, false, REASON_UNAUTOBUNDLED);
+ }
+ }
+ }
+ }
+ }
+
+ // Posts a 'fake' summary for a package that has exceeded the solo-notification limit.
+ private void maybeAddAutobundleSummary(Adjustment adjustment) {
+ if (adjustment.getSignals() != null) {
+ Bundle.setDefusable(adjustment.getSignals(), true);
+ if (adjustment.getSignals().getBoolean(Adjustment.NEEDS_AUTOGROUPING_KEY, false)) {
+ final String newAutoBundleKey =
+ adjustment.getSignals().getString(Adjustment.GROUP_KEY_OVERRIDE_KEY, null);
+ int userId = -1;
+ NotificationRecord summaryRecord = null;
+ synchronized (mNotificationList) {
+ NotificationRecord notificationRecord =
+ mNotificationsByKey.get(adjustment.getKey());
+ if (notificationRecord == null) {
+ // The notification could have been cancelled again already. A successive
+ // adjustment will post a summary if needed.
+ return;
+ }
+ final StatusBarNotification adjustedSbn = notificationRecord.sbn;
+ userId = adjustedSbn.getUser().getIdentifier();
+ ArrayMap<String, String> summaries = mAutobundledSummaries.get(userId);
+ if (summaries == null) {
+ summaries = new ArrayMap<>();
+ }
+ mAutobundledSummaries.put(userId, summaries);
+ if (!summaries.containsKey(adjustment.getPackage())
+ && newAutoBundleKey != null) {
+ // Add summary
+ final ApplicationInfo appInfo =
+ adjustedSbn.getNotification().extras.getParcelable(
+ Notification.EXTRA_BUILDER_APPLICATION_INFO);
+ final Bundle extras = new Bundle();
+ extras.putParcelable(Notification.EXTRA_BUILDER_APPLICATION_INFO, appInfo);
+ final Notification summaryNotification =
+ new Notification.Builder(getContext()).setSmallIcon(
+ adjustedSbn.getNotification().getSmallIcon())
+ .setGroupSummary(true)
+ .setGroup(newAutoBundleKey)
+ .setFlag(Notification.FLAG_AUTOGROUP_SUMMARY, true)
+ .setFlag(Notification.FLAG_GROUP_SUMMARY, true)
+ .setColor(adjustedSbn.getNotification().color)
+ .setLocalOnly(true)
+ .build();
+ summaryNotification.extras.putAll(extras);
+ Intent appIntent = getContext().getPackageManager()
+ .getLaunchIntentForPackage(adjustment.getPackage());
+ if (appIntent != null) {
+ summaryNotification.contentIntent = PendingIntent.getActivityAsUser(
+ getContext(), 0, appIntent, 0, null,
+ UserHandle.of(userId));
+ }
+ final StatusBarNotification summarySbn =
+ new StatusBarNotification(adjustedSbn.getPackageName(),
+ adjustedSbn.getOpPkg(),
+ Integer.MAX_VALUE, Adjustment.GROUP_KEY_OVERRIDE_KEY,
+ adjustedSbn.getUid(), adjustedSbn.getInitialPid(),
+ summaryNotification, adjustedSbn.getUser(),
+ newAutoBundleKey,
+ System.currentTimeMillis());
+ summaryRecord = new NotificationRecord(getContext(), summarySbn);
+ summaries.put(adjustment.getPackage(), summarySbn.getKey());
+ }
+ }
+ if (summaryRecord != null) {
+ mHandler.post(new EnqueueNotificationRunnable(userId, summaryRecord));
+ }
+ }
+ }
+ }
+
+ private String disableNotificationEffects(NotificationRecord record) {
+ if (mDisableNotificationEffects) {
+ return "booleanState";
+ }
+ if ((mListenerHints & HINT_HOST_DISABLE_EFFECTS) != 0) {
+ return "listenerHints";
+ }
+ if (mCallState != TelephonyManager.CALL_STATE_IDLE && !mZenModeHelper.isCall(record)) {
+ return "callState";
+ }
+ return null;
+ };
+
+ private void dumpJson(PrintWriter pw, DumpFilter filter) {
+ JSONObject dump = new JSONObject();
+ try {
+ dump.put("service", "Notification Manager");
+ dump.put("bans", mRankingHelper.dumpBansJson(filter));
+ dump.put("ranking", mRankingHelper.dumpJson(filter));
+ dump.put("stats", mUsageStats.dumpJson(filter));
+ } catch (JSONException e) {
e.printStackTrace();
}
pw.println(dump);
pw.println(" mDisableNotificationEffects=" + mDisableNotificationEffects);
pw.println(" mCallState=" + callStateToString(mCallState));
pw.println(" mSystemReady=" + mSystemReady);
+ pw.println(" mMaxPackageEnqueueRate=" + mMaxPackageEnqueueRate);
}
pw.println(" mArchive=" + mArchive.toString());
Iterator<StatusBarNotification> iter = mArchive.descendingIterator();
pw.print(" mListenersDisablingEffects: (");
N = mListenersDisablingEffects.size();
for (int i = 0; i < N; i++) {
- final ManagedServiceInfo listener = mListenersDisablingEffects.valueAt(i);
- if (i > 0) pw.print(',');
- pw.print(listener.component);
+ final int hint = mListenersDisablingEffects.keyAt(i);
+ if (i > 0) pw.print(';');
+ pw.print("hint[" + hint + "]:");
+
+ final ArraySet<ManagedServiceInfo> listeners =
+ mListenersDisablingEffects.valueAt(i);
+ final int listenerSize = listeners.size();
+
+ for (int j = 0; j < listenerSize; j++) {
+ if (i > 0) pw.print(',');
+ final ManagedServiceInfo listener = listeners.valueAt(i);
+ pw.print(listener.component);
+ }
}
pw.println(')');
+ pw.println("\n mRankerServicePackageName: " + mRankerServicePackageName);
+ pw.println("\n Notification ranker services:");
+ mRankerServices.dump(pw, filter);
}
pw.println("\n Policy access:");
pw.print(" mPolicyAccess: "); pw.println(mPolicyAccess);
r.dump(pw, " ", getContext(), filter.redact);
}
}
-
- try {
- pw.println("\n Banned Packages:");
- ArrayMap<Integer, ArrayList<String>> packageBans = getPackageBans(filter);
- for (Integer userId : packageBans.keySet()) {
- for (String packageName : packageBans.get(userId)) {
- pw.println(" " + userId + ": " + packageName);
- }
- }
- } catch (NameNotFoundException e) {
- // pass
- }
- }
- }
-
- private ArrayMap<Integer, ArrayList<String>> getPackageBans(DumpFilter filter)
- throws NameNotFoundException {
- ArrayMap<Integer, ArrayList<String>> packageBans = new ArrayMap<>();
- ArrayList<String> packageNames = new ArrayList<>();
- for (UserInfo user : UserManager.get(getContext()).getUsers()) {
- final int userId = user.getUserHandle().getIdentifier();
- final PackageManager packageManager = getContext().getPackageManager();
- List<PackageInfo> packages = packageManager.getInstalledPackages(0, userId);
- final int packageCount = packages.size();
- for (int p = 0; p < packageCount; p++) {
- final String packageName = packages.get(p).packageName;
- if (filter == null || filter.matches(packageName)) {
- final int uid = packageManager.getPackageUid(packageName, userId);
- if (!checkNotificationOp(packageName, uid)) {
- packageNames.add(packageName);
- }
- }
- }
- if (!packageNames.isEmpty()) {
- packageBans.put(userId, packageNames);
- packageNames = new ArrayList<>();
- }
}
- return packageBans;
}
/**
callingUid, incomingUserId, true, false, "enqueueNotification", pkg);
final UserHandle user = new UserHandle(userId);
+ // Fix the notification as best we can.
+ try {
+ final ApplicationInfo ai = getContext().getPackageManager().getApplicationInfoAsUser(
+ pkg, PackageManager.MATCH_DEBUG_TRIAGED_MISSING,
+ (userId == UserHandle.USER_ALL) ? UserHandle.USER_SYSTEM : userId);
+ Notification.addFieldsFromContext(ai, userId, notification);
+ } catch (NameNotFoundException e) {
+ Slog.e(TAG, "Cannot create a context for sending app", e);
+ return;
+ }
+
+ mUsageStats.registerEnqueuedByApp(pkg);
+
// Limit the number of notifications that any given package except the android
// package or a registered listener can enqueue. Prevents DOS attacks and deals with leaks.
if (!isSystemNotification && !isNotificationFromListener) {
synchronized (mNotificationList) {
+ final float appEnqueueRate = mUsageStats.getAppEnqueueRate(pkg);
+ if (appEnqueueRate > mMaxPackageEnqueueRate) {
+ mUsageStats.registerOverRateQuota(pkg);
+ final long now = SystemClock.elapsedRealtime();
+ if ((now - mLastOverRateLogTime) > MIN_PACKAGE_OVERRATE_LOG_INTERVAL) {
+ Slog.e(TAG, "Package enqueue rate is " + appEnqueueRate
+ + ". Shedding events. package=" + pkg);
+ mLastOverRateLogTime = now;
+ }
+ return;
+ }
+
int count = 0;
final int N = mNotificationList.size();
for (int i=0; i<N; i++) {
}
count++;
if (count >= MAX_PACKAGE_NOTIFICATIONS) {
+ mUsageStats.registerOverCountQuota(pkg);
Slog.e(TAG, "Package has already posted " + count
+ " notifications. Not showing more. package=" + pkg);
return;
+ " id=" + id + " notification=" + notification);
}
- if (notification.getSmallIcon() != null) {
- if (!notification.isValid()) {
- throw new IllegalArgumentException("Invalid notification (): pkg=" + pkg
- + " id=" + id + " notification=" + notification);
+ // Whitelist pending intents.
+ if (notification.allPendingIntents != null) {
+ final int intentCount = notification.allPendingIntents.size();
+ if (intentCount > 0) {
+ final ActivityManagerInternal am = LocalServices
+ .getService(ActivityManagerInternal.class);
+ final long duration = LocalServices.getService(
+ DeviceIdleController.LocalService.class).getNotificationWhitelistDuration();
+ for (int i = 0; i < intentCount; i++) {
+ PendingIntent pendingIntent = notification.allPendingIntents.valueAt(i);
+ if (pendingIntent != null) {
+ am.setPendingIntentWhitelistDuration(pendingIntent.getTarget(), duration);
+ }
+ }
}
}
- mHandler.post(new Runnable() {
- @Override
- public void run() {
+ // Sanitize inputs
+ notification.priority = clamp(notification.priority, Notification.PRIORITY_MIN,
+ Notification.PRIORITY_MAX);
- synchronized (mNotificationList) {
+ // setup local book-keeping
+ final StatusBarNotification n = new StatusBarNotification(
+ pkg, opPkg, id, tag, callingUid, callingPid, 0, notification,
+ user);
+ final NotificationRecord r = new NotificationRecord(getContext(), n);
+ mHandler.post(new EnqueueNotificationRunnable(userId, r));
- // === Scoring ===
+ idOut[0] = id;
+ }
- // 0. Sanitize inputs
- notification.priority = clamp(notification.priority, Notification.PRIORITY_MIN,
- Notification.PRIORITY_MAX);
- // Migrate notification flags to scores
- if (0 != (notification.flags & Notification.FLAG_HIGH_PRIORITY)) {
- if (notification.priority < Notification.PRIORITY_MAX) {
- notification.priority = Notification.PRIORITY_MAX;
- }
- } else if (SCORE_ONGOING_HIGHER &&
- 0 != (notification.flags & Notification.FLAG_ONGOING_EVENT)) {
- if (notification.priority < Notification.PRIORITY_HIGH) {
- notification.priority = Notification.PRIORITY_HIGH;
- }
- }
- // force no heads up per package config
- if (!mRankingHelper.getPackagePeekable(pkg, callingUid)) {
- if (notification.extras == null) {
- notification.extras = new Bundle();
- }
- notification.extras.putInt(Notification.EXTRA_AS_HEADS_UP,
- Notification.HEADS_UP_NEVER);
- }
+ private class EnqueueNotificationRunnable implements Runnable {
+ private final NotificationRecord r;
+ private final int userId;
- // 1. initial score: buckets of 10, around the app [-20..20]
- final int score = notification.priority * NOTIFICATION_PRIORITY_MULTIPLIER;
+ EnqueueNotificationRunnable(int userId, NotificationRecord r) {
+ this.userId = userId;
+ this.r = r;
+ };
- // 2. extract ranking signals from the notification data
- final StatusBarNotification n = new StatusBarNotification(
- pkg, opPkg, id, tag, callingUid, callingPid, score, notification,
- user);
- NotificationRecord r = new NotificationRecord(n, score);
- NotificationRecord old = mNotificationsByKey.get(n.getKey());
- if (old != null) {
- // Retain ranking information from previous record
- r.copyRankingInformation(old);
- }
+ @Override
+ public void run() {
- // Handle grouped notifications and bail out early if we
- // can to avoid extracting signals.
- handleGroupedNotificationLocked(r, old, callingUid, callingPid);
- boolean ignoreNotification =
- removeUnusedGroupedNotificationLocked(r, old, callingUid, callingPid);
-
- // This conditional is a dirty hack to limit the logging done on
- // behalf of the download manager without affecting other apps.
- if (!pkg.equals("com.android.providers.downloads")
- || Log.isLoggable("DownloadManager", Log.VERBOSE)) {
- int enqueueStatus = EVENTLOG_ENQUEUE_STATUS_NEW;
- if (ignoreNotification) {
- enqueueStatus = EVENTLOG_ENQUEUE_STATUS_IGNORED;
- } else if (old != null) {
- enqueueStatus = EVENTLOG_ENQUEUE_STATUS_UPDATE;
- }
- EventLogTags.writeNotificationEnqueue(callingUid, callingPid,
- pkg, id, tag, userId, notification.toString(),
- enqueueStatus);
- }
+ synchronized (mNotificationList) {
+ final StatusBarNotification n = r.sbn;
+ if (DBG) Slog.d(TAG, "EnqueueNotificationRunnable.run for: " + n.getKey());
+ NotificationRecord old = mNotificationsByKey.get(n.getKey());
+ if (old != null) {
+ // Retain ranking information from previous record
+ r.copyRankingInformation(old);
+ }
- if (ignoreNotification) {
- return;
+ final int callingUid = n.getUid();
+ final int callingPid = n.getInitialPid();
+ final Notification notification = n.getNotification();
+ final String pkg = n.getPackageName();
+ final int id = n.getId();
+ final String tag = n.getTag();
+ final boolean isSystemNotification = isUidSystem(callingUid) ||
+ ("android".equals(pkg));
+
+ // Handle grouped notifications and bail out early if we
+ // can to avoid extracting signals.
+ handleGroupedNotificationLocked(r, old, callingUid, callingPid);
+
+ // This conditional is a dirty hack to limit the logging done on
+ // behalf of the download manager without affecting other apps.
+ if (!pkg.equals("com.android.providers.downloads")
+ || Log.isLoggable("DownloadManager", Log.VERBOSE)) {
+ int enqueueStatus = EVENTLOG_ENQUEUE_STATUS_NEW;
+ if (old != null) {
+ enqueueStatus = EVENTLOG_ENQUEUE_STATUS_UPDATE;
}
+ EventLogTags.writeNotificationEnqueue(callingUid, callingPid,
+ pkg, id, tag, userId, notification.toString(),
+ enqueueStatus);
+ }
- mRankingHelper.extractSignals(r);
+ mRankingHelper.extractSignals(r);
- // 3. Apply local rules
+ final boolean isPackageSuspended = isPackageSuspendedForUser(pkg, callingUid);
- // blocked apps
- if (ENABLE_BLOCKED_NOTIFICATIONS && !noteNotificationOp(pkg, callingUid)) {
- if (!isSystemNotification) {
- r.score = JUNK_SCORE;
- Slog.e(TAG, "Suppressing notification from package " + pkg
- + " by user request.");
+ // blocked apps
+ if (r.getImportance() == NotificationListenerService.Ranking.IMPORTANCE_NONE
+ || !noteNotificationOp(pkg, callingUid) || isPackageSuspended) {
+ if (!isSystemNotification) {
+ if (isPackageSuspended) {
+ Slog.e(TAG, "Suppressing notification from package due to package "
+ + "suspended by administrator.");
+ mUsageStats.registerSuspendedByAdmin(r);
+ } else {
+ Slog.e(TAG, "Suppressing notification from package by user request.");
mUsageStats.registerBlocked(r);
}
- }
-
- if (r.score < SCORE_DISPLAY_THRESHOLD) {
- // Notification will be blocked because the score is too low.
return;
}
+ }
- int index = indexOfNotificationLocked(n.getKey());
- if (index < 0) {
- mNotificationList.add(r);
- mUsageStats.registerPostedByApp(r);
- } else {
- old = mNotificationList.get(index);
- mNotificationList.set(index, r);
- mUsageStats.registerUpdatedByApp(r, old);
- // Make sure we don't lose the foreground service state.
- notification.flags |=
- old.getNotification().flags & Notification.FLAG_FOREGROUND_SERVICE;
- r.isUpdate = true;
- }
+ // tell the ranker service about the notification
+ if (mRankerServices.isEnabled()) {
+ mRankerServices.onNotificationEnqueued(r);
+ // TODO delay the code below here for 100ms or until there is an answer
+ }
- mNotificationsByKey.put(n.getKey(), r);
- // Ensure if this is a foreground service that the proper additional
- // flags are set.
- if ((notification.flags & Notification.FLAG_FOREGROUND_SERVICE) != 0) {
- notification.flags |= Notification.FLAG_ONGOING_EVENT
- | Notification.FLAG_NO_CLEAR;
- }
+ int index = indexOfNotificationLocked(n.getKey());
+ if (index < 0) {
+ mNotificationList.add(r);
+ mUsageStats.registerPostedByApp(r);
+ } else {
+ old = mNotificationList.get(index);
+ mNotificationList.set(index, r);
+ mUsageStats.registerUpdatedByApp(r, old);
+ // Make sure we don't lose the foreground service state.
+ notification.flags |=
+ old.getNotification().flags & Notification.FLAG_FOREGROUND_SERVICE;
+ r.isUpdate = true;
+ }
- applyZenModeLocked(r);
- mRankingHelper.sort(mNotificationList);
+ mNotificationsByKey.put(n.getKey(), r);
- if (notification.getSmallIcon() != null) {
- StatusBarNotification oldSbn = (old != null) ? old.sbn : null;
- mListeners.notifyPostedLocked(n, oldSbn);
- } else {
- Slog.e(TAG, "Not posting notification without small icon: " + notification);
- if (old != null && !old.isCanceled) {
- mListeners.notifyRemovedLocked(n);
- }
- // ATTENTION: in a future release we will bail out here
- // so that we do not play sounds, show lights, etc. for invalid
- // notifications
- Slog.e(TAG, "WARNING: In a future release this will crash the app: "
- + n.getPackageName());
- }
+ // Ensure if this is a foreground service that the proper additional
+ // flags are set.
+ if ((notification.flags & Notification.FLAG_FOREGROUND_SERVICE) != 0) {
+ notification.flags |= Notification.FLAG_ONGOING_EVENT
+ | Notification.FLAG_NO_CLEAR;
+ }
+
+ applyZenModeLocked(r);
+ mRankingHelper.sort(mNotificationList);
- buzzBeepBlinkLocked(r);
+ if (notification.getSmallIcon() != null) {
+ StatusBarNotification oldSbn = (old != null) ? old.sbn : null;
+ mListeners.notifyPostedLocked(n, oldSbn);
+ } else {
+ Slog.e(TAG, "Not posting notification without small icon: " + notification);
+ if (old != null && !old.isCanceled) {
+ mListeners.notifyRemovedLocked(n);
+ }
+ // ATTENTION: in a future release we will bail out here
+ // so that we do not play sounds, show lights, etc. for invalid
+ // notifications
+ Slog.e(TAG, "WARNING: In a future release this will crash the app: "
+ + n.getPackageName());
}
- }
- });
- idOut[0] = id;
+ buzzBeepBlinkLocked(r);
+ }
+ }
}
/**
int callingUid, int callingPid) {
StatusBarNotification sbn = r.sbn;
Notification n = sbn.getNotification();
+ if (n.isGroupSummary() && !sbn.isAppGroup()) {
+ // notifications without a group shouldn't be a summary, otherwise autobundling can
+ // lead to bugs
+ n.flags &= ~Notification.FLAG_GROUP_SUMMARY;
+ }
+
String group = sbn.getGroupKey();
boolean isSummary = n.isGroupSummary();
// notification was a summary and its group key changed.
if (oldIsSummary && (!isSummary || !oldGroup.equals(group))) {
cancelGroupChildrenLocked(old, callingUid, callingPid, null,
- REASON_GROUP_SUMMARY_CANCELED);
- }
- }
-
- /**
- * Performs group notification optimizations if SysUI is the only active
- * notification listener and returns whether the given notification should
- * be ignored.
- *
- * <p>Returns true if the given notification is a child of a group with a
- * summary, which means that SysUI will never show it, and hence the new
- * notification can be safely ignored. Also cancels any previous instance
- * of the ignored notification.</p>
- *
- * <p>For summaries, cancels all children of that group, as SysUI will
- * never show them anymore.</p>
- *
- * @return true if the given notification can be ignored as an optimization
- */
- private boolean removeUnusedGroupedNotificationLocked(NotificationRecord r,
- NotificationRecord old, int callingUid, int callingPid) {
- if (!ENABLE_CHILD_NOTIFICATIONS) {
- // No optimizations are possible if listeners want groups.
- if (mListeners.notificationGroupsDesired()) {
- return false;
- }
-
- StatusBarNotification sbn = r.sbn;
- String group = sbn.getGroupKey();
- boolean isSummary = sbn.getNotification().isGroupSummary();
- boolean isChild = sbn.getNotification().isGroupChild();
-
- NotificationRecord summary = mSummaryByGroupKey.get(group);
- if (isChild && summary != null) {
- // Child with an active summary -> ignore
- if (DBG) {
- Slog.d(TAG, "Ignoring group child " + sbn.getKey() + " due to existing summary "
- + summary.getKey());
- }
- // Make sure we don't leave an old version of the notification around.
- if (old != null) {
- if (DBG) {
- Slog.d(TAG, "Canceling old version of ignored group child " + sbn.getKey());
- }
- cancelNotificationLocked(old, false, REASON_GROUP_OPTIMIZATION);
- }
- return true;
- } else if (isSummary) {
- // Summary -> cancel children
- cancelGroupChildrenLocked(r, callingUid, callingPid, null,
- REASON_GROUP_OPTIMIZATION);
- }
+ REASON_GROUP_SUMMARY_CANCELED, false /* sendDelete */);
}
- return false;
}
- private void buzzBeepBlinkLocked(NotificationRecord record) {
+ @VisibleForTesting
+ void buzzBeepBlinkLocked(NotificationRecord record) {
boolean buzz = false;
boolean beep = false;
boolean blink = false;
final Notification notification = record.sbn.getNotification();
+ final String key = record.getKey();
// Should this notification make noise, vibe, or use the LED?
- final boolean aboveThreshold = record.score >= SCORE_INTERRUPTION_THRESHOLD;
+ final boolean aboveThreshold = record.getImportance() >= IMPORTANCE_DEFAULT;
final boolean canInterrupt = aboveThreshold && !record.isIntercepted();
if (DBG || record.isIntercepted())
Slog.v(TAG,
if (disableEffects != null) {
ZenLog.traceDisableEffects(record, disableEffects);
}
+
+ // Remember if this notification already owns the notification channels.
+ boolean wasBeep = key != null && key.equals(mSoundNotificationKey);
+ boolean wasBuzz = key != null && key.equals(mVibrateNotificationKey);
+
+ // These are set inside the conditional if the notification is allowed to make noise.
+ boolean hasValidVibrate = false;
+ boolean hasValidSound = false;
if (disableEffects == null
- && (!(record.isUpdate
- && (notification.flags & Notification.FLAG_ONLY_ALERT_ONCE) != 0 ))
&& (record.getUserId() == UserHandle.USER_ALL ||
record.getUserId() == currentUser ||
mUserProfiles.isCurrentProfile(record.getUserId()))
&& mAudioManager != null) {
if (DBG) Slog.v(TAG, "Interrupting!");
- sendAccessibilityEvent(notification, record.sbn.getPackageName());
-
- // sound
-
// should we use the default notification sound? (indicated either by
// DEFAULT_SOUND or because notification.sound is pointing at
// Settings.System.NOTIFICATION_SOUND)
.equals(notification.sound);
Uri soundUri = null;
- boolean hasValidSound = false;
-
if (useDefaultSound) {
soundUri = Settings.System.DEFAULT_NOTIFICATION_URI;
// check to see if the default notification sound is silent
- ContentResolver resolver = getContext().getContentResolver();
- hasValidSound = Settings.System.getString(resolver,
- Settings.System.NOTIFICATION_SOUND) != null;
+ hasValidSound = mSystemNotificationSound != null;
} else if (notification.sound != null) {
soundUri = notification.sound;
hasValidSound = (soundUri != null);
}
- if (hasValidSound) {
- boolean looping =
- (notification.flags & Notification.FLAG_INSISTENT) != 0;
- AudioAttributes audioAttributes = audioAttributesForNotification(notification);
- mSoundNotificationKey = record.getKey();
- // do not play notifications if stream volume is 0 (typically because
- // ringer mode is silent) or if there is a user of exclusive audio focus
- if ((mAudioManager.getStreamVolume(
- AudioAttributes.toLegacyStreamType(audioAttributes)) != 0)
- && !mAudioManager.isAudioFocusExclusive()) {
- final long identity = Binder.clearCallingIdentity();
- try {
- final IRingtonePlayer player =
- mAudioManager.getRingtonePlayer();
- if (player != null) {
- if (DBG) Slog.v(TAG, "Playing sound " + soundUri
- + " with attributes " + audioAttributes);
- player.playAsync(soundUri, record.sbn.getUser(), looping,
- audioAttributes);
- beep = true;
- }
- } catch (RemoteException e) {
- } finally {
- Binder.restoreCallingIdentity(identity);
- }
- }
- }
-
- // vibrate
// Does the notification want to specify its own vibration?
final boolean hasCustomVibrate = notification.vibrate != null;
// new in 4.2: if there was supposed to be a sound and we're in vibrate
// mode, and no other vibration is specified, we fall back to vibration
final boolean convertSoundToVibration =
- !hasCustomVibrate
- && hasValidSound
- && (mAudioManager.getRingerModeInternal()
- == AudioManager.RINGER_MODE_VIBRATE);
+ !hasCustomVibrate
+ && hasValidSound
+ && (mAudioManager.getRingerModeInternal() == AudioManager.RINGER_MODE_VIBRATE);
// The DEFAULT_VIBRATE flag trumps any custom vibration AND the fallback.
final boolean useDefaultVibrate =
(notification.defaults & Notification.DEFAULT_VIBRATE) != 0;
- if ((useDefaultVibrate || convertSoundToVibration || hasCustomVibrate)
- && !(mAudioManager.getRingerModeInternal()
- == AudioManager.RINGER_MODE_SILENT)) {
- mVibrateNotificationKey = record.getKey();
+ hasValidVibrate = useDefaultVibrate || convertSoundToVibration ||
+ hasCustomVibrate;
+
+ // We can alert, and we're allowed to alert, but if the developer asked us to only do
+ // it once, and we already have, then don't.
+ if (!(record.isUpdate
+ && (notification.flags & Notification.FLAG_ONLY_ALERT_ONCE) != 0)) {
+
+ sendAccessibilityEvent(notification, record.sbn.getPackageName());
+
+ if (hasValidSound) {
+ boolean looping =
+ (notification.flags & Notification.FLAG_INSISTENT) != 0;
+ AudioAttributes audioAttributes = audioAttributesForNotification(notification);
+ mSoundNotificationKey = key;
+ // do not play notifications if stream volume is 0 (typically because
+ // ringer mode is silent) or if there is a user of exclusive audio focus
+ if ((mAudioManager.getStreamVolume(
+ AudioAttributes.toLegacyStreamType(audioAttributes)) != 0)
+ && !mAudioManager.isAudioFocusExclusive()) {
+ final long identity = Binder.clearCallingIdentity();
+ try {
+ final IRingtonePlayer player =
+ mAudioManager.getRingtonePlayer();
+ if (player != null) {
+ if (DBG) Slog.v(TAG, "Playing sound " + soundUri
+ + " with attributes " + audioAttributes);
+ player.playAsync(soundUri, record.sbn.getUser(), looping,
+ audioAttributes);
+ beep = true;
+ }
+ } catch (RemoteException e) {
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ }
+ }
- if (useDefaultVibrate || convertSoundToVibration) {
- // Escalate privileges so we can use the vibrator even if the
- // notifying app does not have the VIBRATE permission.
- long identity = Binder.clearCallingIdentity();
- try {
+ if (hasValidVibrate && !(mAudioManager.getRingerModeInternal()
+ == AudioManager.RINGER_MODE_SILENT)) {
+ mVibrateNotificationKey = key;
+
+ if (useDefaultVibrate || convertSoundToVibration) {
+ // Escalate privileges so we can use the vibrator even if the
+ // notifying app does not have the VIBRATE permission.
+ long identity = Binder.clearCallingIdentity();
+ try {
+ mVibrator.vibrate(record.sbn.getUid(), record.sbn.getOpPkg(),
+ useDefaultVibrate ? mDefaultVibrationPattern
+ : mFallbackVibrationPattern,
+ ((notification.flags & Notification.FLAG_INSISTENT) != 0)
+ ? 0: -1, audioAttributesForNotification(notification));
+ buzz = true;
+ } finally {
+ Binder.restoreCallingIdentity(identity);
+ }
+ } else if (notification.vibrate.length > 1) {
+ // If you want your own vibration pattern, you need the VIBRATE
+ // permission
mVibrator.vibrate(record.sbn.getUid(), record.sbn.getOpPkg(),
- useDefaultVibrate ? mDefaultVibrationPattern
- : mFallbackVibrationPattern,
- ((notification.flags & Notification.FLAG_INSISTENT) != 0)
- ? 0: -1, audioAttributesForNotification(notification));
+ notification.vibrate,
+ ((notification.flags & Notification.FLAG_INSISTENT) != 0)
+ ? 0: -1, audioAttributesForNotification(notification));
buzz = true;
- } finally {
- Binder.restoreCallingIdentity(identity);
}
- } else if (notification.vibrate.length > 1) {
- // If you want your own vibration pattern, you need the VIBRATE
- // permission
- mVibrator.vibrate(record.sbn.getUid(), record.sbn.getOpPkg(),
- notification.vibrate,
- ((notification.flags & Notification.FLAG_INSISTENT) != 0)
- ? 0: -1, audioAttributesForNotification(notification));
- buzz = true;
}
}
+
+ }
+ // If a notification is updated to remove the actively playing sound or vibrate,
+ // cancel that feedback now
+ if (wasBeep && !hasValidSound) {
+ clearSoundLocked();
+ }
+ if (wasBuzz && !hasValidVibrate) {
+ clearVibrateLocked();
}
// light
// release the light
- boolean wasShowLights = mLights.remove(record.getKey());
- if ((notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0 && aboveThreshold) {
- mLights.add(record.getKey());
+ boolean wasShowLights = mLights.remove(key);
+ if ((notification.flags & Notification.FLAG_SHOW_LIGHTS) != 0 && aboveThreshold
+ && ((record.getSuppressedVisualEffects()
+ & NotificationListenerService.SUPPRESSED_EFFECT_SCREEN_OFF) == 0)) {
+ mLights.add(key);
updateLightsLocked();
if (mUseAttentionLight) {
mAttentionLight.pulse();
updateLightsLocked();
}
if (buzz || beep || blink) {
- EventLogTags.writeNotificationAlert(record.getKey(),
- buzz ? 1 : 0, beep ? 1 : 0, blink ? 1 : 0);
- mHandler.post(mBuzzBeepBlinked);
+ if (((record.getSuppressedVisualEffects()
+ & NotificationListenerService.SUPPRESSED_EFFECT_SCREEN_OFF) != 0)) {
+ if (DBG) Slog.v(TAG, "Suppressed SystemUI from triggering screen on");
+ } else {
+ EventLogTags.writeNotificationAlert(key,
+ buzz ? 1 : 0, beep ? 1 : 0, blink ? 1 : 0);
+ mHandler.post(mBuzzBeepBlinked);
+ }
}
}
}
}
- private void handleRankingConfigChange() {
+ private void handleRankingSort() {
synchronized (mNotificationList) {
final int N = mNotificationList.size();
ArrayList<String> orderBefore = new ArrayList<String>(N);
+ ArrayList<String> groupOverrideBefore = new ArrayList<>(N);
int[] visibilities = new int[N];
+ int[] importances = new int[N];
for (int i = 0; i < N; i++) {
final NotificationRecord r = mNotificationList.get(i);
orderBefore.add(r.getKey());
+ groupOverrideBefore.add(r.sbn.getGroupKey());
visibilities[i] = r.getPackageVisibilityOverride();
+ importances[i] = r.getImportance();
mRankingHelper.extractSignals(r);
}
+ mRankingHelper.sort(mNotificationList);
for (int i = 0; i < N; i++) {
- mRankingHelper.sort(mNotificationList);
final NotificationRecord r = mNotificationList.get(i);
if (!orderBefore.get(i).equals(r.getKey())
- || visibilities[i] != r.getPackageVisibilityOverride()) {
+ || visibilities[i] != r.getPackageVisibilityOverride()
+ || importances[i] != r.getImportance()
+ || !groupOverrideBefore.get(i).equals(r.sbn.getGroupKey())) {
scheduleSendRankingUpdate();
return;
}
// let zen mode evaluate this record
private void applyZenModeLocked(NotificationRecord record) {
record.setIntercepted(mZenModeHelper.shouldIntercept(record));
+ if (record.isIntercepted()) {
+ int suppressed = (mZenModeHelper.shouldSuppressWhenScreenOff()
+ ? SUPPRESSED_EFFECT_SCREEN_OFF : 0)
+ | (mZenModeHelper.shouldSuppressWhenScreenOn()
+ ? SUPPRESSED_EFFECT_SCREEN_ON : 0);
+ record.setSuppressedVisualEffects(suppressed);
+ }
}
// lock on mNotificationList
}
private void scheduleSendRankingUpdate() {
- mHandler.removeMessages(MESSAGE_SEND_RANKING_UPDATE);
- Message m = Message.obtain(mHandler, MESSAGE_SEND_RANKING_UPDATE);
- mHandler.sendMessage(m);
+ if (!mHandler.hasMessages(MESSAGE_SEND_RANKING_UPDATE)) {
+ Message m = Message.obtain(mHandler, MESSAGE_SEND_RANKING_UPDATE);
+ mHandler.sendMessage(m);
+ }
}
private void handleSendRankingUpdate() {
}
- private final class RankingWorkerHandler extends Handler
+ private final class RankingHandlerWorker extends Handler implements RankingHandler
{
- public RankingWorkerHandler(Looper looper) {
+ public RankingHandlerWorker(Looper looper) {
super(looper);
}
case MESSAGE_RECONSIDER_RANKING:
handleRankingReconsideration(msg);
break;
- case MESSAGE_RANKING_CONFIG_CHANGE:
- handleRankingConfigChange();
+ case MESSAGE_RANKING_SORT:
+ handleRankingSort();
break;
}
}
+
+ public void requestSort() {
+ removeMessages(MESSAGE_RANKING_SORT);
+ sendEmptyMessage(MESSAGE_RANKING_SORT);
+ }
+
+ public void requestReconsideration(RankingReconsideration recon) {
+ Message m = Message.obtain(this,
+ NotificationManagerService.MESSAGE_RECONSIDER_RANKING, recon);
+ long delay = recon.getDelay(TimeUnit.MILLISECONDS);
+ sendMessageDelayed(m, delay);
+ }
}
// Notifications
mLights.remove(canceledKey);
// Record usage stats
+ // TODO: add unbundling stats?
switch (reason) {
case REASON_DELEGATE_CANCEL:
case REASON_DELEGATE_CANCEL_ALL:
case REASON_LISTENER_CANCEL_ALL:
mUsageStats.registerDismissedByUser(r);
break;
- case REASON_NOMAN_CANCEL:
- case REASON_NOMAN_CANCEL_ALL:
+ case REASON_APP_CANCEL:
+ case REASON_APP_CANCEL_ALL:
mUsageStats.registerRemovedByApp(r);
break;
}
if (groupSummary != null && groupSummary.getKey().equals(r.getKey())) {
mSummaryByGroupKey.remove(groupKey);
}
+ final ArrayMap<String, String> summaries = mAutobundledSummaries.get(r.sbn.getUserId());
+ if (summaries != null && r.sbn.getKey().equals(summaries.get(r.sbn.getPackageName()))) {
+ summaries.remove(r.sbn.getPackageName());
+ }
// Save it for users of getHistoricalNotifications()
mArchive.record(r.sbn);
cancelNotificationLocked(r, sendDelete, reason);
cancelGroupChildrenLocked(r, callingUid, callingPid, listenerName,
- REASON_GROUP_SUMMARY_CANCELED);
+ REASON_GROUP_SUMMARY_CANCELED, sendDelete);
updateLightsLocked();
}
}
final int M = canceledNotifications.size();
for (int i = 0; i < M; i++) {
cancelGroupChildrenLocked(canceledNotifications.get(i), callingUid, callingPid,
- listenerName, REASON_GROUP_SUMMARY_CANCELED);
+ listenerName, REASON_GROUP_SUMMARY_CANCELED, false /* sendDelete */);
}
}
if (canceledNotifications != null) {
int M = canceledNotifications != null ? canceledNotifications.size() : 0;
for (int i = 0; i < M; i++) {
cancelGroupChildrenLocked(canceledNotifications.get(i), callingUid, callingPid,
- listenerName, REASON_GROUP_SUMMARY_CANCELED);
+ listenerName, REASON_GROUP_SUMMARY_CANCELED, false /* sendDelete */);
}
updateLightsLocked();
}
// Warning: The caller is responsible for invoking updateLightsLocked().
private void cancelGroupChildrenLocked(NotificationRecord r, int callingUid, int callingPid,
- String listenerName, int reason) {
+ String listenerName, int reason, boolean sendDelete) {
Notification n = r.getNotification();
if (!n.isGroupSummary()) {
return;
for (int i = N - 1; i >= 0; i--) {
NotificationRecord childR = mNotificationList.get(i);
StatusBarNotification childSbn = childR.sbn;
- if (childR.getNotification().isGroupChild() &&
+ if ((childSbn.isGroup() && !childSbn.getNotification().isGroupSummary()) &&
childR.getGroupKey().equals(r.getGroupKey())) {
EventLogTags.writeNotificationCancel(callingUid, callingPid, pkg, childSbn.getId(),
childSbn.getTag(), userId, 0, 0, reason, listenerName);
mNotificationList.remove(i);
- cancelNotificationLocked(childR, false, reason);
+ cancelNotificationLocked(childR, sendDelete, reason);
}
}
}
// Don't flash while we are in a call or screen is on
if (ledNotification == null || mInCall || mScreenOn) {
mNotificationLight.turnOff();
- mStatusBar.notificationLightOff();
+ if (mStatusBar != null) {
+ mStatusBar.notificationLightOff();
+ }
} else {
final Notification ledno = ledNotification.sbn.getNotification();
int ledARGB = ledno.ledARGB;
mNotificationLight.setFlashing(ledARGB, Light.LIGHT_FLASH_TIMED,
ledOnMS, ledOffMS);
}
- // let SystemUI make an independent decision
- mStatusBar.notificationLightPulse(ledARGB, ledOnMS, ledOffMS);
+ if (mStatusBar != null) {
+ // let SystemUI make an independent decision
+ mStatusBar.notificationLightPulse(ledARGB, ledOnMS, ledOffMS);
+ }
}
}
if (isCallerSystem()) {
return;
}
+ checkCallerIsSameApp(pkg);
+ }
+
+ private static void checkCallerIsSameApp(String pkg) {
final int uid = Binder.getCallingUid();
try {
ApplicationInfo ai = AppGlobals.getPackageManager().getApplicationInfo(
* <p>Caller must hold a lock on mNotificationList.</p>
*/
private NotificationRankingUpdate makeRankingUpdateLocked(ManagedServiceInfo info) {
- int speedBumpIndex = -1;
final int N = mNotificationList.size();
ArrayList<String> keys = new ArrayList<String>(N);
ArrayList<String> interceptedKeys = new ArrayList<String>(N);
+ ArrayList<Integer> importance = new ArrayList<>(N);
+ Bundle overrideGroupKeys = new Bundle();
Bundle visibilityOverrides = new Bundle();
+ Bundle suppressedVisualEffects = new Bundle();
+ Bundle explanation = new Bundle();
for (int i = 0; i < N; i++) {
NotificationRecord record = mNotificationList.get(i);
if (!isVisibleToListener(record.sbn, info)) {
continue;
}
- keys.add(record.sbn.getKey());
+ final String key = record.sbn.getKey();
+ keys.add(key);
+ importance.add(record.getImportance());
+ if (record.getImportanceExplanation() != null) {
+ explanation.putCharSequence(key, record.getImportanceExplanation());
+ }
if (record.isIntercepted()) {
- interceptedKeys.add(record.sbn.getKey());
+ interceptedKeys.add(key);
+
}
+ suppressedVisualEffects.putInt(key, record.getSuppressedVisualEffects());
if (record.getPackageVisibilityOverride()
!= NotificationListenerService.Ranking.VISIBILITY_NO_OVERRIDE) {
- visibilityOverrides.putInt(record.sbn.getKey(),
- record.getPackageVisibilityOverride());
- }
- // Find first min-prio notification for speedbump placement.
- if (speedBumpIndex == -1 &&
- // Intrusiveness trumps priority, hence ignore intrusives.
- !record.isRecentlyIntrusive() &&
- // Currently, package priority is either PRIORITY_DEFAULT or PRIORITY_MAX, so
- // scanning for PRIORITY_MIN within the package bucket PRIORITY_DEFAULT
- // (or lower as a safeguard) is sufficient to find the speedbump index.
- // We'll have to revisit this when more package priority buckets are introduced.
- record.getPackagePriority() <= Notification.PRIORITY_DEFAULT &&
- record.sbn.getNotification().priority == Notification.PRIORITY_MIN) {
- speedBumpIndex = keys.size() - 1;
- }
- }
- String[] keysAr = keys.toArray(new String[keys.size()]);
+ visibilityOverrides.putInt(key, record.getPackageVisibilityOverride());
+ }
+ overrideGroupKeys.putString(key, record.sbn.getOverrideGroupKey());
+ }
+ final int M = keys.size();
+ String[] keysAr = keys.toArray(new String[M]);
String[] interceptedKeysAr = interceptedKeys.toArray(new String[interceptedKeys.size()]);
+ int[] importanceAr = new int[M];
+ for (int i = 0; i < M; i++) {
+ importanceAr[i] = importance.get(i);
+ }
return new NotificationRankingUpdate(keysAr, interceptedKeysAr, visibilityOverrides,
- speedBumpIndex);
+ suppressedVisualEffects, importanceAr, explanation, overrideGroupKeys);
}
private boolean isVisibleToListener(StatusBarNotification sbn, ManagedServiceInfo listener) {
return true;
}
+ private boolean isPackageSuspendedForUser(String pkg, int uid) {
+ int userId = UserHandle.getUserId(uid);
+ try {
+ return AppGlobals.getPackageManager().isPackageSuspendedForUser(pkg, userId);
+ } catch (RemoteException re) {
+ throw new SecurityException("Could not talk to package manager service");
+ } catch (IllegalArgumentException ex) {
+ // Package not found.
+ return false;
+ }
+ }
+
+ private class TrimCache {
+ StatusBarNotification heavy;
+ StatusBarNotification sbnClone;
+ StatusBarNotification sbnCloneLight;
+
+ TrimCache(StatusBarNotification sbn) {
+ heavy = sbn;
+ }
+
+ StatusBarNotification ForListener(ManagedServiceInfo info) {
+ if (mListeners.getOnNotificationPostedTrim(info) == TRIM_LIGHT) {
+ if (sbnCloneLight == null) {
+ sbnCloneLight = heavy.cloneLight();
+ }
+ return sbnCloneLight;
+ } else {
+ if (sbnClone == null) {
+ sbnClone = heavy.clone();
+ }
+ return sbnClone;
+ }
+ }
+ }
+
+ public class NotificationRankers extends ManagedServices {
+
+ public NotificationRankers() {
+ super(getContext(), mHandler, mNotificationList, mUserProfiles);
+ }
+
+ @Override
+ protected Config getConfig() {
+ Config c = new Config();
+ c.caption = "notification ranker service";
+ c.serviceInterface = NotificationRankerService.SERVICE_INTERFACE;
+ c.secureSettingName = null;
+ c.bindPermission = Manifest.permission.BIND_NOTIFICATION_RANKER_SERVICE;
+ c.settingsAction = Settings.ACTION_MANAGE_DEFAULT_APPS_SETTINGS;
+ c.clientLabel = R.string.notification_ranker_binding_label;
+ return c;
+ }
+
+ @Override
+ protected IInterface asInterface(IBinder binder) {
+ return INotificationListener.Stub.asInterface(binder);
+ }
+
+ @Override
+ protected boolean checkType(IInterface service) {
+ return service instanceof INotificationListener;
+ }
+
+ @Override
+ protected void onServiceAdded(ManagedServiceInfo info) {
+ mListeners.registerGuestService(info);
+ }
+
+ @Override
+ protected void onServiceRemovedLocked(ManagedServiceInfo removed) {
+ mListeners.unregisterService(removed.service, removed.userid);
+ }
+
+ public void onNotificationEnqueued(final NotificationRecord r) {
+ final StatusBarNotification sbn = r.sbn;
+ TrimCache trimCache = new TrimCache(sbn);
+
+ // mServices is the list inside ManagedServices of all the rankers,
+ // There should be only one, but it's a list, so while we enforce
+ // singularity elsewhere, we keep it general here, to avoid surprises.
+ for (final ManagedServiceInfo info : NotificationRankers.this.mServices) {
+ boolean sbnVisible = isVisibleToListener(sbn, info);
+ if (!sbnVisible) {
+ continue;
+ }
+
+ final int importance = r.getImportance();
+ final boolean fromUser = r.isImportanceFromUser();
+ final StatusBarNotification sbnToPost = trimCache.ForListener(info);
+ mHandler.post(new Runnable() {
+ @Override
+ public void run() {
+ notifyEnqueued(info, sbnToPost, importance, fromUser);
+ }
+ });
+ }
+ }
+
+ private void notifyEnqueued(final ManagedServiceInfo info,
+ final StatusBarNotification sbn, int importance, boolean fromUser) {
+ final INotificationListener ranker = (INotificationListener) info.service;
+ StatusBarNotificationHolder sbnHolder = new StatusBarNotificationHolder(sbn);
+ try {
+ ranker.onNotificationEnqueued(sbnHolder, importance, fromUser);
+ } catch (RemoteException ex) {
+ Log.e(TAG, "unable to notify ranker (enqueued): " + ranker, ex);
+ }
+ }
+
+ public boolean isEnabled() {
+ return !mServices.isEmpty();
+ }
+
+ @Override
+ public void onUserSwitched(int user) {
+ synchronized (mNotificationList) {
+ int i = mServices.size()-1;
+ while (i --> 0) {
+ final ManagedServiceInfo info = mServices.get(i);
+ unregisterService(info.service, info.userid);
+ }
+ }
+ registerRanker();
+ }
+
+ @Override
+ public void onPackagesChanged(boolean queryReplace, String[] pkgList) {
+ if (DEBUG) Slog.d(TAG, "onPackagesChanged queryReplace=" + queryReplace
+ + " pkgList=" + (pkgList == null ? null : Arrays.asList(pkgList)));
+ if (mRankerServicePackageName == null) {
+ return;
+ }
+
+ if (pkgList != null && (pkgList.length > 0)) {
+ for (String pkgName : pkgList) {
+ if (mRankerServicePackageName.equals(pkgName)) {
+ registerRanker();
+ }
+ }
+ }
+ }
+
+ protected void registerRanker() {
+ // Find the updatable ranker and register it.
+ if (mRankerServicePackageName == null) {
+ Slog.w(TAG, "could not start ranker service: no package specified!");
+ return;
+ }
+ Set<ComponentName> rankerComponents = queryPackageForServices(
+ mRankerServicePackageName, UserHandle.USER_SYSTEM);
+ Iterator<ComponentName> iterator = rankerComponents.iterator();
+ if (iterator.hasNext()) {
+ ComponentName rankerComponent = iterator.next();
+ if (iterator.hasNext()) {
+ Slog.e(TAG, "found multiple ranker services:" + rankerComponents);
+ } else {
+ registerSystemService(rankerComponent, UserHandle.USER_SYSTEM);
+ }
+ } else {
+ Slog.w(TAG, "could not start ranker service: none found");
+ }
+ }
+ }
+
public class NotificationListeners extends ManagedServices {
private final ArraySet<ManagedServiceInfo> mLightTrimListeners = new ArraySet<>();
- private boolean mNotificationGroupsDesired;
public NotificationListeners() {
super(getContext(), mHandler, mNotificationList, mUserProfiles);
}
@Override
+ protected boolean checkType(IInterface service) {
+ return service instanceof INotificationListener;
+ }
+
+ @Override
public void onServiceAdded(ManagedServiceInfo info) {
final INotificationListener listener = (INotificationListener) info.service;
final NotificationRankingUpdate update;
synchronized (mNotificationList) {
- updateNotificationGroupsDesiredLocked();
update = makeRankingUpdateLocked(info);
}
try {
@Override
protected void onServiceRemovedLocked(ManagedServiceInfo removed) {
- if (mListenersDisablingEffects.remove(removed)) {
+ if (removeDisabledHints(removed)) {
updateListenerHintsLocked();
updateEffectsSuppressorLocked();
}
mLightTrimListeners.remove(removed);
- updateNotificationGroupsDesiredLocked();
}
public void setOnNotificationPostedTrimLocked(ManagedServiceInfo info, int trim) {
public int getOnNotificationPostedTrim(ManagedServiceInfo info) {
return mLightTrimListeners.contains(info) ? TRIM_LIGHT : TRIM_FULL;
-
}
/**
*/
public void notifyPostedLocked(StatusBarNotification sbn, StatusBarNotification oldSbn) {
// Lazily initialized snapshots of the notification.
- StatusBarNotification sbnClone = null;
- StatusBarNotification sbnCloneLight = null;
+ TrimCache trimCache = new TrimCache(sbn);
for (final ManagedServiceInfo info : mServices) {
boolean sbnVisible = isVisibleToListener(sbn, info);
continue;
}
- final int trim = mListeners.getOnNotificationPostedTrim(info);
-
- if (trim == TRIM_LIGHT && sbnCloneLight == null) {
- sbnCloneLight = sbn.cloneLight();
- } else if (trim == TRIM_FULL && sbnClone == null) {
- sbnClone = sbn.clone();
- }
- final StatusBarNotification sbnToPost =
- (trim == TRIM_FULL) ? sbnClone : sbnCloneLight;
-
+ final StatusBarNotification sbnToPost = trimCache.ForListener(info);
mHandler.post(new Runnable() {
@Override
public void run() {
}
return false;
}
-
- /**
- * Returns whether any of the currently registered listeners wants to receive notification
- * groups.
- *
- * <p>Currently we assume groups are desired by non-SystemUI listeners.</p>
- */
- public boolean notificationGroupsDesired() {
- return mNotificationGroupsDesired;
- }
-
- private void updateNotificationGroupsDesiredLocked() {
- mNotificationGroupsDesired = true;
- // No listeners, no groups.
- if (mServices.isEmpty()) {
- mNotificationGroupsDesired = false;
- return;
- }
- // One listener: Check whether it's SysUI.
- if (mServices.size() == 1 &&
- mServices.get(0).component.getPackageName().equals("com.android.systemui")) {
- mNotificationGroupsDesired = false;
- return;
- }
- }
}
public static final class DumpFilter {
for (int i = 0; i < tokens.length; i++) {
String token = tokens[i];
if (token != null) {
- token.trim();
+ token = token.trim();
}
if (TextUtils.isEmpty(token)) {
continue;
OSDN Git Service
