services/core/java/com/android/server/notification/ZenModeFiltering.java

   1 /**
   2  * Copyright (c) 2015, The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *     http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 package com.android.server.notification;
  18
  19 import android.app.Notification;
  20 import android.content.ComponentName;
  21 import android.content.Context;
  22 import android.media.AudioAttributes;
  23 import android.media.AudioManager;
  24 import android.os.Bundle;
  25 import android.os.UserHandle;
  26 import android.provider.Settings.Global;
  27 import android.provider.Settings.Secure;
  28 import android.service.notification.ZenModeConfig;
  29 import android.telecom.TelecomManager;
  30 import android.util.ArrayMap;
  31 import android.util.Slog;
  32
  33 import java.io.PrintWriter;
  34 import java.util.Date;
  35 import java.util.Objects;
  36
  37 public class ZenModeFiltering {
  38     private static final String TAG = ZenModeHelper.TAG;
  39     private static final boolean DEBUG = ZenModeHelper.DEBUG;
  40
  41     static final RepeatCallers REPEAT_CALLERS = new RepeatCallers();
  42
  43     private final Context mContext;
  44
  45     private ComponentName mDefaultPhoneApp;
  46
  47     public ZenModeFiltering(Context context) {
  48         mContext = context;
  49     }
  50
  51     public void dump(PrintWriter pw, String prefix) {
  52         pw.print(prefix); pw.print("mDefaultPhoneApp="); pw.println(mDefaultPhoneApp);
  53         pw.print(prefix); pw.print("RepeatCallers.mThresholdMinutes=");
  54         pw.println(REPEAT_CALLERS.mThresholdMinutes);
  55         synchronized (REPEAT_CALLERS) {
  56             if (!REPEAT_CALLERS.mCalls.isEmpty()) {
  57                 pw.print(prefix); pw.println("RepeatCallers.mCalls=");
  58                 for (int i = 0; i < REPEAT_CALLERS.mCalls.size(); i++) {
  59                     pw.print(prefix); pw.print("  ");
  60                     pw.print(REPEAT_CALLERS.mCalls.keyAt(i));
  61                     pw.print(" at ");
  62                     pw.println(ts(REPEAT_CALLERS.mCalls.valueAt(i)));
  63                 }
  64             }
  65         }
  66     }
  67
  68     private static String ts(long time) {
  69         return new Date(time) + " (" + time + ")";
  70     }
  71
  72     /**
  73      * @param extras extras of the notification with EXTRA_PEOPLE populated
  74      * @param contactsTimeoutMs timeout in milliseconds to wait for contacts response
  75      * @param timeoutAffinity affinity to return when the timeout specified via
  76      *                        <code>contactsTimeoutMs</code> is hit
  77      */
  78     public static boolean matchesCallFilter(Context context, int zen, ZenModeConfig config,
  79             UserHandle userHandle, Bundle extras, ValidateNotificationPeople validator,
  80             int contactsTimeoutMs, float timeoutAffinity) {
  81         if (zen == Global.ZEN_MODE_NO_INTERRUPTIONS) return false; // nothing gets through
  82         if (zen == Global.ZEN_MODE_ALARMS) return false; // not an alarm
  83         if (zen == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS) {
  84             if (config.allowRepeatCallers && REPEAT_CALLERS.isRepeat(context, extras)) {
  85                 return true;
  86             }
  87             if (!config.allowCalls) return false; // no other calls get through
  88             if (validator != null) {
  89                 final float contactAffinity = validator.getContactAffinity(userHandle, extras,
  90                         contactsTimeoutMs, timeoutAffinity);
  91                 return audienceMatches(config.allowCallsFrom, contactAffinity);
  92             }
  93         }
  94         return true;
  95     }
  96
  97     private static Bundle extras(NotificationRecord record) {
  98         return record != null && record.sbn != null && record.sbn.getNotification() != null
  99                 ? record.sbn.getNotification().extras : null;
 100     }
 101
 102     protected void recordCall(NotificationRecord record) {
 103         REPEAT_CALLERS.recordCall(mContext, extras(record));
 104     }
 105
 106     public boolean shouldIntercept(int zen, ZenModeConfig config, NotificationRecord record) {
 107         if (isSystem(record)) {
 108             return false;
 109         }
 110         switch (zen) {
 111             case Global.ZEN_MODE_NO_INTERRUPTIONS:
 112                 // #notevenalarms
 113                 ZenLog.traceIntercepted(record, "none");
 114                 return true;
 115             case Global.ZEN_MODE_ALARMS:
 116                 if (isAlarm(record)) {
 117                     // Alarms only
 118                     return false;
 119                 }
 120                 ZenLog.traceIntercepted(record, "alarmsOnly");
 121                 return true;
 122             case Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS:
 123                 if (isAlarm(record)) {
 124                     // Alarms are always priority
 125                     return false;
 126                 }
 127                 // allow user-prioritized packages through in priority mode
 128                 if (record.getPackagePriority() == Notification.PRIORITY_MAX) {
 129                     ZenLog.traceNotIntercepted(record, "priorityApp");
 130                     return false;
 131                 }
 132                 if (isCall(record)) {
 133                     if (config.allowRepeatCallers
 134                             && REPEAT_CALLERS.isRepeat(mContext, extras(record))) {
 135                         ZenLog.traceNotIntercepted(record, "repeatCaller");
 136                         return false;
 137                     }
 138                     if (!config.allowCalls) {
 139                         ZenLog.traceIntercepted(record, "!allowCalls");
 140                         return true;
 141                     }
 142                     return shouldInterceptAudience(config.allowCallsFrom, record);
 143                 }
 144                 if (isMessage(record)) {
 145                     if (!config.allowMessages) {
 146                         ZenLog.traceIntercepted(record, "!allowMessages");
 147                         return true;
 148                     }
 149                     return shouldInterceptAudience(config.allowMessagesFrom, record);
 150                 }
 151                 if (isEvent(record)) {
 152                     if (!config.allowEvents) {
 153                         ZenLog.traceIntercepted(record, "!allowEvents");
 154                         return true;
 155                     }
 156                     return false;
 157                 }
 158                 if (isReminder(record)) {
 159                     if (!config.allowReminders) {
 160                         ZenLog.traceIntercepted(record, "!allowReminders");
 161                         return true;
 162                     }
 163                     return false;
 164                 }
 165                 ZenLog.traceIntercepted(record, "!priority");
 166                 return true;
 167             default:
 168                 return false;
 169         }
 170     }
 171
 172     private static boolean shouldInterceptAudience(int source, NotificationRecord record) {
 173         if (!audienceMatches(source, record.getContactAffinity())) {
 174             ZenLog.traceIntercepted(record, "!audienceMatches");
 175             return true;
 176         }
 177         return false;
 178     }
 179
 180     private static boolean isSystem(NotificationRecord record) {
 181         return record.isCategory(Notification.CATEGORY_SYSTEM);
 182     }
 183
 184     private static boolean isAlarm(NotificationRecord record) {
 185         return record.isCategory(Notification.CATEGORY_ALARM)
 186                 || record.isAudioStream(AudioManager.STREAM_ALARM)
 187                 || record.isAudioAttributesUsage(AudioAttributes.USAGE_ALARM);
 188     }
 189
 190     private static boolean isEvent(NotificationRecord record) {
 191         return record.isCategory(Notification.CATEGORY_EVENT);
 192     }
 193
 194     private static boolean isReminder(NotificationRecord record) {
 195         return record.isCategory(Notification.CATEGORY_REMINDER);
 196     }
 197
 198     public boolean isCall(NotificationRecord record) {
 199         return record != null && (isDefaultPhoneApp(record.sbn.getPackageName())
 200                 || record.isCategory(Notification.CATEGORY_CALL));
 201     }
 202
 203     private boolean isDefaultPhoneApp(String pkg) {
 204         if (mDefaultPhoneApp == null) {
 205             final TelecomManager telecomm =
 206                     (TelecomManager) mContext.getSystemService(Context.TELECOM_SERVICE);
 207             mDefaultPhoneApp = telecomm != null ? telecomm.getDefaultPhoneApp() : null;
 208             if (DEBUG) Slog.d(TAG, "Default phone app: " + mDefaultPhoneApp);
 209         }
 210         return pkg != null && mDefaultPhoneApp != null
 211                 && pkg.equals(mDefaultPhoneApp.getPackageName());
 212     }
 213
 214     @SuppressWarnings("deprecation")
 215     private boolean isDefaultMessagingApp(NotificationRecord record) {
 216         final int userId = record.getUserId();
 217         if (userId == UserHandle.USER_NULL || userId == UserHandle.USER_ALL) return false;
 218         final String defaultApp = Secure.getStringForUser(mContext.getContentResolver(),
 219                 Secure.SMS_DEFAULT_APPLICATION, userId);
 220         return Objects.equals(defaultApp, record.sbn.getPackageName());
 221     }
 222
 223     private boolean isMessage(NotificationRecord record) {
 224         return record.isCategory(Notification.CATEGORY_MESSAGE) || isDefaultMessagingApp(record);
 225     }
 226
 227     private static boolean audienceMatches(int source, float contactAffinity) {
 228         switch (source) {
 229             case ZenModeConfig.SOURCE_ANYONE:
 230                 return true;
 231             case ZenModeConfig.SOURCE_CONTACT:
 232                 return contactAffinity >= ValidateNotificationPeople.VALID_CONTACT;
 233             case ZenModeConfig.SOURCE_STAR:
 234                 return contactAffinity >= ValidateNotificationPeople.STARRED_CONTACT;
 235             default:
 236                 Slog.w(TAG, "Encountered unknown source: " + source);
 237                 return true;
 238         }
 239     }
 240
 241     private static class RepeatCallers {
 242         // Person : time
 243         private final ArrayMap<String, Long> mCalls = new ArrayMap<>();
 244         private int mThresholdMinutes;
 245
 246         private synchronized void recordCall(Context context, Bundle extras) {
 247             setThresholdMinutes(context);
 248             if (mThresholdMinutes <= 0 || extras == null) return;
 249             final String peopleString = peopleString(extras);
 250             if (peopleString == null) return;
 251             final long now = System.currentTimeMillis();
 252             cleanUp(mCalls, now);
 253             mCalls.put(peopleString, now);
 254         }
 255
 256         private synchronized boolean isRepeat(Context context, Bundle extras) {
 257             setThresholdMinutes(context);
 258             if (mThresholdMinutes <= 0 || extras == null) return false;
 259             final String peopleString = peopleString(extras);
 260             if (peopleString == null) return false;
 261             final long now = System.currentTimeMillis();
 262             cleanUp(mCalls, now);
 263             return mCalls.containsKey(peopleString);
 264         }
 265
 266         private synchronized void cleanUp(ArrayMap<String, Long> calls, long now) {
 267             final int N = calls.size();
 268             for (int i = N - 1; i >= 0; i--) {
 269                 final long time = mCalls.valueAt(i);
 270                 if (time > now || (now - time) > mThresholdMinutes * 1000 * 60) {
 271                     calls.removeAt(i);
 272                 }
 273             }
 274         }
 275
 276         private void setThresholdMinutes(Context context) {
 277             if (mThresholdMinutes <= 0) {
 278                 mThresholdMinutes = context.getResources().getInteger(com.android.internal.R.integer
 279                         .config_zen_repeat_callers_threshold);
 280             }
 281         }
 282
 283         private static String peopleString(Bundle extras) {
 284             final String[] extraPeople = ValidateNotificationPeople.getExtraPeople(extras);
 285             if (extraPeople == null || extraPeople.length == 0) return null;
 286             final StringBuilder sb = new StringBuilder();
 287             for (int i = 0; i < extraPeople.length; i++) {
 288                 String extraPerson = extraPeople[i];
 289                 if (extraPerson == null) continue;
 290                 extraPerson = extraPerson.trim();
 291                 if (extraPerson.isEmpty()) continue;
 292                 if (sb.length() > 0) {
 293                     sb.append('|');
 294                 }
 295                 sb.append(extraPerson);
 296             }
 297             return sb.length() == 0 ? null : sb.toString();
 298         }
 299     }
 300
 301 }