Android/frameworks_base
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Merge "Track whether we've logged the "intercepted" state of a record." into tm-qpr-dev am: 82dc9cb01c

Browse Source 
Original change: https://googleplex-android-review.googlesource.com/c/platform/frameworks/base/+/21447287

Change-Id: I8a2074851f7cabff839c4570e346205f6b03d55f
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>
This commit is contained in:
Yuri Lin
2023-02-16 19:17:50 +00:00
committed by Automerger Merge Worker
parent eba861261c 82dc9cb01c
commit 065b8b588b
4 changed files with 69 additions and 27 deletions
Download Patch File Download Diff File Expand all files Collapse all files

3
services/core/java/com/android/server/notification/NotificationManagerService.java
View File

@@ -8585,6 +8585,9 @@ public class NotificationManagerService extends SystemService {
if (interceptBefore && !record.isIntercepted() if (interceptBefore && !record.isIntercepted()
&& record.isNewEnoughForAlerting(System.currentTimeMillis())) { && record.isNewEnoughForAlerting(System.currentTimeMillis())) {
buzzBeepBlinkLocked(record); buzzBeepBlinkLocked(record);
// Log alert after change in intercepted state to Zen Log as well
ZenLog.traceAlertOnUpdatedIntercept(record);
} }
} }
if (changed) { if (changed) {

7
services/core/java/com/android/server/notification/NotificationRecord.java
View File

@@ -114,6 +114,8 @@ public final class NotificationRecord {
// is this notification currently being intercepted by Zen Mode? // is this notification currently being intercepted by Zen Mode?
private boolean mIntercept; private boolean mIntercept;
// has the intercept value been set explicitly? we only want to log it if new or changed
private boolean mInterceptSet;
// is this notification hidden since the app pkg is suspended? // is this notification hidden since the app pkg is suspended?
private boolean mHidden; private boolean mHidden;
@@ -914,6 +916,7 @@ public final class NotificationRecord {
public boolean setIntercepted(boolean intercept) { public boolean setIntercepted(boolean intercept) {
mIntercept = intercept; mIntercept = intercept;
mInterceptSet = true;
return mIntercept; return mIntercept;
} }
@@ -934,6 +937,10 @@ public final class NotificationRecord {
return mIntercept; return mIntercept;
} }
public boolean hasInterceptBeenSet() {
return mInterceptSet;
}
public boolean isNewEnoughForAlerting(long now) { public boolean isNewEnoughForAlerting(long now) {
return getFreshnessMs(now) <= MAX_SOUND_DELAY_MS; return getFreshnessMs(now) <= MAX_SOUND_DELAY_MS;
} }

8
services/core/java/com/android/server/notification/ZenLog.java
View File

@@ -68,20 +68,23 @@ public class ZenLog {
private static final int TYPE_MATCHES_CALL_FILTER = 18; private static final int TYPE_MATCHES_CALL_FILTER = 18;
private static final int TYPE_RECORD_CALLER = 19; private static final int TYPE_RECORD_CALLER = 19;
private static final int TYPE_CHECK_REPEAT_CALLER = 20; private static final int TYPE_CHECK_REPEAT_CALLER = 20;
private static final int TYPE_ALERT_ON_UPDATED_INTERCEPT = 21;
private static int sNext; private static int sNext;
private static int sSize; private static int sSize;
public static void traceIntercepted(NotificationRecord record, String reason) { public static void traceIntercepted(NotificationRecord record, String reason) {
if (record != null && record.isIntercepted()) return; // already logged
append(TYPE_INTERCEPTED, record.getKey() + "," + reason); append(TYPE_INTERCEPTED, record.getKey() + "," + reason);
} }
public static void traceNotIntercepted(NotificationRecord record, String reason) { public static void traceNotIntercepted(NotificationRecord record, String reason) {
if (record != null && record.isUpdate) return; // already logged
append(TYPE_NOT_INTERCEPTED, record.getKey() + "," + reason); append(TYPE_NOT_INTERCEPTED, record.getKey() + "," + reason);
} }
public static void traceAlertOnUpdatedIntercept(NotificationRecord record) {
append(TYPE_ALERT_ON_UPDATED_INTERCEPT, record.getKey());
}
public static void traceSetRingerModeExternal(int ringerModeOld, int ringerModeNew, public static void traceSetRingerModeExternal(int ringerModeOld, int ringerModeNew,
String caller, int ringerModeInternalIn, int ringerModeInternalOut) { String caller, int ringerModeInternalIn, int ringerModeInternalOut) {
append(TYPE_SET_RINGER_MODE_EXTERNAL, caller + ",e:" + append(TYPE_SET_RINGER_MODE_EXTERNAL, caller + ",e:" +
@@ -219,6 +222,7 @@ public class ZenLog {
case TYPE_MATCHES_CALL_FILTER: return "matches_call_filter"; case TYPE_MATCHES_CALL_FILTER: return "matches_call_filter";
case TYPE_RECORD_CALLER: return "record_caller"; case TYPE_RECORD_CALLER: return "record_caller";
case TYPE_CHECK_REPEAT_CALLER: return "check_repeat_caller"; case TYPE_CHECK_REPEAT_CALLER: return "check_repeat_caller";
case TYPE_ALERT_ON_UPDATED_INTERCEPT: return "alert_on_updated_intercept";
default: return "unknown"; default: return "unknown";
} }
} }

78
services/core/java/com/android/server/notification/ZenModeFiltering.java
View File

@@ -155,85 +155,85 @@ public class ZenModeFiltering {
if (isCritical(record)) { if (isCritical(record)) {
// Zen mode is ignored for critical notifications. // Zen mode is ignored for critical notifications.
ZenLog.traceNotIntercepted(record, "criticalNotification"); maybeLogInterceptDecision(record, false, "criticalNotification");
return false; return false;
} }
// Make an exception to policy for the notification saying that policy has changed // Make an exception to policy for the notification saying that policy has changed
if (NotificationManager.Policy.areAllVisualEffectsSuppressed(policy.suppressedVisualEffects) if (NotificationManager.Policy.areAllVisualEffectsSuppressed(policy.suppressedVisualEffects)
&& "android".equals(record.getSbn().getPackageName()) && "android".equals(record.getSbn().getPackageName())
&& SystemMessageProto.SystemMessage.NOTE_ZEN_UPGRADE == record.getSbn().getId()) { && SystemMessageProto.SystemMessage.NOTE_ZEN_UPGRADE == record.getSbn().getId()) {
ZenLog.traceNotIntercepted(record, "systemDndChangedNotification"); maybeLogInterceptDecision(record, false, "systemDndChangedNotification");
return false; return false;
} }
switch (zen) { switch (zen) {
case Global.ZEN_MODE_NO_INTERRUPTIONS: case Global.ZEN_MODE_NO_INTERRUPTIONS:
// #notevenalarms // #notevenalarms
ZenLog.traceIntercepted(record, "none"); maybeLogInterceptDecision(record, true, "none");
return true; return true;
case Global.ZEN_MODE_ALARMS: case Global.ZEN_MODE_ALARMS:
if (isAlarm(record)) { if (isAlarm(record)) {
// Alarms only // Alarms only
ZenLog.traceNotIntercepted(record, "alarm"); maybeLogInterceptDecision(record, false, "alarm");
return false; return false;
} }
ZenLog.traceIntercepted(record, "alarmsOnly"); maybeLogInterceptDecision(record, true, "alarmsOnly");
return true; return true;
case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS: case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
// allow user-prioritized packages through in priority mode // allow user-prioritized packages through in priority mode
if (record.getPackagePriority() == Notification.PRIORITY_MAX) { if (record.getPackagePriority() == Notification.PRIORITY_MAX) {
ZenLog.traceNotIntercepted(record, "priorityApp"); maybeLogInterceptDecision(record, false, "priorityApp");
return false; return false;
} }
if (isAlarm(record)) { if (isAlarm(record)) {
if (!policy.allowAlarms()) { if (!policy.allowAlarms()) {
ZenLog.traceIntercepted(record, "!allowAlarms"); maybeLogInterceptDecision(record, true, "!allowAlarms");
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "allowedAlarm"); maybeLogInterceptDecision(record, false, "allowedAlarm");
return false; return false;
} }
if (isEvent(record)) { if (isEvent(record)) {
if (!policy.allowEvents()) { if (!policy.allowEvents()) {
ZenLog.traceIntercepted(record, "!allowEvents"); maybeLogInterceptDecision(record, true, "!allowEvents");
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "allowedEvent"); maybeLogInterceptDecision(record, false, "allowedEvent");
return false; return false;
} }
if (isReminder(record)) { if (isReminder(record)) {
if (!policy.allowReminders()) { if (!policy.allowReminders()) {
ZenLog.traceIntercepted(record, "!allowReminders"); maybeLogInterceptDecision(record, true, "!allowReminders");
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "allowedReminder"); maybeLogInterceptDecision(record, false, "allowedReminder");
return false; return false;
} }
if (isMedia(record)) { if (isMedia(record)) {
if (!policy.allowMedia()) { if (!policy.allowMedia()) {
ZenLog.traceIntercepted(record, "!allowMedia"); maybeLogInterceptDecision(record, true, "!allowMedia");
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "allowedMedia"); maybeLogInterceptDecision(record, false, "allowedMedia");
return false; return false;
} }
if (isSystem(record)) { if (isSystem(record)) {
if (!policy.allowSystem()) { if (!policy.allowSystem()) {
ZenLog.traceIntercepted(record, "!allowSystem"); maybeLogInterceptDecision(record, true, "!allowSystem");
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "allowedSystem"); maybeLogInterceptDecision(record, false, "allowedSystem");
return false; return false;
} }
if (isConversation(record)) { if (isConversation(record)) {
if (policy.allowConversations()) { if (policy.allowConversations()) {
if (policy.priorityConversationSenders == CONVERSATION_SENDERS_ANYONE) { if (policy.priorityConversationSenders == CONVERSATION_SENDERS_ANYONE) {
ZenLog.traceNotIntercepted(record, "conversationAnyone"); maybeLogInterceptDecision(record, false, "conversationAnyone");
return false; return false;
} else if (policy.priorityConversationSenders } else if (policy.priorityConversationSenders
== NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT == NotificationManager.Policy.CONVERSATION_SENDERS_IMPORTANT
&& record.getChannel().isImportantConversation()) { && record.getChannel().isImportantConversation()) {
ZenLog.traceNotIntercepted(record, "conversationMatches"); maybeLogInterceptDecision(record, false, "conversationMatches");
return false; return false;
} }
} }
@@ -244,31 +244,59 @@ public class ZenModeFiltering {
if (policy.allowRepeatCallers() if (policy.allowRepeatCallers()
&& REPEAT_CALLERS.isRepeat( && REPEAT_CALLERS.isRepeat(
mContext, extras(record), record.getPhoneNumbers())) { mContext, extras(record), record.getPhoneNumbers())) {
ZenLog.traceNotIntercepted(record, "repeatCaller"); maybeLogInterceptDecision(record, false, "repeatCaller");
return false; return false;
} }
if (!policy.allowCalls()) { if (!policy.allowCalls()) {
ZenLog.traceIntercepted(record, "!allowCalls"); maybeLogInterceptDecision(record, true, "!allowCalls");
return true; return true;
} }
return shouldInterceptAudience(policy.allowCallsFrom(), record); return shouldInterceptAudience(policy.allowCallsFrom(), record);
} }
if (isMessage(record)) { if (isMessage(record)) {
if (!policy.allowMessages()) { if (!policy.allowMessages()) {
ZenLog.traceIntercepted(record, "!allowMessages"); maybeLogInterceptDecision(record, true, "!allowMessages");
return true; return true;
} }
return shouldInterceptAudience(policy.allowMessagesFrom(), record); return shouldInterceptAudience(policy.allowMessagesFrom(), record);
} }
ZenLog.traceIntercepted(record, "!priority"); maybeLogInterceptDecision(record, true, "!priority");
return true; return true;
default: default:
ZenLog.traceNotIntercepted(record, "unknownZenMode"); maybeLogInterceptDecision(record, false, "unknownZenMode");
return false; return false;
} }
} }
// Consider logging the decision of shouldIntercept for the given record.
// This will log the outcome if one of the following is true:
// - it's the first time the intercept decision is set for the record
// - OR it's not the first time, but the intercept decision changed
private static void maybeLogInterceptDecision(NotificationRecord record, boolean intercept,
String reason) {
boolean interceptBefore = record.isIntercepted();
if (record.hasInterceptBeenSet() && (interceptBefore == intercept)) {
// this record has already been evaluated for whether it should be intercepted, and
// the decision has not changed.
return;
}
// add a note to the reason indicating whether it's new or updated
String annotatedReason = reason;
if (!record.hasInterceptBeenSet()) {
annotatedReason = "new:" + reason;
} else if (interceptBefore != intercept) {
annotatedReason = "updated:" + reason;
}
if (intercept) {
ZenLog.traceIntercepted(record, annotatedReason);
} else {
ZenLog.traceNotIntercepted(record, annotatedReason);
}
}
/** /**
* Check if the notification is too critical to be suppressed. * Check if the notification is too critical to be suppressed.
* *
@@ -285,10 +313,10 @@ public class ZenModeFiltering {
private static boolean shouldInterceptAudience(int source, NotificationRecord record) { private static boolean shouldInterceptAudience(int source, NotificationRecord record) {
float affinity = record.getContactAffinity(); float affinity = record.getContactAffinity();
if (!audienceMatches(source, affinity)) { if (!audienceMatches(source, affinity)) {
ZenLog.traceIntercepted(record, "!audienceMatches,affinity=" + affinity); maybeLogInterceptDecision(record, true, "!audienceMatches,affinity=" + affinity);
return true; return true;
} }
ZenLog.traceNotIntercepted(record, "affinity=" + affinity); maybeLogInterceptDecision(record, false, "affinity=" + affinity);
return false; return false;
} }