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.messaging.datamodel; 18 19 import android.app.Notification; 20 import android.app.PendingIntent; 21 import android.content.Context; 22 import android.content.Intent; 23 import android.content.pm.PackageManager.NameNotFoundException; 24 import android.content.res.Resources; 25 import android.graphics.Bitmap; 26 import android.graphics.Bitmap.Config; 27 import android.graphics.BitmapFactory; 28 import android.graphics.Typeface; 29 import android.media.AudioManager; 30 import android.net.Uri; 31 import android.os.Bundle; 32 import android.os.SystemClock; 33 import android.provider.ContactsContract; 34 import android.provider.ContactsContract.Contacts; 35 import android.support.v4.app.NotificationCompat; 36 import android.support.v4.app.NotificationCompat.WearableExtender; 37 import android.support.v4.app.NotificationManagerCompat; 38 import android.support.v4.app.RemoteInput; 39 import android.support.v4.util.SimpleArrayMap; 40 import android.text.Spannable; 41 import android.text.SpannableStringBuilder; 42 import android.text.TextUtils; 43 import android.text.style.StyleSpan; 44 import android.text.style.TextAppearanceSpan; 45 46 import com.android.messaging.Factory; 47 import com.android.messaging.R; 48 import com.android.messaging.datamodel.MessageNotificationState.BundledMessageNotificationState; 49 import com.android.messaging.datamodel.MessageNotificationState.ConversationLineInfo; 50 import com.android.messaging.datamodel.MessageNotificationState.MultiConversationNotificationState; 51 import com.android.messaging.datamodel.MessageNotificationState.MultiMessageNotificationState; 52 import com.android.messaging.datamodel.action.MarkAsReadAction; 53 import com.android.messaging.datamodel.action.MarkAsSeenAction; 54 import com.android.messaging.datamodel.action.RedownloadMmsAction; 55 import com.android.messaging.datamodel.data.ConversationListItemData; 56 import com.android.messaging.datamodel.media.AvatarRequestDescriptor; 57 import com.android.messaging.datamodel.media.ImageResource; 58 import com.android.messaging.datamodel.media.MediaRequest; 59 import com.android.messaging.datamodel.media.MediaResourceManager; 60 import com.android.messaging.datamodel.media.MessagePartVideoThumbnailRequestDescriptor; 61 import com.android.messaging.datamodel.media.UriImageRequestDescriptor; 62 import com.android.messaging.datamodel.media.VideoThumbnailRequest; 63 import com.android.messaging.sms.MmsSmsUtils; 64 import com.android.messaging.sms.MmsUtils; 65 import com.android.messaging.ui.UIIntents; 66 import com.android.messaging.util.Assert; 67 import com.android.messaging.util.AvatarUriUtil; 68 import com.android.messaging.util.BugleGservices; 69 import com.android.messaging.util.BugleGservicesKeys; 70 import com.android.messaging.util.BuglePrefs; 71 import com.android.messaging.util.BuglePrefsKeys; 72 import com.android.messaging.util.ContentType; 73 import com.android.messaging.util.ConversationIdSet; 74 import com.android.messaging.util.ImageUtils; 75 import com.android.messaging.util.LogUtil; 76 import com.android.messaging.util.NotificationPlayer; 77 import com.android.messaging.util.OsUtil; 78 import com.android.messaging.util.PendingIntentConstants; 79 import com.android.messaging.util.PhoneUtils; 80 import com.android.messaging.util.RingtoneUtil; 81 import com.android.messaging.util.ThreadUtil; 82 import com.android.messaging.util.UriUtil; 83 84 import java.util.HashSet; 85 import java.util.Iterator; 86 import java.util.List; 87 import java.util.Locale; 88 import java.util.Set; 89 90 /** 91 * Handle posting, updating and removing all conversation notifications. 92 * 93 * There are currently two main classes of notification and their rules: <p> 94 * 1) Messages - {@link MessageNotificationState}. Only one message notification. 95 * Unread messages across senders and conversations are coalesced.<p> 96 * 2) Failed Messages - {@link MessageNotificationState#checkFailedMesages } Only one failed 97 * message. Multiple failures are coalesced.<p> 98 * 99 * To add a new class of notifications, subclass the NotificationState and add commands which 100 * create one and pass into general creation function. 101 * 102 */ 103 public class BugleNotifications { 104 // Logging 105 public static final String TAG = LogUtil.BUGLE_NOTIFICATIONS_TAG; 106 107 // Constants to use for update. 108 public static final int UPDATE_NONE = 0; 109 public static final int UPDATE_MESSAGES = 1; 110 public static final int UPDATE_ERRORS = 2; 111 public static final int UPDATE_ALL = UPDATE_MESSAGES + UPDATE_ERRORS; 112 113 // Constants for notification type used for audio and vibration settings. 114 public static final int LOCAL_SMS_NOTIFICATION = 0; 115 116 private static final String SMS_NOTIFICATION_TAG = ":sms:"; 117 private static final String SMS_ERROR_NOTIFICATION_TAG = ":error:"; 118 119 private static final String WEARABLE_COMPANION_APP_PACKAGE = "com.google.android.wearable.app"; 120 121 private static final Set<NotificationState> sPendingNotifications = 122 new HashSet<NotificationState>(); 123 124 private static int sWearableImageWidth; 125 private static int sWearableImageHeight; 126 private static int sIconWidth; 127 private static int sIconHeight; 128 129 private static boolean sInitialized = false; 130 131 private static final Object mLock = new Object(); 132 133 // sLastMessageDingTime is a map between a conversation id and a time. It's used to keep track 134 // of the time we last dinged a message for this conversation. When messages are coming in 135 // at flurry, we don't want to over-ding the user. 136 private static final SimpleArrayMap<String, Long> sLastMessageDingTime = 137 new SimpleArrayMap<String, Long>(); 138 private static int sTimeBetweenDingsMs; 139 140 /** 141 * This is the volume at which to play the observable-conversation notification sound, 142 * expressed as a fraction of the system notification volume. 143 */ 144 private static final float OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME = 0.25f; 145 146 /** 147 * Entry point for posting notifications. 148 * Don't call this on the UI thread. 149 * @param silent If true, no ring will be played. If false, checks global settings before 150 * playing a ringtone 151 * @param coverage Indicates which notification types should be checked. Valid values are 152 * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL 153 */ update(final boolean silent, final int coverage)154 public static void update(final boolean silent, final int coverage) { 155 update(silent, null /* conversationId */, coverage); 156 } 157 158 /** 159 * Entry point for posting notifications. 160 * Don't call this on the UI thread. 161 * @param silent If true, no ring will be played. If false, checks global settings before 162 * playing a ringtone 163 * @param conversationId Conversation ID where a new message was received 164 * @param coverage Indicates which notification types should be checked. Valid values are 165 * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL 166 */ update(final boolean silent, final String conversationId, final int coverage)167 public static void update(final boolean silent, final String conversationId, 168 final int coverage) { 169 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 170 LogUtil.v(TAG, "Update: silent = " + silent 171 + " conversationId = " + conversationId 172 + " coverage = " + coverage); 173 } 174 Assert.isNotMainThread(); 175 checkInitialized(); 176 177 if (!shouldNotify()) { 178 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 179 LogUtil.v(TAG, "Notifications disabled"); 180 } 181 cancel(PendingIntentConstants.SMS_NOTIFICATION_ID); 182 return; 183 } else { 184 if ((coverage & UPDATE_MESSAGES) != 0) { 185 createMessageNotification(silent, conversationId); 186 } 187 } 188 if ((coverage & UPDATE_ERRORS) != 0) { 189 MessageNotificationState.checkFailedMessages(); 190 } 191 } 192 193 /** 194 * Cancel all notifications of a certain type. 195 * 196 * @param type Message or error notifications from Constants. 197 */ cancel(final int type)198 private static synchronized void cancel(final int type) { 199 cancel(type, null, false); 200 } 201 202 /** 203 * Cancel all notifications of a certain type. 204 * 205 * @param type Message or error notifications from Constants. 206 * @param conversationId If set, cancel the notification for this 207 * conversation only. For message notifications, this only works 208 * if the notifications are bundled (group children). 209 * @param isBundledNotification True if this notification is part of a 210 * notification bundle. This only applies to message notifications, 211 * which are bundled together with other message notifications. 212 */ cancel(final int type, final String conversationId, final boolean isBundledNotification)213 private static synchronized void cancel(final int type, final String conversationId, 214 final boolean isBundledNotification) { 215 final String notificationTag = buildNotificationTag(type, conversationId, 216 isBundledNotification); 217 final NotificationManagerCompat notificationManager = 218 NotificationManagerCompat.from(Factory.get().getApplicationContext()); 219 220 // Find all pending notifications and cancel them. 221 synchronized (sPendingNotifications) { 222 final Iterator<NotificationState> iter = sPendingNotifications.iterator(); 223 while (iter.hasNext()) { 224 final NotificationState notifState = iter.next(); 225 if (notifState.mType == type) { 226 notifState.mCanceled = true; 227 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 228 LogUtil.v(TAG, "Canceling pending notification"); 229 } 230 iter.remove(); 231 } 232 } 233 } 234 notificationManager.cancel(notificationTag, type); 235 if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { 236 LogUtil.d(TAG, "Canceled notifications of type " + type); 237 } 238 239 // Message notifications for multiple conversations can be grouped together (see comment in 240 // createMessageNotification). We need to do bookkeeping to track the current set of 241 // notification group children, including removing them when we cancel notifications). 242 if (type == PendingIntentConstants.SMS_NOTIFICATION_ID) { 243 final Context context = Factory.get().getApplicationContext(); 244 final ConversationIdSet groupChildIds = getGroupChildIds(context); 245 246 if (groupChildIds != null && groupChildIds.size() > 0) { 247 // If a conversation is specified, remove just that notification. Otherwise, 248 // we're removing the group summary so clear all children. 249 if (conversationId != null) { 250 groupChildIds.remove(conversationId); 251 writeGroupChildIds(context, groupChildIds); 252 } else { 253 cancelStaleGroupChildren(groupChildIds, null); 254 // We'll update the group children preference as we cancel each child, 255 // so we don't need to do it here. 256 } 257 } 258 } 259 } 260 261 /** 262 * Cancels stale notifications from the currently active group of 263 * notifications. If the {@code state} parameter is an instance of 264 * {@link MultiConversationNotificationState} it represents a new 265 * notification group. This method will cancel any notifications that were 266 * in the old group, but not the new one. If the new notification is not a 267 * group, then all existing grouped notifications are cancelled. 268 * 269 * @param previousGroupChildren Conversation ids for the active notification 270 * group 271 * @param state New notification state 272 */ cancelStaleGroupChildren(final ConversationIdSet previousGroupChildren, final NotificationState state)273 private static void cancelStaleGroupChildren(final ConversationIdSet previousGroupChildren, 274 final NotificationState state) { 275 final ConversationIdSet newChildren = new ConversationIdSet(); 276 if (state instanceof MultiConversationNotificationState) { 277 for (final NotificationState child : 278 ((MultiConversationNotificationState) state).mChildren) { 279 if (child.mConversationIds != null) { 280 newChildren.add(child.mConversationIds.first()); 281 } 282 } 283 } 284 for (final String childConversationId : previousGroupChildren) { 285 if (!newChildren.contains(childConversationId)) { 286 cancel(PendingIntentConstants.SMS_NOTIFICATION_ID, childConversationId, true); 287 } 288 } 289 } 290 291 /** 292 * Returns {@code true} if incoming notifications should display a 293 * notification, {@code false} otherwise. 294 * 295 * @return true if the notification should occur 296 */ shouldNotify()297 private static boolean shouldNotify() { 298 // If we're not the default sms app, don't put up any notifications. 299 if (!PhoneUtils.getDefault().isDefaultSmsApp()) { 300 return false; 301 } 302 303 // Now check prefs (i.e. settings) to see if the user turned off notifications. 304 final BuglePrefs prefs = BuglePrefs.getApplicationPrefs(); 305 final Context context = Factory.get().getApplicationContext(); 306 final String prefKey = context.getString(R.string.notifications_enabled_pref_key); 307 final boolean defaultValue = context.getResources().getBoolean( 308 R.bool.notifications_enabled_pref_default); 309 return prefs.getBoolean(prefKey, defaultValue); 310 } 311 312 /** 313 * Returns {@code true} if incoming notifications for the given {@link NotificationState} 314 * should vibrate the device, {@code false} otherwise. 315 * 316 * @return true if vibration should be used 317 */ shouldVibrate(final NotificationState state)318 public static boolean shouldVibrate(final NotificationState state) { 319 // The notification should vibrate if the global setting is turned on AND 320 // the per-conversation setting is turned on (default). 321 if (!state.getNotificationVibrate()) { 322 return false; 323 } else { 324 final BuglePrefs prefs = BuglePrefs.getApplicationPrefs(); 325 final Context context = Factory.get().getApplicationContext(); 326 final String prefKey = context.getString(R.string.notification_vibration_pref_key); 327 final boolean defaultValue = context.getResources().getBoolean( 328 R.bool.notification_vibration_pref_default); 329 return prefs.getBoolean(prefKey, defaultValue); 330 } 331 } 332 getNotificationRingtoneUriForConversationId(final String conversationId)333 private static Uri getNotificationRingtoneUriForConversationId(final String conversationId) { 334 final DatabaseWrapper db = DataModel.get().getDatabase(); 335 final ConversationListItemData convData = 336 ConversationListItemData.getExistingConversation(db, conversationId); 337 return RingtoneUtil.getNotificationRingtoneUri( 338 convData != null ? convData.getNotificationSoundUri() : null); 339 } 340 341 /** 342 * Returns a unique tag to identify a notification. 343 * 344 * @param name The tag name (in practice, the type) 345 * @param conversationId The conversation id (optional) 346 */ buildNotificationTag(final String name, final String conversationId)347 private static String buildNotificationTag(final String name, 348 final String conversationId) { 349 final Context context = Factory.get().getApplicationContext(); 350 if (conversationId != null) { 351 return context.getPackageName() + name + ":" + conversationId; 352 } else { 353 return context.getPackageName() + name; 354 } 355 } 356 357 /** 358 * Returns a unique tag to identify a notification. 359 * <p> 360 * This delegates to 361 * {@link #buildNotificationTag(int, String, boolean)} and can be 362 * used when the notification is never bundled (e.g. error notifications). 363 */ buildNotificationTag(final int type, final String conversationId)364 static String buildNotificationTag(final int type, final String conversationId) { 365 return buildNotificationTag(type, conversationId, false /* bundledNotification */); 366 } 367 368 /** 369 * Returns a unique tag to identify a notification. 370 * 371 * @param type One of the constants in {@link PendingIntentConstants} 372 * @param conversationId The conversation id (where applicable) 373 * @param bundledNotification Set to true if this notification will be 374 * bundled together with other notifications (e.g. on a wearable 375 * device). 376 */ buildNotificationTag(final int type, final String conversationId, final boolean bundledNotification)377 static String buildNotificationTag(final int type, final String conversationId, 378 final boolean bundledNotification) { 379 String tag = null; 380 switch(type) { 381 case PendingIntentConstants.SMS_NOTIFICATION_ID: 382 if (bundledNotification) { 383 tag = buildNotificationTag(SMS_NOTIFICATION_TAG, conversationId); 384 } else { 385 tag = buildNotificationTag(SMS_NOTIFICATION_TAG, null); 386 } 387 break; 388 case PendingIntentConstants.MSG_SEND_ERROR: 389 tag = buildNotificationTag(SMS_ERROR_NOTIFICATION_TAG, null); 390 break; 391 } 392 return tag; 393 } 394 checkInitialized()395 private static void checkInitialized() { 396 if (!sInitialized) { 397 final Resources resources = Factory.get().getApplicationContext().getResources(); 398 sWearableImageWidth = resources.getDimensionPixelSize( 399 R.dimen.notification_wearable_image_width); 400 sWearableImageHeight = resources.getDimensionPixelSize( 401 R.dimen.notification_wearable_image_height); 402 sIconHeight = (int) resources.getDimension( 403 android.R.dimen.notification_large_icon_height); 404 sIconWidth = 405 (int) resources.getDimension(android.R.dimen.notification_large_icon_width); 406 407 sInitialized = true; 408 } 409 } 410 processAndSend(final NotificationState state, final boolean silent, final boolean softSound)411 private static void processAndSend(final NotificationState state, final boolean silent, 412 final boolean softSound) { 413 final Context context = Factory.get().getApplicationContext(); 414 final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context); 415 notifBuilder.setCategory(Notification.CATEGORY_MESSAGE); 416 // TODO: Need to fix this for multi conversation notifications to rate limit dings. 417 final String conversationId = state.mConversationIds.first(); 418 419 420 final Uri ringtoneUri = RingtoneUtil.getNotificationRingtoneUri(state.getRingtoneUri()); 421 // If the notification's conversation is currently observable (focused or in the 422 // conversation list), then play a notification beep at a low volume and don't display an 423 // actual notification. 424 if (softSound) { 425 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 426 LogUtil.v(TAG, "processAndSend: fromConversationId == " + 427 "sCurrentlyDisplayedConversationId so NOT showing notification," + 428 " but playing soft sound. conversationId: " + conversationId); 429 } 430 playObservableConversationNotificationSound(ringtoneUri); 431 return; 432 } 433 state.mBaseRequestCode = state.mType; 434 435 // Set the delete intent (except for bundled wearable notifications, which are dismissed 436 // as a group, either from the wearable or when the summary notification is dismissed from 437 // the host device). 438 if (!(state instanceof BundledMessageNotificationState)) { 439 final PendingIntent clearIntent = state.getClearIntent(); 440 notifBuilder.setDeleteIntent(clearIntent); 441 } 442 443 updateBuilderAudioVibrate(state, notifBuilder, silent, ringtoneUri, conversationId); 444 445 // Set the content intent 446 PendingIntent destinationIntent; 447 if (state.mConversationIds.size() > 1) { 448 // We have notifications for multiple conversation, go to the conversation list. 449 destinationIntent = UIIntents.get() 450 .getPendingIntentForConversationListActivity(context); 451 } else { 452 // We have a single conversation, go directly to that conversation. 453 destinationIntent = UIIntents.get() 454 .getPendingIntentForConversationActivity(context, 455 state.mConversationIds.first(), 456 null /*draft*/); 457 } 458 notifBuilder.setContentIntent(destinationIntent); 459 460 // TODO: set based on contact coming from a favorite. 461 notifBuilder.setPriority(state.getPriority()); 462 463 // Save the state of the notification in-progress so when the avatar is loaded, 464 // we can continue building the notification. 465 final NotificationCompat.Style notifStyle = state.build(notifBuilder); 466 state.mNotificationBuilder = notifBuilder; 467 state.mNotificationStyle = notifStyle; 468 if (!state.mPeople.isEmpty()) { 469 final Bundle people = new Bundle(); 470 people.putStringArray(NotificationCompat.EXTRA_PEOPLE, 471 state.mPeople.toArray(new String[state.mPeople.size()])); 472 notifBuilder.addExtras(people); 473 } 474 475 if (state.mParticipantAvatarsUris != null) { 476 final Uri avatarUri = state.mParticipantAvatarsUris.get(0); 477 final AvatarRequestDescriptor descriptor = new AvatarRequestDescriptor(avatarUri, 478 sIconWidth, sIconHeight, OsUtil.isAtLeastL()); 479 final MediaRequest<ImageResource> imageRequest = descriptor.buildSyncMediaRequest( 480 context); 481 482 synchronized (sPendingNotifications) { 483 sPendingNotifications.add(state); 484 } 485 486 // Synchronously load the avatar. 487 final ImageResource avatarImage = 488 MediaResourceManager.get().requestMediaResourceSync(imageRequest); 489 if (avatarImage != null) { 490 ImageResource avatarHiRes = null; 491 try { 492 if (isWearCompanionAppInstalled()) { 493 // For Wear users, we need to request a high-res avatar image to use as the 494 // notification card background. If the sender has a contact photo, we'll 495 // request the display photo from the Contacts provider. Otherwise, we ask 496 // the local content provider for a hi-res version of the generic avatar 497 // (e.g. letter with colored background). 498 avatarHiRes = requestContactDisplayPhoto(context, 499 getDisplayPhotoUri(avatarUri)); 500 if (avatarHiRes == null) { 501 final AvatarRequestDescriptor hiResDesc = 502 new AvatarRequestDescriptor(avatarUri, 503 sWearableImageWidth, 504 sWearableImageHeight, 505 false /* cropToCircle */, 506 true /* isWearBackground */); 507 avatarHiRes = MediaResourceManager.get().requestMediaResourceSync( 508 hiResDesc.buildSyncMediaRequest(context)); 509 } 510 } 511 512 // We have to make copies of the bitmaps to hand to the NotificationManager 513 // because the bitmap in the ImageResource is managed and will automatically 514 // get released. 515 Bitmap avatarBitmap = Bitmap.createBitmap(avatarImage.getBitmap()); 516 Bitmap avatarHiResBitmap = (avatarHiRes != null) ? 517 Bitmap.createBitmap(avatarHiRes.getBitmap()) : null; 518 sendNotification(state, avatarBitmap, avatarHiResBitmap); 519 return; 520 } finally { 521 avatarImage.release(); 522 if (avatarHiRes != null) { 523 avatarHiRes.release(); 524 } 525 } 526 } 527 } 528 // We have no avatar. Post the notification anyway. 529 sendNotification(state, null, null); 530 } 531 532 /** 533 * Returns the thumbnailUri from the avatar URI, or null if avatar URI does not have thumbnail. 534 */ getThumbnailUri(final Uri avatarUri)535 private static Uri getThumbnailUri(final Uri avatarUri) { 536 Uri localUri = null; 537 final String avatarType = AvatarUriUtil.getAvatarType(avatarUri); 538 if (TextUtils.equals(avatarType, AvatarUriUtil.TYPE_LOCAL_RESOURCE_URI)) { 539 localUri = AvatarUriUtil.getPrimaryUri(avatarUri); 540 } else if (UriUtil.isLocalResourceUri(avatarUri)) { 541 localUri = avatarUri; 542 } 543 if (localUri != null && localUri.getAuthority().equals(ContactsContract.AUTHORITY)) { 544 // Contact photos are of the form: content://com.android.contacts/contacts/123/photo 545 final List<String> pathParts = localUri.getPathSegments(); 546 if (pathParts.size() == 3 && 547 pathParts.get(2).equals(Contacts.Photo.CONTENT_DIRECTORY)) { 548 return localUri; 549 } 550 } 551 return null; 552 } 553 554 /** 555 * Returns the displayPhotoUri from the avatar URI, or null if avatar URI 556 * does not have a displayPhotoUri. 557 */ getDisplayPhotoUri(final Uri avatarUri)558 private static Uri getDisplayPhotoUri(final Uri avatarUri) { 559 final Uri thumbnailUri = getThumbnailUri(avatarUri); 560 if (thumbnailUri == null) { 561 return null; 562 } 563 final List<String> originalPaths = thumbnailUri.getPathSegments(); 564 final int originalPathsSize = originalPaths.size(); 565 final StringBuilder newPathBuilder = new StringBuilder(); 566 // Change content://com.android.contacts/contacts("_corp")/123/photo to 567 // content://com.android.contacts/contacts("_corp")/123/display_photo 568 for (int i = 0; i < originalPathsSize; i++) { 569 newPathBuilder.append('/'); 570 if (i == 2) { 571 newPathBuilder.append(ContactsContract.Contacts.Photo.DISPLAY_PHOTO); 572 } else { 573 newPathBuilder.append(originalPaths.get(i)); 574 } 575 } 576 return thumbnailUri.buildUpon().path(newPathBuilder.toString()).build(); 577 } 578 requestContactDisplayPhoto(final Context context, final Uri displayPhotoUri)579 private static ImageResource requestContactDisplayPhoto(final Context context, 580 final Uri displayPhotoUri) { 581 final UriImageRequestDescriptor bgDescriptor = 582 new UriImageRequestDescriptor(displayPhotoUri, 583 sWearableImageWidth, 584 sWearableImageHeight, 585 false, /* allowCompression */ 586 true, /* isStatic */ 587 false /* cropToCircle */, 588 ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */, 589 ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */); 590 return MediaResourceManager.get().requestMediaResourceSync( 591 bgDescriptor.buildSyncMediaRequest(context)); 592 } 593 createMessageNotification(final boolean silent, final String conversationId)594 private static void createMessageNotification(final boolean silent, 595 final String conversationId) { 596 final NotificationState state = MessageNotificationState.getNotificationState(); 597 final boolean softSound = DataModel.get().isNewMessageObservable(conversationId); 598 if (state == null) { 599 cancel(PendingIntentConstants.SMS_NOTIFICATION_ID); 600 if (softSound && !TextUtils.isEmpty(conversationId)) { 601 final Uri ringtoneUri = getNotificationRingtoneUriForConversationId(conversationId); 602 playObservableConversationNotificationSound(ringtoneUri); 603 } 604 return; 605 } 606 processAndSend(state, silent, softSound); 607 608 // The rest of the logic here is for supporting Android Wear devices, specifically for when 609 // we are notifying about multiple conversations. In that case, the Inbox-style summary 610 // notification (which we already processed above) appears on the phone (as it always has), 611 // but wearables show per-conversation notifications, bundled together in a group. 612 613 // It is valid to replace a notification group with another group with fewer conversations, 614 // or even with one notification for a single conversation. In either case, we need to 615 // explicitly cancel any children from the old group which are not being notified about now. 616 final Context context = Factory.get().getApplicationContext(); 617 final ConversationIdSet oldGroupChildIds = getGroupChildIds(context); 618 if (oldGroupChildIds != null && oldGroupChildIds.size() > 0) { 619 cancelStaleGroupChildren(oldGroupChildIds, state); 620 } 621 622 // Send per-conversation notifications (if there are multiple conversations). 623 final ConversationIdSet groupChildIds = new ConversationIdSet(); 624 if (state instanceof MultiConversationNotificationState) { 625 for (final NotificationState child : 626 ((MultiConversationNotificationState) state).mChildren) { 627 processAndSend(child, true /* silent */, softSound); 628 if (child.mConversationIds != null) { 629 groupChildIds.add(child.mConversationIds.first()); 630 } 631 } 632 } 633 634 // Record the new set of group children. 635 writeGroupChildIds(context, groupChildIds); 636 } 637 updateBuilderAudioVibrate(final NotificationState state, final NotificationCompat.Builder notifBuilder, final boolean silent, final Uri ringtoneUri, final String conversationId)638 private static void updateBuilderAudioVibrate(final NotificationState state, 639 final NotificationCompat.Builder notifBuilder, final boolean silent, 640 final Uri ringtoneUri, final String conversationId) { 641 int defaults = Notification.DEFAULT_LIGHTS; 642 if (!silent) { 643 final BuglePrefs prefs = Factory.get().getApplicationPrefs(); 644 final long latestNotificationTimestamp = prefs.getLong( 645 BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP, Long.MIN_VALUE); 646 final long latestReceivedTimestamp = state.getLatestReceivedTimestamp(); 647 prefs.putLong( 648 BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP, 649 Math.max(latestNotificationTimestamp, latestReceivedTimestamp)); 650 if (latestReceivedTimestamp > latestNotificationTimestamp) { 651 synchronized (mLock) { 652 // Find out the last time we dinged for this conversation 653 Long lastTime = sLastMessageDingTime.get(conversationId); 654 if (sTimeBetweenDingsMs == 0) { 655 sTimeBetweenDingsMs = BugleGservices.get().getInt( 656 BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS, 657 BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS_DEFAULT) * 658 1000; 659 } 660 if (lastTime == null 661 || SystemClock.elapsedRealtime() - lastTime > sTimeBetweenDingsMs) { 662 sLastMessageDingTime.put(conversationId, SystemClock.elapsedRealtime()); 663 notifBuilder.setSound(ringtoneUri); 664 if (shouldVibrate(state)) { 665 defaults |= Notification.DEFAULT_VIBRATE; 666 } 667 } 668 } 669 } 670 } 671 notifBuilder.setDefaults(defaults); 672 } 673 674 // TODO: this doesn't seem to be defined in NotificationCompat yet. Temporarily 675 // define it here until it makes its way from Notification -> NotificationCompat. 676 /** 677 * Notification category: incoming direct message (SMS, instant message, etc.). 678 */ 679 private static final String CATEGORY_MESSAGE = "msg"; 680 sendNotification(final NotificationState notificationState, final Bitmap avatarIcon, final Bitmap avatarHiRes)681 private static void sendNotification(final NotificationState notificationState, 682 final Bitmap avatarIcon, final Bitmap avatarHiRes) { 683 final Context context = Factory.get().getApplicationContext(); 684 if (notificationState.mCanceled) { 685 if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { 686 LogUtil.d(TAG, "sendNotification: Notification already cancelled; dropping it"); 687 } 688 return; 689 } 690 691 synchronized (sPendingNotifications) { 692 if (sPendingNotifications.contains(notificationState)) { 693 sPendingNotifications.remove(notificationState); 694 } 695 } 696 697 notificationState.mNotificationBuilder 698 .setSmallIcon(notificationState.getIcon()) 699 .setVisibility(NotificationCompat.VISIBILITY_PRIVATE) 700 .setColor(context.getResources().getColor(R.color.notification_accent_color)) 701 // .setPublicVersion(null) // TODO: when/if we ever support different 702 // text on the lockscreen, instead of "contents hidden" 703 .setCategory(CATEGORY_MESSAGE); 704 705 if (avatarIcon != null) { 706 notificationState.mNotificationBuilder.setLargeIcon(avatarIcon); 707 } 708 709 if (notificationState.mParticipantContactUris != null && 710 notificationState.mParticipantContactUris.size() > 0) { 711 for (final Uri contactUri : notificationState.mParticipantContactUris) { 712 notificationState.mNotificationBuilder.addPerson(contactUri.toString()); 713 } 714 } 715 716 final Uri attachmentUri = notificationState.getAttachmentUri(); 717 final String attachmentType = notificationState.getAttachmentType(); 718 Bitmap attachmentBitmap = null; 719 720 // For messages with photo/video attachment, request an image to show in the notification. 721 if (attachmentUri != null && notificationState.mNotificationStyle != null && 722 (notificationState.mNotificationStyle instanceof 723 NotificationCompat.BigPictureStyle) && 724 (ContentType.isImageType(attachmentType) || 725 ContentType.isVideoType(attachmentType))) { 726 final boolean isVideo = ContentType.isVideoType(attachmentType); 727 728 MediaRequest<ImageResource> imageRequest; 729 if (isVideo) { 730 Assert.isTrue(VideoThumbnailRequest.shouldShowIncomingVideoThumbnails()); 731 final MessagePartVideoThumbnailRequestDescriptor videoDescriptor = 732 new MessagePartVideoThumbnailRequestDescriptor(attachmentUri); 733 imageRequest = videoDescriptor.buildSyncMediaRequest(context); 734 } else { 735 final UriImageRequestDescriptor imageDescriptor = 736 new UriImageRequestDescriptor(attachmentUri, 737 sWearableImageWidth, 738 sWearableImageHeight, 739 false /* allowCompression */, 740 true /* isStatic */, 741 false /* cropToCircle */, 742 ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */, 743 ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */); 744 imageRequest = imageDescriptor.buildSyncMediaRequest(context); 745 } 746 final ImageResource imageResource = 747 MediaResourceManager.get().requestMediaResourceSync(imageRequest); 748 if (imageResource != null) { 749 try { 750 // Copy the bitmap, because the one in the ImageResource is managed by 751 // MediaResourceManager. 752 Bitmap imageResourceBitmap = imageResource.getBitmap(); 753 Config config = imageResourceBitmap.getConfig(); 754 755 // Make sure our bitmap has a valid format. 756 if (config == null) { 757 config = Bitmap.Config.ARGB_8888; 758 } 759 attachmentBitmap = imageResourceBitmap.copy(config, true); 760 } finally { 761 imageResource.release(); 762 } 763 } 764 } 765 766 fireOffNotification(notificationState, attachmentBitmap, avatarIcon, avatarHiRes); 767 } 768 fireOffNotification(final NotificationState notificationState, final Bitmap attachmentBitmap, final Bitmap avatarBitmap, Bitmap avatarHiResBitmap)769 private static void fireOffNotification(final NotificationState notificationState, 770 final Bitmap attachmentBitmap, final Bitmap avatarBitmap, Bitmap avatarHiResBitmap) { 771 if (notificationState.mCanceled) { 772 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 773 LogUtil.v(TAG, "Firing off notification, but notification already canceled"); 774 } 775 return; 776 } 777 778 final Context context = Factory.get().getApplicationContext(); 779 780 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 781 LogUtil.v(TAG, "MMS picture loaded, bitmap: " + attachmentBitmap); 782 } 783 784 final NotificationCompat.Builder notifBuilder = notificationState.mNotificationBuilder; 785 notifBuilder.setStyle(notificationState.mNotificationStyle); 786 notifBuilder.setColor(context.getResources().getColor(R.color.notification_accent_color)); 787 788 final WearableExtender wearableExtender = new WearableExtender(); 789 setWearableGroupOptions(notifBuilder, notificationState); 790 791 if (avatarHiResBitmap != null) { 792 wearableExtender.setBackground(avatarHiResBitmap); 793 } else if (avatarBitmap != null) { 794 // Nothing to do here; we already set avatarBitmap as the notification icon 795 } else { 796 final Bitmap defaultBackground = BitmapFactory.decodeResource( 797 context.getResources(), R.drawable.bg_sms); 798 wearableExtender.setBackground(defaultBackground); 799 } 800 801 if (notificationState instanceof MultiMessageNotificationState) { 802 if (attachmentBitmap != null) { 803 // When we've got a picture attachment, we do some switcheroo trickery. When 804 // the notification is expanded, we show the picture as a bigPicture. The small 805 // icon shows the sender's avatar. When that same notification is collapsed, the 806 // picture is shown in the location where the avatar is normally shown. The lines 807 // below make all that happen. 808 809 // Here we're taking the picture attachment and making a small, scaled, center 810 // cropped version of the picture we can stuff into the place where the avatar 811 // goes when the notification is collapsed. 812 final Bitmap smallBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap, sIconWidth, 813 sIconHeight); 814 ((NotificationCompat.BigPictureStyle) notificationState.mNotificationStyle) 815 .bigPicture(attachmentBitmap) 816 .bigLargeIcon(avatarBitmap); 817 notificationState.mNotificationBuilder.setLargeIcon(smallBitmap); 818 819 // Add a wearable page with no visible card so you can more easily see the photo. 820 final NotificationCompat.Builder photoPageNotifBuilder = 821 new NotificationCompat.Builder(Factory.get().getApplicationContext()); 822 final WearableExtender photoPageWearableExtender = new WearableExtender(); 823 photoPageWearableExtender.setHintShowBackgroundOnly(true); 824 if (attachmentBitmap != null) { 825 final Bitmap wearBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap, 826 sWearableImageWidth, sWearableImageHeight); 827 photoPageWearableExtender.setBackground(wearBitmap); 828 } 829 photoPageNotifBuilder.extend(photoPageWearableExtender); 830 wearableExtender.addPage(photoPageNotifBuilder.build()); 831 } 832 833 maybeAddWearableConversationLog(wearableExtender, 834 (MultiMessageNotificationState) notificationState); 835 addDownloadMmsAction(notifBuilder, wearableExtender, notificationState); 836 addWearableVoiceReplyAction(wearableExtender, notificationState); 837 } 838 839 // Apply the wearable options and build & post the notification 840 notifBuilder.extend(wearableExtender); 841 doNotify(notifBuilder.build(), notificationState); 842 } 843 setWearableGroupOptions(final NotificationCompat.Builder notifBuilder, final NotificationState notificationState)844 private static void setWearableGroupOptions(final NotificationCompat.Builder notifBuilder, 845 final NotificationState notificationState) { 846 final String groupKey = "groupkey"; 847 if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { 848 LogUtil.v(TAG, "Group key (for wearables)=" + groupKey); 849 } 850 if (notificationState instanceof MultiConversationNotificationState) { 851 notifBuilder.setGroup(groupKey).setGroupSummary(true); 852 } else if (notificationState instanceof BundledMessageNotificationState) { 853 final int order = ((BundledMessageNotificationState) notificationState).mGroupOrder; 854 // Convert the order to a zero-padded string ("00", "01", "02", etc). 855 // The Wear library orders notifications within a bundle lexicographically 856 // by the sort key, hence the need for zeroes to preserve the ordering. 857 final String sortKey = String.format(Locale.US, "%02d", order); 858 notifBuilder.setGroup(groupKey).setSortKey(sortKey); 859 } 860 } 861 maybeAddWearableConversationLog( final WearableExtender wearableExtender, final MultiMessageNotificationState notificationState)862 private static void maybeAddWearableConversationLog( 863 final WearableExtender wearableExtender, 864 final MultiMessageNotificationState notificationState) { 865 if (!isWearCompanionAppInstalled()) { 866 return; 867 } 868 final String convId = notificationState.mConversationIds.first(); 869 ConversationLineInfo convInfo = notificationState.mConvList.mConvInfos.get(0); 870 final Notification page = MessageNotificationState.buildConversationPageForWearable( 871 convId, 872 convInfo.mParticipantCount); 873 if (page != null) { 874 wearableExtender.addPage(page); 875 } 876 } 877 addWearableVoiceReplyAction( final WearableExtender wearableExtender, final NotificationState notificationState)878 private static void addWearableVoiceReplyAction( 879 final WearableExtender wearableExtender, final NotificationState notificationState) { 880 if (!(notificationState instanceof MultiMessageNotificationState)) { 881 return; 882 } 883 final MultiMessageNotificationState multiMessageNotificationState = 884 (MultiMessageNotificationState) notificationState; 885 final Context context = Factory.get().getApplicationContext(); 886 887 final String conversationId = notificationState.mConversationIds.first(); 888 final ConversationLineInfo convInfo = 889 multiMessageNotificationState.mConvList.mConvInfos.get(0); 890 final String selfId = convInfo.mSelfParticipantId; 891 892 final boolean requiresMms = 893 MmsSmsUtils.getRequireMmsForEmailAddress( 894 convInfo.mIncludeEmailAddress, convInfo.mSubId) || 895 (convInfo.mIsGroup && MmsUtils.groupMmsEnabled(convInfo.mSubId)); 896 897 final int requestCode = multiMessageNotificationState.getReplyIntentRequestCode(); 898 final PendingIntent replyPendingIntent = UIIntents.get() 899 .getPendingIntentForSendingMessageToConversation(context, 900 conversationId, selfId, requiresMms, requestCode); 901 902 final int replyLabelRes = requiresMms ? R.string.notification_reply_via_mms : 903 R.string.notification_reply_via_sms; 904 905 final NotificationCompat.Action.Builder actionBuilder = 906 new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply, 907 context.getString(replyLabelRes), replyPendingIntent); 908 final String[] choices = context.getResources().getStringArray( 909 R.array.notification_reply_choices); 910 final RemoteInput remoteInput = new RemoteInput.Builder(Intent.EXTRA_TEXT).setLabel( 911 context.getString(R.string.notification_reply_prompt)). 912 setChoices(choices) 913 .build(); 914 actionBuilder.addRemoteInput(remoteInput); 915 wearableExtender.addAction(actionBuilder.build()); 916 } 917 addDownloadMmsAction(final NotificationCompat.Builder notifBuilder, final WearableExtender wearableExtender, final NotificationState notificationState)918 private static void addDownloadMmsAction(final NotificationCompat.Builder notifBuilder, 919 final WearableExtender wearableExtender, final NotificationState notificationState) { 920 if (!(notificationState instanceof MultiMessageNotificationState)) { 921 return; 922 } 923 final MultiMessageNotificationState multiMessageNotificationState = 924 (MultiMessageNotificationState) notificationState; 925 final ConversationLineInfo convInfo = 926 multiMessageNotificationState.mConvList.mConvInfos.get(0); 927 if (!convInfo.getDoesLatestMessageNeedDownload()) { 928 return; 929 } 930 final String messageId = convInfo.getLatestMessageId(); 931 if (messageId == null) { 932 // No message Id, no download for you 933 return; 934 } 935 final Context context = Factory.get().getApplicationContext(); 936 final PendingIntent downloadPendingIntent = 937 RedownloadMmsAction.getPendingIntentForRedownloadMms(context, messageId); 938 939 final NotificationCompat.Action.Builder actionBuilder = 940 new NotificationCompat.Action.Builder(R.drawable.ic_file_download_light, 941 context.getString(R.string.notification_download_mms), 942 downloadPendingIntent); 943 final NotificationCompat.Action downloadAction = actionBuilder.build(); 944 notifBuilder.addAction(downloadAction); 945 946 // Support the action on a wearable device as well 947 wearableExtender.addAction(downloadAction); 948 } 949 doNotify(final Notification notification, final NotificationState notificationState)950 private static synchronized void doNotify(final Notification notification, 951 final NotificationState notificationState) { 952 if (notification == null) { 953 return; 954 } 955 final int type = notificationState.mType; 956 final ConversationIdSet conversationIds = notificationState.mConversationIds; 957 final boolean isBundledNotification = 958 (notificationState instanceof BundledMessageNotificationState); 959 960 // Mark the notification as finished 961 notificationState.mCanceled = true; 962 963 final NotificationManagerCompat notificationManager = 964 NotificationManagerCompat.from(Factory.get().getApplicationContext()); 965 // Only need conversationId for tags with a single conversation. 966 String conversationId = null; 967 if (conversationIds != null && conversationIds.size() == 1) { 968 conversationId = conversationIds.first(); 969 } 970 final String notificationTag = buildNotificationTag(type, 971 conversationId, isBundledNotification); 972 973 notification.flags |= Notification.FLAG_AUTO_CANCEL; 974 notification.defaults |= Notification.DEFAULT_LIGHTS; 975 976 notificationManager.notify(notificationTag, type, notification); 977 978 LogUtil.i(TAG, "Notifying for conversation " + conversationId + "; " 979 + "tag = " + notificationTag + ", type = " + type); 980 } 981 982 // This is the message string used in each line of an inboxStyle notification. 983 // TODO: add attachment type formatInboxMessage(final String sender, final CharSequence message, final Uri attachmentUri, final String attachmentType)984 static CharSequence formatInboxMessage(final String sender, 985 final CharSequence message, final Uri attachmentUri, final String attachmentType) { 986 final Context context = Factory.get().getApplicationContext(); 987 final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan( 988 context, R.style.NotificationSenderText); 989 990 final TextAppearanceSpan notificationTertiaryText = new TextAppearanceSpan( 991 context, R.style.NotificationTertiaryText); 992 993 final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(); 994 if (!TextUtils.isEmpty(sender)) { 995 spannableStringBuilder.append(sender); 996 spannableStringBuilder.setSpan(notificationSenderSpan, 0, sender.length(), 0); 997 } 998 final String separator = context.getString(R.string.notification_separator); 999 1000 if (!TextUtils.isEmpty(message)) { 1001 if (spannableStringBuilder.length() > 0) { 1002 spannableStringBuilder.append(separator); 1003 } 1004 final int start = spannableStringBuilder.length(); 1005 spannableStringBuilder.append(message); 1006 spannableStringBuilder.setSpan(notificationTertiaryText, start, 1007 start + message.length(), 0); 1008 } 1009 if (attachmentUri != null) { 1010 if (spannableStringBuilder.length() > 0) { 1011 spannableStringBuilder.append(separator); 1012 } 1013 spannableStringBuilder.append(formatAttachmentTag(null, attachmentType)); 1014 } 1015 return spannableStringBuilder; 1016 } 1017 buildColonSeparatedMessage( final String title, final CharSequence content, final Uri attachmentUri, final String attachmentType)1018 protected static CharSequence buildColonSeparatedMessage( 1019 final String title, final CharSequence content, final Uri attachmentUri, 1020 final String attachmentType) { 1021 return buildBoldedMessage(title, content, attachmentUri, attachmentType, 1022 R.string.notification_ticker_separator); 1023 } 1024 buildSpaceSeparatedMessage( final String title, final CharSequence content, final Uri attachmentUri, final String attachmentType)1025 protected static CharSequence buildSpaceSeparatedMessage( 1026 final String title, final CharSequence content, final Uri attachmentUri, 1027 final String attachmentType) { 1028 return buildBoldedMessage(title, content, attachmentUri, attachmentType, 1029 R.string.notification_space_separator); 1030 } 1031 1032 /** 1033 * buildBoldedMessage - build a formatted message where the title is bold, there's a 1034 * separator, then the message. 1035 */ buildBoldedMessage( final String title, final CharSequence message, final Uri attachmentUri, final String attachmentType, final int separatorId)1036 private static CharSequence buildBoldedMessage( 1037 final String title, final CharSequence message, final Uri attachmentUri, 1038 final String attachmentType, 1039 final int separatorId) { 1040 final Context context = Factory.get().getApplicationContext(); 1041 final SpannableStringBuilder spanBuilder = new SpannableStringBuilder(); 1042 1043 // Boldify the title (which is the sender's name) 1044 if (!TextUtils.isEmpty(title)) { 1045 spanBuilder.append(title); 1046 spanBuilder.setSpan(new StyleSpan(Typeface.BOLD), 0, title.length(), 1047 Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); 1048 } 1049 if (!TextUtils.isEmpty(message)) { 1050 if (spanBuilder.length() > 0) { 1051 spanBuilder.append(context.getString(separatorId)); 1052 } 1053 spanBuilder.append(message); 1054 } 1055 if (attachmentUri != null) { 1056 if (spanBuilder.length() > 0) { 1057 final String separator = context.getString(R.string.notification_separator); 1058 spanBuilder.append(separator); 1059 } 1060 spanBuilder.append(formatAttachmentTag(null, attachmentType)); 1061 } 1062 return spanBuilder; 1063 } 1064 formatAttachmentTag(final String author, final String attachmentType)1065 static CharSequence formatAttachmentTag(final String author, final String attachmentType) { 1066 final Context context = Factory.get().getApplicationContext(); 1067 final TextAppearanceSpan notificationSecondaryText = new TextAppearanceSpan( 1068 context, R.style.NotificationSecondaryText); 1069 final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(); 1070 if (!TextUtils.isEmpty(author)) { 1071 final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan( 1072 context, R.style.NotificationSenderText); 1073 spannableStringBuilder.append(author); 1074 spannableStringBuilder.setSpan(notificationSenderSpan, 0, author.length(), 0); 1075 final String separator = context.getString(R.string.notification_separator); 1076 spannableStringBuilder.append(separator); 1077 } 1078 final int start = spannableStringBuilder.length(); 1079 // The default attachment type is an image, since that's what was originally 1080 // supported. When there's no content type, assume it's an image. 1081 int message = R.string.notification_picture; 1082 if (ContentType.isAudioType(attachmentType)) { 1083 message = R.string.notification_audio; 1084 } else if (ContentType.isVideoType(attachmentType)) { 1085 message = R.string.notification_video; 1086 } else if (ContentType.isVCardType(attachmentType)) { 1087 message = R.string.notification_vcard; 1088 } 1089 spannableStringBuilder.append(context.getText(message)); 1090 spannableStringBuilder.setSpan(notificationSecondaryText, start, 1091 spannableStringBuilder.length(), 0); 1092 return spannableStringBuilder; 1093 } 1094 1095 /** 1096 * Play the observable conversation notification sound (it's the regular notification sound, but 1097 * played at half-volume) 1098 */ playObservableConversationNotificationSound(final Uri ringtoneUri)1099 private static void playObservableConversationNotificationSound(final Uri ringtoneUri) { 1100 final Context context = Factory.get().getApplicationContext(); 1101 final AudioManager audioManager = (AudioManager) context 1102 .getSystemService(Context.AUDIO_SERVICE); 1103 final boolean silenced = 1104 audioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL; 1105 if (silenced) { 1106 return; 1107 } 1108 1109 final NotificationPlayer player = new NotificationPlayer(LogUtil.BUGLE_TAG); 1110 player.play(ringtoneUri, false, 1111 AudioManager.STREAM_NOTIFICATION, 1112 OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME); 1113 1114 // Stop the sound after five seconds to handle continuous ringtones 1115 ThreadUtil.getMainThreadHandler().postDelayed(new Runnable() { 1116 @Override 1117 public void run() { 1118 player.stop(); 1119 } 1120 }, 5000); 1121 } 1122 isWearCompanionAppInstalled()1123 public static boolean isWearCompanionAppInstalled() { 1124 boolean found = false; 1125 try { 1126 Factory.get().getApplicationContext().getPackageManager() 1127 .getPackageInfo(WEARABLE_COMPANION_APP_PACKAGE, 0); 1128 found = true; 1129 } catch (final NameNotFoundException e) { 1130 // Ignore; found is already false 1131 } 1132 return found; 1133 } 1134 1135 /** 1136 * When we go to the conversation list, call this to mark all messages as seen. That means 1137 * we won't show a notification again for the same message. 1138 */ markAllMessagesAsSeen()1139 public static void markAllMessagesAsSeen() { 1140 MarkAsSeenAction.markAllAsSeen(); 1141 resetLastMessageDing(null); // reset the ding timeout for all conversations 1142 } 1143 1144 /** 1145 * When we open a particular conversation, call this to mark all messages as read. 1146 */ markMessagesAsRead(final String conversationId)1147 public static void markMessagesAsRead(final String conversationId) { 1148 MarkAsReadAction.markAsRead(conversationId); 1149 resetLastMessageDing(conversationId); 1150 } 1151 1152 /** 1153 * Returns the conversation ids of all active, grouped notifications, or 1154 * {code null} if no notifications are currently active and grouped. 1155 */ getGroupChildIds(final Context context)1156 private static ConversationIdSet getGroupChildIds(final Context context) { 1157 final String prefKey = context.getString(R.string.notifications_group_children_key); 1158 final String groupChildIdsText = BuglePrefs.getApplicationPrefs().getString(prefKey, ""); 1159 if (!TextUtils.isEmpty(groupChildIdsText)) { 1160 return ConversationIdSet.createSet(groupChildIdsText); 1161 } else { 1162 return null; 1163 } 1164 } 1165 1166 /** 1167 * Records the conversation ids of the currently active grouped notifications. 1168 */ writeGroupChildIds(final Context context, final ConversationIdSet childIds)1169 private static void writeGroupChildIds(final Context context, 1170 final ConversationIdSet childIds) { 1171 final ConversationIdSet oldChildIds = getGroupChildIds(context); 1172 if (childIds.equals(oldChildIds)) { 1173 return; 1174 } 1175 final String prefKey = context.getString(R.string.notifications_group_children_key); 1176 BuglePrefs.getApplicationPrefs().putString(prefKey, childIds.getDelimitedString()); 1177 } 1178 1179 /** 1180 * Reset the timer for a notification ding on a particular conversation or all conversations. 1181 */ resetLastMessageDing(final String conversationId)1182 public static void resetLastMessageDing(final String conversationId) { 1183 synchronized (mLock) { 1184 if (TextUtils.isEmpty(conversationId)) { 1185 // reset all conversation dings 1186 sLastMessageDingTime.clear(); 1187 } else { 1188 sLastMessageDingTime.remove(conversationId); 1189 } 1190 } 1191 } 1192 notifyEmergencySmsFailed(final String emergencyNumber, final String conversationId)1193 public static void notifyEmergencySmsFailed(final String emergencyNumber, 1194 final String conversationId) { 1195 final Context context = Factory.get().getApplicationContext(); 1196 1197 final CharSequence line1 = MessageNotificationState.applyWarningTextColor(context, 1198 context.getString(R.string.notification_emergency_send_failure_line1, 1199 emergencyNumber)); 1200 final String line2 = context.getString(R.string.notification_emergency_send_failure_line2, 1201 emergencyNumber); 1202 final PendingIntent destinationIntent = UIIntents.get() 1203 .getPendingIntentForConversationActivity(context, conversationId, null /* draft */); 1204 1205 final NotificationCompat.Builder builder = new NotificationCompat.Builder(context); 1206 builder.setTicker(line1) 1207 .setContentTitle(line1) 1208 .setContentText(line2) 1209 .setStyle(new NotificationCompat.BigTextStyle(builder).bigText(line2)) 1210 .setSmallIcon(R.drawable.ic_failed_light) 1211 .setContentIntent(destinationIntent) 1212 .setSound(UriUtil.getUriForResourceId(context, R.raw.message_failure)); 1213 1214 final String tag = context.getPackageName() + ":emergency_sms_error"; 1215 NotificationManagerCompat.from(context).notify( 1216 tag, 1217 PendingIntentConstants.MSG_SEND_ERROR, 1218 builder.build()); 1219 } 1220 } 1221 1222