| /* |
| * Copyright (C) 2015 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| package com.android.messaging.datamodel; |
| |
| import android.app.Notification; |
| import android.app.PendingIntent; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.content.pm.PackageManager.NameNotFoundException; |
| import android.content.res.Resources; |
| import android.graphics.Bitmap; |
| import android.graphics.Bitmap.Config; |
| import android.graphics.BitmapFactory; |
| import android.graphics.Typeface; |
| import android.media.AudioManager; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.os.SystemClock; |
| import android.provider.ContactsContract; |
| import android.provider.ContactsContract.Contacts; |
| import android.support.v4.app.NotificationCompat; |
| import android.support.v4.app.NotificationCompat.WearableExtender; |
| import android.support.v4.app.NotificationManagerCompat; |
| import android.support.v4.app.RemoteInput; |
| import android.support.v4.util.SimpleArrayMap; |
| import android.text.Spannable; |
| import android.text.SpannableStringBuilder; |
| import android.text.TextUtils; |
| import android.text.style.StyleSpan; |
| import android.text.style.TextAppearanceSpan; |
| |
| import com.android.messaging.Factory; |
| import com.android.messaging.R; |
| import com.android.messaging.datamodel.MessageNotificationState.BundledMessageNotificationState; |
| import com.android.messaging.datamodel.MessageNotificationState.ConversationLineInfo; |
| import com.android.messaging.datamodel.MessageNotificationState.MultiConversationNotificationState; |
| import com.android.messaging.datamodel.MessageNotificationState.MultiMessageNotificationState; |
| import com.android.messaging.datamodel.action.MarkAsReadAction; |
| import com.android.messaging.datamodel.action.MarkAsSeenAction; |
| import com.android.messaging.datamodel.action.RedownloadMmsAction; |
| import com.android.messaging.datamodel.data.ConversationListItemData; |
| import com.android.messaging.datamodel.media.AvatarRequestDescriptor; |
| import com.android.messaging.datamodel.media.ImageResource; |
| import com.android.messaging.datamodel.media.MediaRequest; |
| import com.android.messaging.datamodel.media.MediaResourceManager; |
| import com.android.messaging.datamodel.media.MessagePartVideoThumbnailRequestDescriptor; |
| import com.android.messaging.datamodel.media.UriImageRequestDescriptor; |
| import com.android.messaging.datamodel.media.VideoThumbnailRequest; |
| import com.android.messaging.sms.MmsSmsUtils; |
| import com.android.messaging.sms.MmsUtils; |
| import com.android.messaging.ui.UIIntents; |
| import com.android.messaging.util.Assert; |
| import com.android.messaging.util.AvatarUriUtil; |
| import com.android.messaging.util.BugleGservices; |
| import com.android.messaging.util.BugleGservicesKeys; |
| import com.android.messaging.util.BuglePrefs; |
| import com.android.messaging.util.BuglePrefsKeys; |
| import com.android.messaging.util.ContentType; |
| import com.android.messaging.util.ConversationIdSet; |
| import com.android.messaging.util.ImageUtils; |
| import com.android.messaging.util.LogUtil; |
| import com.android.messaging.util.NotificationPlayer; |
| import com.android.messaging.util.OsUtil; |
| import com.android.messaging.util.PendingIntentConstants; |
| import com.android.messaging.util.PhoneUtils; |
| import com.android.messaging.util.RingtoneUtil; |
| import com.android.messaging.util.ThreadUtil; |
| import com.android.messaging.util.UriUtil; |
| |
| import java.util.HashSet; |
| import java.util.Iterator; |
| import java.util.List; |
| import java.util.Locale; |
| import java.util.Set; |
| |
| /** |
| * Handle posting, updating and removing all conversation notifications. |
| * |
| * There are currently two main classes of notification and their rules: <p> |
| * 1) Messages - {@link MessageNotificationState}. Only one message notification. |
| * Unread messages across senders and conversations are coalesced.<p> |
| * 2) Failed Messages - {@link MessageNotificationState#checkFailedMesages } Only one failed |
| * message. Multiple failures are coalesced.<p> |
| * |
| * To add a new class of notifications, subclass the NotificationState and add commands which |
| * create one and pass into general creation function. |
| * |
| */ |
| public class BugleNotifications { |
| // Logging |
| public static final String TAG = LogUtil.BUGLE_NOTIFICATIONS_TAG; |
| |
| // Constants to use for update. |
| public static final int UPDATE_NONE = 0; |
| public static final int UPDATE_MESSAGES = 1; |
| public static final int UPDATE_ERRORS = 2; |
| public static final int UPDATE_ALL = UPDATE_MESSAGES + UPDATE_ERRORS; |
| |
| // Constants for notification type used for audio and vibration settings. |
| public static final int LOCAL_SMS_NOTIFICATION = 0; |
| |
| private static final String SMS_NOTIFICATION_TAG = ":sms:"; |
| private static final String SMS_ERROR_NOTIFICATION_TAG = ":error:"; |
| |
| private static final String WEARABLE_COMPANION_APP_PACKAGE = "com.google.android.wearable.app"; |
| |
| private static final Set<NotificationState> sPendingNotifications = |
| new HashSet<NotificationState>(); |
| |
| private static int sWearableImageWidth; |
| private static int sWearableImageHeight; |
| private static int sIconWidth; |
| private static int sIconHeight; |
| |
| private static boolean sInitialized = false; |
| |
| private static final Object mLock = new Object(); |
| |
| // sLastMessageDingTime is a map between a conversation id and a time. It's used to keep track |
| // of the time we last dinged a message for this conversation. When messages are coming in |
| // at flurry, we don't want to over-ding the user. |
| private static final SimpleArrayMap<String, Long> sLastMessageDingTime = |
| new SimpleArrayMap<String, Long>(); |
| private static int sTimeBetweenDingsMs; |
| |
| /** |
| * This is the volume at which to play the observable-conversation notification sound, |
| * expressed as a fraction of the system notification volume. |
| */ |
| private static final float OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME = 0.25f; |
| |
| /** |
| * Entry point for posting notifications. |
| * Don't call this on the UI thread. |
| * @param silent If true, no ring will be played. If false, checks global settings before |
| * playing a ringtone |
| * @param coverage Indicates which notification types should be checked. Valid values are |
| * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL |
| */ |
| public static void update(final boolean silent, final int coverage) { |
| update(silent, null /* conversationId */, coverage); |
| } |
| |
| /** |
| * Entry point for posting notifications. |
| * Don't call this on the UI thread. |
| * @param silent If true, no ring will be played. If false, checks global settings before |
| * playing a ringtone |
| * @param conversationId Conversation ID where a new message was received |
| * @param coverage Indicates which notification types should be checked. Valid values are |
| * UPDATE_NONE, UPDATE_MESSAGES, UPDATE_ERRORS, or UPDATE_ALL |
| */ |
| public static void update(final boolean silent, final String conversationId, |
| final int coverage) { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "Update: silent = " + silent |
| + " conversationId = " + conversationId |
| + " coverage = " + coverage); |
| } |
| Assert.isNotMainThread(); |
| checkInitialized(); |
| |
| if (!shouldNotify()) { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "Notifications disabled"); |
| } |
| cancel(PendingIntentConstants.SMS_NOTIFICATION_ID); |
| return; |
| } else { |
| if ((coverage & UPDATE_MESSAGES) != 0) { |
| createMessageNotification(silent, conversationId); |
| } |
| } |
| if ((coverage & UPDATE_ERRORS) != 0) { |
| MessageNotificationState.checkFailedMessages(); |
| } |
| } |
| |
| /** |
| * Cancel all notifications of a certain type. |
| * |
| * @param type Message or error notifications from Constants. |
| */ |
| private static synchronized void cancel(final int type) { |
| cancel(type, null, false); |
| } |
| |
| /** |
| * Cancel all notifications of a certain type. |
| * |
| * @param type Message or error notifications from Constants. |
| * @param conversationId If set, cancel the notification for this |
| * conversation only. For message notifications, this only works |
| * if the notifications are bundled (group children). |
| * @param isBundledNotification True if this notification is part of a |
| * notification bundle. This only applies to message notifications, |
| * which are bundled together with other message notifications. |
| */ |
| private static synchronized void cancel(final int type, final String conversationId, |
| final boolean isBundledNotification) { |
| final String notificationTag = buildNotificationTag(type, conversationId, |
| isBundledNotification); |
| final NotificationManagerCompat notificationManager = |
| NotificationManagerCompat.from(Factory.get().getApplicationContext()); |
| |
| // Find all pending notifications and cancel them. |
| synchronized (sPendingNotifications) { |
| final Iterator<NotificationState> iter = sPendingNotifications.iterator(); |
| while (iter.hasNext()) { |
| final NotificationState notifState = iter.next(); |
| if (notifState.mType == type) { |
| notifState.mCanceled = true; |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "Canceling pending notification"); |
| } |
| iter.remove(); |
| } |
| } |
| } |
| notificationManager.cancel(notificationTag, type); |
| if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { |
| LogUtil.d(TAG, "Canceled notifications of type " + type); |
| } |
| |
| // Message notifications for multiple conversations can be grouped together (see comment in |
| // createMessageNotification). We need to do bookkeeping to track the current set of |
| // notification group children, including removing them when we cancel notifications). |
| if (type == PendingIntentConstants.SMS_NOTIFICATION_ID) { |
| final Context context = Factory.get().getApplicationContext(); |
| final ConversationIdSet groupChildIds = getGroupChildIds(context); |
| |
| if (groupChildIds != null && groupChildIds.size() > 0) { |
| // If a conversation is specified, remove just that notification. Otherwise, |
| // we're removing the group summary so clear all children. |
| if (conversationId != null) { |
| groupChildIds.remove(conversationId); |
| writeGroupChildIds(context, groupChildIds); |
| } else { |
| cancelStaleGroupChildren(groupChildIds, null); |
| // We'll update the group children preference as we cancel each child, |
| // so we don't need to do it here. |
| } |
| } |
| } |
| } |
| |
| /** |
| * Cancels stale notifications from the currently active group of |
| * notifications. If the {@code state} parameter is an instance of |
| * {@link MultiConversationNotificationState} it represents a new |
| * notification group. This method will cancel any notifications that were |
| * in the old group, but not the new one. If the new notification is not a |
| * group, then all existing grouped notifications are cancelled. |
| * |
| * @param previousGroupChildren Conversation ids for the active notification |
| * group |
| * @param state New notification state |
| */ |
| private static void cancelStaleGroupChildren(final ConversationIdSet previousGroupChildren, |
| final NotificationState state) { |
| final ConversationIdSet newChildren = new ConversationIdSet(); |
| if (state instanceof MultiConversationNotificationState) { |
| for (final NotificationState child : |
| ((MultiConversationNotificationState) state).mChildren) { |
| if (child.mConversationIds != null) { |
| newChildren.add(child.mConversationIds.first()); |
| } |
| } |
| } |
| for (final String childConversationId : previousGroupChildren) { |
| if (!newChildren.contains(childConversationId)) { |
| cancel(PendingIntentConstants.SMS_NOTIFICATION_ID, childConversationId, true); |
| } |
| } |
| } |
| |
| /** |
| * Returns {@code true} if incoming notifications should display a |
| * notification, {@code false} otherwise. |
| * |
| * @return true if the notification should occur |
| */ |
| private static boolean shouldNotify() { |
| // If we're not the default sms app, don't put up any notifications. |
| if (!PhoneUtils.getDefault().isDefaultSmsApp()) { |
| return false; |
| } |
| |
| // Now check prefs (i.e. settings) to see if the user turned off notifications. |
| final BuglePrefs prefs = BuglePrefs.getApplicationPrefs(); |
| final Context context = Factory.get().getApplicationContext(); |
| final String prefKey = context.getString(R.string.notifications_enabled_pref_key); |
| final boolean defaultValue = context.getResources().getBoolean( |
| R.bool.notifications_enabled_pref_default); |
| return prefs.getBoolean(prefKey, defaultValue); |
| } |
| |
| /** |
| * Returns {@code true} if incoming notifications for the given {@link NotificationState} |
| * should vibrate the device, {@code false} otherwise. |
| * |
| * @return true if vibration should be used |
| */ |
| public static boolean shouldVibrate(final NotificationState state) { |
| // The notification should vibrate if the global setting is turned on AND |
| // the per-conversation setting is turned on (default). |
| if (!state.getNotificationVibrate()) { |
| return false; |
| } else { |
| final BuglePrefs prefs = BuglePrefs.getApplicationPrefs(); |
| final Context context = Factory.get().getApplicationContext(); |
| final String prefKey = context.getString(R.string.notification_vibration_pref_key); |
| final boolean defaultValue = context.getResources().getBoolean( |
| R.bool.notification_vibration_pref_default); |
| return prefs.getBoolean(prefKey, defaultValue); |
| } |
| } |
| |
| private static Uri getNotificationRingtoneUriForConversationId(final String conversationId) { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final ConversationListItemData convData = |
| ConversationListItemData.getExistingConversation(db, conversationId); |
| return RingtoneUtil.getNotificationRingtoneUri( |
| convData != null ? convData.getNotificationSoundUri() : null); |
| } |
| |
| /** |
| * Returns a unique tag to identify a notification. |
| * |
| * @param name The tag name (in practice, the type) |
| * @param conversationId The conversation id (optional) |
| */ |
| private static String buildNotificationTag(final String name, |
| final String conversationId) { |
| final Context context = Factory.get().getApplicationContext(); |
| if (conversationId != null) { |
| return context.getPackageName() + name + ":" + conversationId; |
| } else { |
| return context.getPackageName() + name; |
| } |
| } |
| |
| /** |
| * Returns a unique tag to identify a notification. |
| * <p> |
| * This delegates to |
| * {@link #buildNotificationTag(int, String, boolean)} and can be |
| * used when the notification is never bundled (e.g. error notifications). |
| */ |
| static String buildNotificationTag(final int type, final String conversationId) { |
| return buildNotificationTag(type, conversationId, false /* bundledNotification */); |
| } |
| |
| /** |
| * Returns a unique tag to identify a notification. |
| * |
| * @param type One of the constants in {@link PendingIntentConstants} |
| * @param conversationId The conversation id (where applicable) |
| * @param bundledNotification Set to true if this notification will be |
| * bundled together with other notifications (e.g. on a wearable |
| * device). |
| */ |
| static String buildNotificationTag(final int type, final String conversationId, |
| final boolean bundledNotification) { |
| String tag = null; |
| switch(type) { |
| case PendingIntentConstants.SMS_NOTIFICATION_ID: |
| if (bundledNotification) { |
| tag = buildNotificationTag(SMS_NOTIFICATION_TAG, conversationId); |
| } else { |
| tag = buildNotificationTag(SMS_NOTIFICATION_TAG, null); |
| } |
| break; |
| case PendingIntentConstants.MSG_SEND_ERROR: |
| tag = buildNotificationTag(SMS_ERROR_NOTIFICATION_TAG, null); |
| break; |
| } |
| return tag; |
| } |
| |
| private static void checkInitialized() { |
| if (!sInitialized) { |
| final Resources resources = Factory.get().getApplicationContext().getResources(); |
| sWearableImageWidth = resources.getDimensionPixelSize( |
| R.dimen.notification_wearable_image_width); |
| sWearableImageHeight = resources.getDimensionPixelSize( |
| R.dimen.notification_wearable_image_height); |
| sIconHeight = (int) resources.getDimension( |
| android.R.dimen.notification_large_icon_height); |
| sIconWidth = |
| (int) resources.getDimension(android.R.dimen.notification_large_icon_width); |
| |
| sInitialized = true; |
| } |
| } |
| |
| private static void processAndSend(final NotificationState state, final boolean silent, |
| final boolean softSound) { |
| final Context context = Factory.get().getApplicationContext(); |
| final NotificationCompat.Builder notifBuilder = new NotificationCompat.Builder(context); |
| notifBuilder.setCategory(Notification.CATEGORY_MESSAGE); |
| // TODO: Need to fix this for multi conversation notifications to rate limit dings. |
| final String conversationId = state.mConversationIds.first(); |
| |
| |
| final Uri ringtoneUri = RingtoneUtil.getNotificationRingtoneUri(state.getRingtoneUri()); |
| // If the notification's conversation is currently observable (focused or in the |
| // conversation list), then play a notification beep at a low volume and don't display an |
| // actual notification. |
| if (softSound) { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "processAndSend: fromConversationId == " + |
| "sCurrentlyDisplayedConversationId so NOT showing notification," + |
| " but playing soft sound. conversationId: " + conversationId); |
| } |
| playObservableConversationNotificationSound(ringtoneUri); |
| return; |
| } |
| state.mBaseRequestCode = state.mType; |
| |
| // Set the delete intent (except for bundled wearable notifications, which are dismissed |
| // as a group, either from the wearable or when the summary notification is dismissed from |
| // the host device). |
| if (!(state instanceof BundledMessageNotificationState)) { |
| final PendingIntent clearIntent = state.getClearIntent(); |
| notifBuilder.setDeleteIntent(clearIntent); |
| } |
| |
| updateBuilderAudioVibrate(state, notifBuilder, silent, ringtoneUri, conversationId); |
| |
| // Set the content intent |
| PendingIntent destinationIntent; |
| if (state.mConversationIds.size() > 1) { |
| // We have notifications for multiple conversation, go to the conversation list. |
| destinationIntent = UIIntents.get() |
| .getPendingIntentForConversationListActivity(context); |
| } else { |
| // We have a single conversation, go directly to that conversation. |
| destinationIntent = UIIntents.get() |
| .getPendingIntentForConversationActivity(context, |
| state.mConversationIds.first(), |
| null /*draft*/); |
| } |
| notifBuilder.setContentIntent(destinationIntent); |
| |
| // TODO: set based on contact coming from a favorite. |
| notifBuilder.setPriority(state.getPriority()); |
| |
| // Save the state of the notification in-progress so when the avatar is loaded, |
| // we can continue building the notification. |
| final NotificationCompat.Style notifStyle = state.build(notifBuilder); |
| state.mNotificationBuilder = notifBuilder; |
| state.mNotificationStyle = notifStyle; |
| if (!state.mPeople.isEmpty()) { |
| final Bundle people = new Bundle(); |
| people.putStringArray(NotificationCompat.EXTRA_PEOPLE, |
| state.mPeople.toArray(new String[state.mPeople.size()])); |
| notifBuilder.addExtras(people); |
| } |
| |
| if (state.mParticipantAvatarsUris != null) { |
| final Uri avatarUri = state.mParticipantAvatarsUris.get(0); |
| final AvatarRequestDescriptor descriptor = new AvatarRequestDescriptor(avatarUri, |
| sIconWidth, sIconHeight, OsUtil.isAtLeastL()); |
| final MediaRequest<ImageResource> imageRequest = descriptor.buildSyncMediaRequest( |
| context); |
| |
| synchronized (sPendingNotifications) { |
| sPendingNotifications.add(state); |
| } |
| |
| // Synchronously load the avatar. |
| final ImageResource avatarImage = |
| MediaResourceManager.get().requestMediaResourceSync(imageRequest); |
| if (avatarImage != null) { |
| ImageResource avatarHiRes = null; |
| try { |
| if (isWearCompanionAppInstalled()) { |
| // For Wear users, we need to request a high-res avatar image to use as the |
| // notification card background. If the sender has a contact photo, we'll |
| // request the display photo from the Contacts provider. Otherwise, we ask |
| // the local content provider for a hi-res version of the generic avatar |
| // (e.g. letter with colored background). |
| avatarHiRes = requestContactDisplayPhoto(context, |
| getDisplayPhotoUri(avatarUri)); |
| if (avatarHiRes == null) { |
| final AvatarRequestDescriptor hiResDesc = |
| new AvatarRequestDescriptor(avatarUri, |
| sWearableImageWidth, |
| sWearableImageHeight, |
| false /* cropToCircle */, |
| true /* isWearBackground */); |
| avatarHiRes = MediaResourceManager.get().requestMediaResourceSync( |
| hiResDesc.buildSyncMediaRequest(context)); |
| } |
| } |
| |
| // We have to make copies of the bitmaps to hand to the NotificationManager |
| // because the bitmap in the ImageResource is managed and will automatically |
| // get released. |
| Bitmap avatarBitmap = Bitmap.createBitmap(avatarImage.getBitmap()); |
| Bitmap avatarHiResBitmap = (avatarHiRes != null) ? |
| Bitmap.createBitmap(avatarHiRes.getBitmap()) : null; |
| sendNotification(state, avatarBitmap, avatarHiResBitmap); |
| return; |
| } finally { |
| avatarImage.release(); |
| if (avatarHiRes != null) { |
| avatarHiRes.release(); |
| } |
| } |
| } |
| } |
| // We have no avatar. Post the notification anyway. |
| sendNotification(state, null, null); |
| } |
| |
| /** |
| * Returns the thumbnailUri from the avatar URI, or null if avatar URI does not have thumbnail. |
| */ |
| private static Uri getThumbnailUri(final Uri avatarUri) { |
| Uri localUri = null; |
| final String avatarType = AvatarUriUtil.getAvatarType(avatarUri); |
| if (TextUtils.equals(avatarType, AvatarUriUtil.TYPE_LOCAL_RESOURCE_URI)) { |
| localUri = AvatarUriUtil.getPrimaryUri(avatarUri); |
| } else if (UriUtil.isLocalResourceUri(avatarUri)) { |
| localUri = avatarUri; |
| } |
| if (localUri != null && localUri.getAuthority().equals(ContactsContract.AUTHORITY)) { |
| // Contact photos are of the form: content://com.android.contacts/contacts/123/photo |
| final List<String> pathParts = localUri.getPathSegments(); |
| if (pathParts.size() == 3 && |
| pathParts.get(2).equals(Contacts.Photo.CONTENT_DIRECTORY)) { |
| return localUri; |
| } |
| } |
| return null; |
| } |
| |
| /** |
| * Returns the displayPhotoUri from the avatar URI, or null if avatar URI |
| * does not have a displayPhotoUri. |
| */ |
| private static Uri getDisplayPhotoUri(final Uri avatarUri) { |
| final Uri thumbnailUri = getThumbnailUri(avatarUri); |
| if (thumbnailUri == null) { |
| return null; |
| } |
| final List<String> originalPaths = thumbnailUri.getPathSegments(); |
| final int originalPathsSize = originalPaths.size(); |
| final StringBuilder newPathBuilder = new StringBuilder(); |
| // Change content://com.android.contacts/contacts("_corp")/123/photo to |
| // content://com.android.contacts/contacts("_corp")/123/display_photo |
| for (int i = 0; i < originalPathsSize; i++) { |
| newPathBuilder.append('/'); |
| if (i == 2) { |
| newPathBuilder.append(ContactsContract.Contacts.Photo.DISPLAY_PHOTO); |
| } else { |
| newPathBuilder.append(originalPaths.get(i)); |
| } |
| } |
| return thumbnailUri.buildUpon().path(newPathBuilder.toString()).build(); |
| } |
| |
| private static ImageResource requestContactDisplayPhoto(final Context context, |
| final Uri displayPhotoUri) { |
| final UriImageRequestDescriptor bgDescriptor = |
| new UriImageRequestDescriptor(displayPhotoUri, |
| sWearableImageWidth, |
| sWearableImageHeight, |
| false, /* allowCompression */ |
| true, /* isStatic */ |
| false /* cropToCircle */, |
| ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */, |
| ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */); |
| return MediaResourceManager.get().requestMediaResourceSync( |
| bgDescriptor.buildSyncMediaRequest(context)); |
| } |
| |
| private static void createMessageNotification(final boolean silent, |
| final String conversationId) { |
| final NotificationState state = MessageNotificationState.getNotificationState(); |
| final boolean softSound = DataModel.get().isNewMessageObservable(conversationId); |
| if (state == null) { |
| cancel(PendingIntentConstants.SMS_NOTIFICATION_ID); |
| if (softSound && !TextUtils.isEmpty(conversationId)) { |
| final Uri ringtoneUri = getNotificationRingtoneUriForConversationId(conversationId); |
| playObservableConversationNotificationSound(ringtoneUri); |
| } |
| return; |
| } |
| processAndSend(state, silent, softSound); |
| |
| // The rest of the logic here is for supporting Android Wear devices, specifically for when |
| // we are notifying about multiple conversations. In that case, the Inbox-style summary |
| // notification (which we already processed above) appears on the phone (as it always has), |
| // but wearables show per-conversation notifications, bundled together in a group. |
| |
| // It is valid to replace a notification group with another group with fewer conversations, |
| // or even with one notification for a single conversation. In either case, we need to |
| // explicitly cancel any children from the old group which are not being notified about now. |
| final Context context = Factory.get().getApplicationContext(); |
| final ConversationIdSet oldGroupChildIds = getGroupChildIds(context); |
| if (oldGroupChildIds != null && oldGroupChildIds.size() > 0) { |
| cancelStaleGroupChildren(oldGroupChildIds, state); |
| } |
| |
| // Send per-conversation notifications (if there are multiple conversations). |
| final ConversationIdSet groupChildIds = new ConversationIdSet(); |
| if (state instanceof MultiConversationNotificationState) { |
| for (final NotificationState child : |
| ((MultiConversationNotificationState) state).mChildren) { |
| processAndSend(child, true /* silent */, softSound); |
| if (child.mConversationIds != null) { |
| groupChildIds.add(child.mConversationIds.first()); |
| } |
| } |
| } |
| |
| // Record the new set of group children. |
| writeGroupChildIds(context, groupChildIds); |
| } |
| |
| private static void updateBuilderAudioVibrate(final NotificationState state, |
| final NotificationCompat.Builder notifBuilder, final boolean silent, |
| final Uri ringtoneUri, final String conversationId) { |
| int defaults = Notification.DEFAULT_LIGHTS; |
| if (!silent) { |
| final BuglePrefs prefs = Factory.get().getApplicationPrefs(); |
| final long latestNotificationTimestamp = prefs.getLong( |
| BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP, Long.MIN_VALUE); |
| final long latestReceivedTimestamp = state.getLatestReceivedTimestamp(); |
| prefs.putLong( |
| BuglePrefsKeys.LATEST_NOTIFICATION_MESSAGE_TIMESTAMP, |
| Math.max(latestNotificationTimestamp, latestReceivedTimestamp)); |
| if (latestReceivedTimestamp > latestNotificationTimestamp) { |
| synchronized (mLock) { |
| // Find out the last time we dinged for this conversation |
| Long lastTime = sLastMessageDingTime.get(conversationId); |
| if (sTimeBetweenDingsMs == 0) { |
| sTimeBetweenDingsMs = BugleGservices.get().getInt( |
| BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS, |
| BugleGservicesKeys.NOTIFICATION_TIME_BETWEEN_RINGS_SECONDS_DEFAULT) * |
| 1000; |
| } |
| if (lastTime == null |
| || SystemClock.elapsedRealtime() - lastTime > sTimeBetweenDingsMs) { |
| sLastMessageDingTime.put(conversationId, SystemClock.elapsedRealtime()); |
| notifBuilder.setSound(ringtoneUri); |
| if (shouldVibrate(state)) { |
| defaults |= Notification.DEFAULT_VIBRATE; |
| } |
| } |
| } |
| } |
| } |
| notifBuilder.setDefaults(defaults); |
| } |
| |
| // TODO: this doesn't seem to be defined in NotificationCompat yet. Temporarily |
| // define it here until it makes its way from Notification -> NotificationCompat. |
| /** |
| * Notification category: incoming direct message (SMS, instant message, etc.). |
| */ |
| private static final String CATEGORY_MESSAGE = "msg"; |
| |
| private static void sendNotification(final NotificationState notificationState, |
| final Bitmap avatarIcon, final Bitmap avatarHiRes) { |
| final Context context = Factory.get().getApplicationContext(); |
| if (notificationState.mCanceled) { |
| if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { |
| LogUtil.d(TAG, "sendNotification: Notification already cancelled; dropping it"); |
| } |
| return; |
| } |
| |
| synchronized (sPendingNotifications) { |
| if (sPendingNotifications.contains(notificationState)) { |
| sPendingNotifications.remove(notificationState); |
| } |
| } |
| |
| notificationState.mNotificationBuilder |
| .setSmallIcon(notificationState.getIcon()) |
| .setVisibility(NotificationCompat.VISIBILITY_PRIVATE) |
| .setColor(context.getResources().getColor(R.color.notification_accent_color)) |
| // .setPublicVersion(null) // TODO: when/if we ever support different |
| // text on the lockscreen, instead of "contents hidden" |
| .setCategory(CATEGORY_MESSAGE); |
| |
| if (avatarIcon != null) { |
| notificationState.mNotificationBuilder.setLargeIcon(avatarIcon); |
| } |
| |
| if (notificationState.mParticipantContactUris != null && |
| notificationState.mParticipantContactUris.size() > 0) { |
| for (final Uri contactUri : notificationState.mParticipantContactUris) { |
| notificationState.mNotificationBuilder.addPerson(contactUri.toString()); |
| } |
| } |
| |
| final Uri attachmentUri = notificationState.getAttachmentUri(); |
| final String attachmentType = notificationState.getAttachmentType(); |
| Bitmap attachmentBitmap = null; |
| |
| // For messages with photo/video attachment, request an image to show in the notification. |
| if (attachmentUri != null && notificationState.mNotificationStyle != null && |
| (notificationState.mNotificationStyle instanceof |
| NotificationCompat.BigPictureStyle) && |
| (ContentType.isImageType(attachmentType) || |
| ContentType.isVideoType(attachmentType))) { |
| final boolean isVideo = ContentType.isVideoType(attachmentType); |
| |
| MediaRequest<ImageResource> imageRequest; |
| if (isVideo) { |
| Assert.isTrue(VideoThumbnailRequest.shouldShowIncomingVideoThumbnails()); |
| final MessagePartVideoThumbnailRequestDescriptor videoDescriptor = |
| new MessagePartVideoThumbnailRequestDescriptor(attachmentUri); |
| imageRequest = videoDescriptor.buildSyncMediaRequest(context); |
| } else { |
| final UriImageRequestDescriptor imageDescriptor = |
| new UriImageRequestDescriptor(attachmentUri, |
| sWearableImageWidth, |
| sWearableImageHeight, |
| false /* allowCompression */, |
| true /* isStatic */, |
| false /* cropToCircle */, |
| ImageUtils.DEFAULT_CIRCLE_BACKGROUND_COLOR /* circleBackgroundColor */, |
| ImageUtils.DEFAULT_CIRCLE_STROKE_COLOR /* circleStrokeColor */); |
| imageRequest = imageDescriptor.buildSyncMediaRequest(context); |
| } |
| final ImageResource imageResource = |
| MediaResourceManager.get().requestMediaResourceSync(imageRequest); |
| if (imageResource != null) { |
| try { |
| // Copy the bitmap, because the one in the ImageResource is managed by |
| // MediaResourceManager. |
| Bitmap imageResourceBitmap = imageResource.getBitmap(); |
| Config config = imageResourceBitmap.getConfig(); |
| |
| // Make sure our bitmap has a valid format. |
| if (config == null) { |
| config = Bitmap.Config.ARGB_8888; |
| } |
| attachmentBitmap = imageResourceBitmap.copy(config, true); |
| } finally { |
| imageResource.release(); |
| } |
| } |
| } |
| |
| fireOffNotification(notificationState, attachmentBitmap, avatarIcon, avatarHiRes); |
| } |
| |
| private static void fireOffNotification(final NotificationState notificationState, |
| final Bitmap attachmentBitmap, final Bitmap avatarBitmap, Bitmap avatarHiResBitmap) { |
| if (notificationState.mCanceled) { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "Firing off notification, but notification already canceled"); |
| } |
| return; |
| } |
| |
| final Context context = Factory.get().getApplicationContext(); |
| |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "MMS picture loaded, bitmap: " + attachmentBitmap); |
| } |
| |
| final NotificationCompat.Builder notifBuilder = notificationState.mNotificationBuilder; |
| notifBuilder.setStyle(notificationState.mNotificationStyle); |
| notifBuilder.setColor(context.getResources().getColor(R.color.notification_accent_color)); |
| |
| final WearableExtender wearableExtender = new WearableExtender(); |
| setWearableGroupOptions(notifBuilder, notificationState); |
| |
| if (avatarHiResBitmap != null) { |
| wearableExtender.setBackground(avatarHiResBitmap); |
| } else if (avatarBitmap != null) { |
| // Nothing to do here; we already set avatarBitmap as the notification icon |
| } else { |
| final Bitmap defaultBackground = BitmapFactory.decodeResource( |
| context.getResources(), R.drawable.bg_sms); |
| wearableExtender.setBackground(defaultBackground); |
| } |
| |
| if (notificationState instanceof MultiMessageNotificationState) { |
| if (attachmentBitmap != null) { |
| // When we've got a picture attachment, we do some switcheroo trickery. When |
| // the notification is expanded, we show the picture as a bigPicture. The small |
| // icon shows the sender's avatar. When that same notification is collapsed, the |
| // picture is shown in the location where the avatar is normally shown. The lines |
| // below make all that happen. |
| |
| // Here we're taking the picture attachment and making a small, scaled, center |
| // cropped version of the picture we can stuff into the place where the avatar |
| // goes when the notification is collapsed. |
| final Bitmap smallBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap, sIconWidth, |
| sIconHeight); |
| ((NotificationCompat.BigPictureStyle) notificationState.mNotificationStyle) |
| .bigPicture(attachmentBitmap) |
| .bigLargeIcon(avatarBitmap); |
| notificationState.mNotificationBuilder.setLargeIcon(smallBitmap); |
| |
| // Add a wearable page with no visible card so you can more easily see the photo. |
| final NotificationCompat.Builder photoPageNotifBuilder = |
| new NotificationCompat.Builder(Factory.get().getApplicationContext()); |
| final WearableExtender photoPageWearableExtender = new WearableExtender(); |
| photoPageWearableExtender.setHintShowBackgroundOnly(true); |
| if (attachmentBitmap != null) { |
| final Bitmap wearBitmap = ImageUtils.scaleCenterCrop(attachmentBitmap, |
| sWearableImageWidth, sWearableImageHeight); |
| photoPageWearableExtender.setBackground(wearBitmap); |
| } |
| photoPageNotifBuilder.extend(photoPageWearableExtender); |
| wearableExtender.addPage(photoPageNotifBuilder.build()); |
| } |
| |
| maybeAddWearableConversationLog(wearableExtender, |
| (MultiMessageNotificationState) notificationState); |
| addDownloadMmsAction(notifBuilder, wearableExtender, notificationState); |
| addWearableVoiceReplyAction(wearableExtender, notificationState); |
| } |
| |
| // Apply the wearable options and build & post the notification |
| notifBuilder.extend(wearableExtender); |
| doNotify(notifBuilder.build(), notificationState); |
| } |
| |
| private static void setWearableGroupOptions(final NotificationCompat.Builder notifBuilder, |
| final NotificationState notificationState) { |
| final String groupKey = "groupkey"; |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "Group key (for wearables)=" + groupKey); |
| } |
| if (notificationState instanceof MultiConversationNotificationState) { |
| notifBuilder.setGroup(groupKey).setGroupSummary(true); |
| } else if (notificationState instanceof BundledMessageNotificationState) { |
| final int order = ((BundledMessageNotificationState) notificationState).mGroupOrder; |
| // Convert the order to a zero-padded string ("00", "01", "02", etc). |
| // The Wear library orders notifications within a bundle lexicographically |
| // by the sort key, hence the need for zeroes to preserve the ordering. |
| final String sortKey = String.format(Locale.US, "%02d", order); |
| notifBuilder.setGroup(groupKey).setSortKey(sortKey); |
| } |
| } |
| |
| private static void maybeAddWearableConversationLog( |
| final WearableExtender wearableExtender, |
| final MultiMessageNotificationState notificationState) { |
| if (!isWearCompanionAppInstalled()) { |
| return; |
| } |
| final String convId = notificationState.mConversationIds.first(); |
| ConversationLineInfo convInfo = notificationState.mConvList.mConvInfos.get(0); |
| final Notification page = MessageNotificationState.buildConversationPageForWearable( |
| convId, |
| convInfo.mParticipantCount); |
| if (page != null) { |
| wearableExtender.addPage(page); |
| } |
| } |
| |
| private static void addWearableVoiceReplyAction( |
| final WearableExtender wearableExtender, final NotificationState notificationState) { |
| if (!(notificationState instanceof MultiMessageNotificationState)) { |
| return; |
| } |
| final MultiMessageNotificationState multiMessageNotificationState = |
| (MultiMessageNotificationState) notificationState; |
| final Context context = Factory.get().getApplicationContext(); |
| |
| final String conversationId = notificationState.mConversationIds.first(); |
| final ConversationLineInfo convInfo = |
| multiMessageNotificationState.mConvList.mConvInfos.get(0); |
| final String selfId = convInfo.mSelfParticipantId; |
| |
| final boolean requiresMms = |
| MmsSmsUtils.getRequireMmsForEmailAddress( |
| convInfo.mIncludeEmailAddress, convInfo.mSubId) || |
| (convInfo.mIsGroup && MmsUtils.groupMmsEnabled(convInfo.mSubId)); |
| |
| final int requestCode = multiMessageNotificationState.getReplyIntentRequestCode(); |
| final PendingIntent replyPendingIntent = UIIntents.get() |
| .getPendingIntentForSendingMessageToConversation(context, |
| conversationId, selfId, requiresMms, requestCode); |
| |
| final int replyLabelRes = requiresMms ? R.string.notification_reply_via_mms : |
| R.string.notification_reply_via_sms; |
| |
| final NotificationCompat.Action.Builder actionBuilder = |
| new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply, |
| context.getString(replyLabelRes), replyPendingIntent); |
| final String[] choices = context.getResources().getStringArray( |
| R.array.notification_reply_choices); |
| final RemoteInput remoteInput = new RemoteInput.Builder(Intent.EXTRA_TEXT).setLabel( |
| context.getString(R.string.notification_reply_prompt)). |
| setChoices(choices) |
| .build(); |
| actionBuilder.addRemoteInput(remoteInput); |
| wearableExtender.addAction(actionBuilder.build()); |
| } |
| |
| private static void addDownloadMmsAction(final NotificationCompat.Builder notifBuilder, |
| final WearableExtender wearableExtender, final NotificationState notificationState) { |
| if (!(notificationState instanceof MultiMessageNotificationState)) { |
| return; |
| } |
| final MultiMessageNotificationState multiMessageNotificationState = |
| (MultiMessageNotificationState) notificationState; |
| final ConversationLineInfo convInfo = |
| multiMessageNotificationState.mConvList.mConvInfos.get(0); |
| if (!convInfo.getDoesLatestMessageNeedDownload()) { |
| return; |
| } |
| final String messageId = convInfo.getLatestMessageId(); |
| if (messageId == null) { |
| // No message Id, no download for you |
| return; |
| } |
| final Context context = Factory.get().getApplicationContext(); |
| final PendingIntent downloadPendingIntent = |
| RedownloadMmsAction.getPendingIntentForRedownloadMms(context, messageId); |
| |
| final NotificationCompat.Action.Builder actionBuilder = |
| new NotificationCompat.Action.Builder(R.drawable.ic_file_download_light, |
| context.getString(R.string.notification_download_mms), |
| downloadPendingIntent); |
| final NotificationCompat.Action downloadAction = actionBuilder.build(); |
| notifBuilder.addAction(downloadAction); |
| |
| // Support the action on a wearable device as well |
| wearableExtender.addAction(downloadAction); |
| } |
| |
| private static synchronized void doNotify(final Notification notification, |
| final NotificationState notificationState) { |
| if (notification == null) { |
| return; |
| } |
| final int type = notificationState.mType; |
| final ConversationIdSet conversationIds = notificationState.mConversationIds; |
| final boolean isBundledNotification = |
| (notificationState instanceof BundledMessageNotificationState); |
| |
| // Mark the notification as finished |
| notificationState.mCanceled = true; |
| |
| final NotificationManagerCompat notificationManager = |
| NotificationManagerCompat.from(Factory.get().getApplicationContext()); |
| // Only need conversationId for tags with a single conversation. |
| String conversationId = null; |
| if (conversationIds != null && conversationIds.size() == 1) { |
| conversationId = conversationIds.first(); |
| } |
| final String notificationTag = buildNotificationTag(type, |
| conversationId, isBundledNotification); |
| |
| notification.flags |= Notification.FLAG_AUTO_CANCEL; |
| notification.defaults |= Notification.DEFAULT_LIGHTS; |
| |
| notificationManager.notify(notificationTag, type, notification); |
| |
| LogUtil.i(TAG, "Notifying for conversation " + conversationId + "; " |
| + "tag = " + notificationTag + ", type = " + type); |
| } |
| |
| // This is the message string used in each line of an inboxStyle notification. |
| // TODO: add attachment type |
| static CharSequence formatInboxMessage(final String sender, |
| final CharSequence message, final Uri attachmentUri, final String attachmentType) { |
| final Context context = Factory.get().getApplicationContext(); |
| final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan( |
| context, R.style.NotificationSenderText); |
| |
| final TextAppearanceSpan notificationTertiaryText = new TextAppearanceSpan( |
| context, R.style.NotificationTertiaryText); |
| |
| final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(); |
| if (!TextUtils.isEmpty(sender)) { |
| spannableStringBuilder.append(sender); |
| spannableStringBuilder.setSpan(notificationSenderSpan, 0, sender.length(), 0); |
| } |
| final String separator = context.getString(R.string.notification_separator); |
| |
| if (!TextUtils.isEmpty(message)) { |
| if (spannableStringBuilder.length() > 0) { |
| spannableStringBuilder.append(separator); |
| } |
| final int start = spannableStringBuilder.length(); |
| spannableStringBuilder.append(message); |
| spannableStringBuilder.setSpan(notificationTertiaryText, start, |
| start + message.length(), 0); |
| } |
| if (attachmentUri != null) { |
| if (spannableStringBuilder.length() > 0) { |
| spannableStringBuilder.append(separator); |
| } |
| spannableStringBuilder.append(formatAttachmentTag(null, attachmentType)); |
| } |
| return spannableStringBuilder; |
| } |
| |
| protected static CharSequence buildColonSeparatedMessage( |
| final String title, final CharSequence content, final Uri attachmentUri, |
| final String attachmentType) { |
| return buildBoldedMessage(title, content, attachmentUri, attachmentType, |
| R.string.notification_ticker_separator); |
| } |
| |
| protected static CharSequence buildSpaceSeparatedMessage( |
| final String title, final CharSequence content, final Uri attachmentUri, |
| final String attachmentType) { |
| return buildBoldedMessage(title, content, attachmentUri, attachmentType, |
| R.string.notification_space_separator); |
| } |
| |
| /** |
| * buildBoldedMessage - build a formatted message where the title is bold, there's a |
| * separator, then the message. |
| */ |
| private static CharSequence buildBoldedMessage( |
| final String title, final CharSequence message, final Uri attachmentUri, |
| final String attachmentType, |
| final int separatorId) { |
| final Context context = Factory.get().getApplicationContext(); |
| final SpannableStringBuilder spanBuilder = new SpannableStringBuilder(); |
| |
| // Boldify the title (which is the sender's name) |
| if (!TextUtils.isEmpty(title)) { |
| spanBuilder.append(title); |
| spanBuilder.setSpan(new StyleSpan(Typeface.BOLD), 0, title.length(), |
| Spannable.SPAN_EXCLUSIVE_EXCLUSIVE); |
| } |
| if (!TextUtils.isEmpty(message)) { |
| if (spanBuilder.length() > 0) { |
| spanBuilder.append(context.getString(separatorId)); |
| } |
| spanBuilder.append(message); |
| } |
| if (attachmentUri != null) { |
| if (spanBuilder.length() > 0) { |
| final String separator = context.getString(R.string.notification_separator); |
| spanBuilder.append(separator); |
| } |
| spanBuilder.append(formatAttachmentTag(null, attachmentType)); |
| } |
| return spanBuilder; |
| } |
| |
| static CharSequence formatAttachmentTag(final String author, final String attachmentType) { |
| final Context context = Factory.get().getApplicationContext(); |
| final TextAppearanceSpan notificationSecondaryText = new TextAppearanceSpan( |
| context, R.style.NotificationSecondaryText); |
| final SpannableStringBuilder spannableStringBuilder = new SpannableStringBuilder(); |
| if (!TextUtils.isEmpty(author)) { |
| final TextAppearanceSpan notificationSenderSpan = new TextAppearanceSpan( |
| context, R.style.NotificationSenderText); |
| spannableStringBuilder.append(author); |
| spannableStringBuilder.setSpan(notificationSenderSpan, 0, author.length(), 0); |
| final String separator = context.getString(R.string.notification_separator); |
| spannableStringBuilder.append(separator); |
| } |
| final int start = spannableStringBuilder.length(); |
| // The default attachment type is an image, since that's what was originally |
| // supported. When there's no content type, assume it's an image. |
| int message = R.string.notification_picture; |
| if (ContentType.isAudioType(attachmentType)) { |
| message = R.string.notification_audio; |
| } else if (ContentType.isVideoType(attachmentType)) { |
| message = R.string.notification_video; |
| } else if (ContentType.isVCardType(attachmentType)) { |
| message = R.string.notification_vcard; |
| } |
| spannableStringBuilder.append(context.getText(message)); |
| spannableStringBuilder.setSpan(notificationSecondaryText, start, |
| spannableStringBuilder.length(), 0); |
| return spannableStringBuilder; |
| } |
| |
| /** |
| * Play the observable conversation notification sound (it's the regular notification sound, but |
| * played at half-volume) |
| */ |
| private static void playObservableConversationNotificationSound(final Uri ringtoneUri) { |
| final Context context = Factory.get().getApplicationContext(); |
| final AudioManager audioManager = (AudioManager) context |
| .getSystemService(Context.AUDIO_SERVICE); |
| final boolean silenced = |
| audioManager.getRingerMode() != AudioManager.RINGER_MODE_NORMAL; |
| if (silenced) { |
| return; |
| } |
| |
| final NotificationPlayer player = new NotificationPlayer(LogUtil.BUGLE_TAG); |
| player.play(ringtoneUri, false, |
| AudioManager.STREAM_NOTIFICATION, |
| OBSERVABLE_CONVERSATION_NOTIFICATION_VOLUME); |
| |
| // Stop the sound after five seconds to handle continuous ringtones |
| ThreadUtil.getMainThreadHandler().postDelayed(new Runnable() { |
| @Override |
| public void run() { |
| player.stop(); |
| } |
| }, 5000); |
| } |
| |
| public static boolean isWearCompanionAppInstalled() { |
| boolean found = false; |
| try { |
| Factory.get().getApplicationContext().getPackageManager() |
| .getPackageInfo(WEARABLE_COMPANION_APP_PACKAGE, 0); |
| found = true; |
| } catch (final NameNotFoundException e) { |
| // Ignore; found is already false |
| } |
| return found; |
| } |
| |
| /** |
| * When we go to the conversation list, call this to mark all messages as seen. That means |
| * we won't show a notification again for the same message. |
| */ |
| public static void markAllMessagesAsSeen() { |
| MarkAsSeenAction.markAllAsSeen(); |
| resetLastMessageDing(null); // reset the ding timeout for all conversations |
| } |
| |
| /** |
| * When we open a particular conversation, call this to mark all messages as read. |
| */ |
| public static void markMessagesAsRead(final String conversationId) { |
| MarkAsReadAction.markAsRead(conversationId); |
| resetLastMessageDing(conversationId); |
| } |
| |
| /** |
| * Returns the conversation ids of all active, grouped notifications, or |
| * {code null} if no notifications are currently active and grouped. |
| */ |
| private static ConversationIdSet getGroupChildIds(final Context context) { |
| final String prefKey = context.getString(R.string.notifications_group_children_key); |
| final String groupChildIdsText = BuglePrefs.getApplicationPrefs().getString(prefKey, ""); |
| if (!TextUtils.isEmpty(groupChildIdsText)) { |
| return ConversationIdSet.createSet(groupChildIdsText); |
| } else { |
| return null; |
| } |
| } |
| |
| /** |
| * Records the conversation ids of the currently active grouped notifications. |
| */ |
| private static void writeGroupChildIds(final Context context, |
| final ConversationIdSet childIds) { |
| final ConversationIdSet oldChildIds = getGroupChildIds(context); |
| if (childIds.equals(oldChildIds)) { |
| return; |
| } |
| final String prefKey = context.getString(R.string.notifications_group_children_key); |
| BuglePrefs.getApplicationPrefs().putString(prefKey, childIds.getDelimitedString()); |
| } |
| |
| /** |
| * Reset the timer for a notification ding on a particular conversation or all conversations. |
| */ |
| public static void resetLastMessageDing(final String conversationId) { |
| synchronized (mLock) { |
| if (TextUtils.isEmpty(conversationId)) { |
| // reset all conversation dings |
| sLastMessageDingTime.clear(); |
| } else { |
| sLastMessageDingTime.remove(conversationId); |
| } |
| } |
| } |
| |
| public static void notifyEmergencySmsFailed(final String emergencyNumber, |
| final String conversationId) { |
| final Context context = Factory.get().getApplicationContext(); |
| |
| final CharSequence line1 = MessageNotificationState.applyWarningTextColor(context, |
| context.getString(R.string.notification_emergency_send_failure_line1, |
| emergencyNumber)); |
| final String line2 = context.getString(R.string.notification_emergency_send_failure_line2, |
| emergencyNumber); |
| final PendingIntent destinationIntent = UIIntents.get() |
| .getPendingIntentForConversationActivity(context, conversationId, null /* draft */); |
| |
| final NotificationCompat.Builder builder = new NotificationCompat.Builder(context); |
| builder.setTicker(line1) |
| .setContentTitle(line1) |
| .setContentText(line2) |
| .setStyle(new NotificationCompat.BigTextStyle(builder).bigText(line2)) |
| .setSmallIcon(R.drawable.ic_failed_light) |
| .setContentIntent(destinationIntent) |
| .setSound(UriUtil.getUriForResourceId(context, R.raw.message_failure)); |
| |
| final String tag = context.getPackageName() + ":emergency_sms_error"; |
| NotificationManagerCompat.from(context).notify( |
| tag, |
| PendingIntentConstants.MSG_SEND_ERROR, |
| builder.build()); |
| } |
| } |
| |
