1package eu.siacs.conversations.services;
2
3import android.app.Notification;
4import android.app.PendingIntent;
5import android.content.Intent;
6import android.content.SharedPreferences;
7import android.content.res.Resources;
8import android.graphics.Bitmap;
9import android.graphics.Typeface;
10import android.net.Uri;
11import android.os.Build;
12import android.os.SystemClock;
13import android.preference.PreferenceManager;
14import android.support.v4.app.NotificationCompat;
15import android.support.v4.app.NotificationCompat.BigPictureStyle;
16import android.support.v4.app.NotificationCompat.Builder;
17import android.support.v4.app.NotificationManagerCompat;
18import android.support.v4.app.NotificationCompat.CarExtender.UnreadConversation;
19import android.support.v4.app.RemoteInput;
20import android.support.v4.content.ContextCompat;
21import android.text.SpannableString;
22import android.text.style.StyleSpan;
23import android.util.DisplayMetrics;
24import android.util.Log;
25import android.util.Pair;
26
27import java.io.File;
28import java.io.FileNotFoundException;
29import java.util.ArrayList;
30import java.util.Calendar;
31import java.util.HashMap;
32import java.util.Iterator;
33import java.util.LinkedHashMap;
34import java.util.List;
35import java.util.Map;
36import java.util.concurrent.atomic.AtomicInteger;
37import java.util.regex.Matcher;
38import java.util.regex.Pattern;
39
40import eu.siacs.conversations.Config;
41import eu.siacs.conversations.R;
42import eu.siacs.conversations.entities.Account;
43import eu.siacs.conversations.entities.Contact;
44import eu.siacs.conversations.entities.Conversation;
45import eu.siacs.conversations.entities.Message;
46import eu.siacs.conversations.persistance.FileBackend;
47import eu.siacs.conversations.ui.ConversationActivity;
48import eu.siacs.conversations.ui.ManageAccountActivity;
49import eu.siacs.conversations.ui.SettingsActivity;
50import eu.siacs.conversations.ui.TimePreference;
51import eu.siacs.conversations.utils.GeoHelper;
52import eu.siacs.conversations.utils.UIHelper;
53import eu.siacs.conversations.xmpp.XmppConnection;
54
55public class NotificationService {
56
57 public static final Object CATCHUP_LOCK = new Object();
58
59 private static final String CONVERSATIONS_GROUP = "eu.siacs.conversations";
60 private final XmppConnectionService mXmppConnectionService;
61
62 private final LinkedHashMap<String, ArrayList<Message>> notifications = new LinkedHashMap<>();
63
64 private static final int NOTIFICATION_ID_MULTIPLIER = 1024 * 1024;
65
66 public static final int NOTIFICATION_ID = 2 * NOTIFICATION_ID_MULTIPLIER;
67 public static final int FOREGROUND_NOTIFICATION_ID = NOTIFICATION_ID_MULTIPLIER * 4;
68 public static final int ERROR_NOTIFICATION_ID = NOTIFICATION_ID_MULTIPLIER * 6;
69
70 private Conversation mOpenConversation;
71 private boolean mIsInForeground;
72 private long mLastNotification;
73
74 private final HashMap<Conversation,AtomicInteger> mBacklogMessageCounter = new HashMap<>();
75
76 public NotificationService(final XmppConnectionService service) {
77 this.mXmppConnectionService = service;
78 }
79
80 public boolean notify(final Message message) {
81 return message.getStatus() == Message.STATUS_RECEIVED
82 && notificationsEnabled()
83 && !message.getConversation().isMuted()
84 && (message.getConversation().alwaysNotify() || wasHighlightedOrPrivate(message))
85 && (!message.getConversation().isWithStranger() || notificationsFromStrangers())
86 ;
87 }
88
89 public boolean notificationsEnabled() {
90 return mXmppConnectionService.getBooleanPreference("show_notification",R.bool.show_notification);
91 }
92
93 private boolean notificationsFromStrangers() {
94 return mXmppConnectionService.getBooleanPreference("notifications_from_strangers",R.bool.notifications_from_strangers);
95 }
96
97 public boolean isQuietHours() {
98 if (!mXmppConnectionService.getBooleanPreference("enable_quiet_hours", R.bool.enable_quiet_hours)) {
99 return false;
100 }
101 final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mXmppConnectionService);
102 final long startTime = preferences.getLong("quiet_hours_start", TimePreference.DEFAULT_VALUE) % Config.MILLISECONDS_IN_DAY;
103 final long endTime = preferences.getLong("quiet_hours_end", TimePreference.DEFAULT_VALUE) % Config.MILLISECONDS_IN_DAY;
104 final long nowTime = Calendar.getInstance().getTimeInMillis() % Config.MILLISECONDS_IN_DAY;
105
106 if (endTime < startTime) {
107 return nowTime > startTime || nowTime < endTime;
108 } else {
109 return nowTime > startTime && nowTime < endTime;
110 }
111 }
112
113 public void pushFromBacklog(final Message message) {
114 if (notify(message)) {
115 synchronized (notifications) {
116 getBacklogMessageCounter(message.getConversation()).incrementAndGet();
117 pushToStack(message);
118 }
119 }
120 }
121
122 private AtomicInteger getBacklogMessageCounter(Conversation conversation) {
123 synchronized (mBacklogMessageCounter) {
124 if (!mBacklogMessageCounter.containsKey(conversation)) {
125 mBacklogMessageCounter.put(conversation,new AtomicInteger(0));
126 }
127 return mBacklogMessageCounter.get(conversation);
128 }
129 }
130
131 public void pushFromDirectReply(final Message message) {
132 synchronized (notifications) {
133 pushToStack(message);
134 updateNotification(false);
135 }
136 }
137
138 public void finishBacklog(boolean notify, Account account) {
139 synchronized (notifications) {
140 mXmppConnectionService.updateUnreadCountBadge();
141 if (account == null || !notify) {
142 updateNotification(notify);
143 } else {
144 updateNotification(getBacklogMessageCount(account) > 0);
145 }
146 }
147 }
148
149 private int getBacklogMessageCount(Account account) {
150 int count = 0;
151 synchronized (this.mBacklogMessageCounter) {
152 for(Iterator<Map.Entry<Conversation, AtomicInteger>> it = mBacklogMessageCounter.entrySet().iterator(); it.hasNext(); ) {
153 Map.Entry<Conversation, AtomicInteger> entry = it.next();
154 if (entry.getKey().getAccount() == account) {
155 count += entry.getValue().get();
156 it.remove();
157 }
158 }
159 }
160 Log.d(Config.LOGTAG,account.getJid().toBareJid()+": backlog message count="+count);
161 return count;
162 }
163
164 public void finishBacklog(boolean notify) {
165 finishBacklog(notify,null);
166 }
167
168 private void pushToStack(final Message message) {
169 final String conversationUuid = message.getConversationUuid();
170 if (notifications.containsKey(conversationUuid)) {
171 notifications.get(conversationUuid).add(message);
172 } else {
173 final ArrayList<Message> mList = new ArrayList<>();
174 mList.add(message);
175 notifications.put(conversationUuid, mList);
176 }
177 }
178
179 public void push(final Message message) {
180 synchronized (CATCHUP_LOCK) {
181 final XmppConnection connection = message.getConversation().getAccount().getXmppConnection();
182 if (connection.isWaitingForSmCatchup()) {
183 connection.incrementSmCatchupMessageCounter();
184 pushFromBacklog(message);
185 } else {
186 pushNow(message);
187 }
188 }
189 }
190
191 private void pushNow(final Message message) {
192 mXmppConnectionService.updateUnreadCountBadge();
193 if (!notify(message)) {
194 Log.d(Config.LOGTAG,message.getConversation().getAccount().getJid().toBareJid()+": suppressing notification because turned off");
195 return;
196 }
197 final boolean isScreenOn = mXmppConnectionService.isInteractive();
198 if (this.mIsInForeground && isScreenOn && this.mOpenConversation == message.getConversation()) {
199 Log.d(Config.LOGTAG,message.getConversation().getAccount().getJid().toBareJid()+": suppressing notification because conversation is open");
200 return;
201 }
202 synchronized (notifications) {
203 pushToStack(message);
204 final Account account = message.getConversation().getAccount();
205 final boolean doNotify = (!(this.mIsInForeground && this.mOpenConversation == null) || !isScreenOn)
206 && !account.inGracePeriod()
207 && !this.inMiniGracePeriod(account);
208 updateNotification(doNotify);
209 }
210 }
211
212 public void clear() {
213 synchronized (notifications) {
214 for(ArrayList<Message> messages : notifications.values()) {
215 markAsReadIfHasDirectReply(messages);
216 }
217 notifications.clear();
218 updateNotification(false);
219 }
220 }
221
222 public void clear(final Conversation conversation) {
223 synchronized (this.mBacklogMessageCounter) {
224 this.mBacklogMessageCounter.remove(conversation);
225 }
226 synchronized (notifications) {
227 markAsReadIfHasDirectReply(conversation);
228 if (notifications.remove(conversation.getUuid()) != null) {
229 final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(mXmppConnectionService);
230 notificationManager.cancel(conversation.getUuid(), NOTIFICATION_ID);
231 updateNotification(false, true);
232 }
233 }
234 }
235
236 private void markAsReadIfHasDirectReply(final Conversation conversation) {
237 markAsReadIfHasDirectReply(notifications.get(conversation.getUuid()));
238 }
239
240 private void markAsReadIfHasDirectReply(final ArrayList<Message> messages) {
241 if (messages != null && messages.size() > 0) {
242 Message last = messages.get(messages.size() - 1);
243 if (last.getStatus() != Message.STATUS_RECEIVED) {
244 if (mXmppConnectionService.markRead(last.getConversation(), false)) {
245 mXmppConnectionService.updateConversationUi();
246 }
247 }
248 }
249 }
250
251 private void setNotificationColor(final Builder mBuilder) {
252 mBuilder.setColor(ContextCompat.getColor(mXmppConnectionService, R.color.primary500));
253 }
254
255 public void updateNotification(final boolean notify) {
256 updateNotification(notify, false);
257 }
258
259 public void updateNotification(final boolean notify, boolean summaryOnly) {
260 final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(mXmppConnectionService);
261 final SharedPreferences preferences = PreferenceManager.getDefaultSharedPreferences(mXmppConnectionService);
262
263 if (notifications.size() == 0) {
264 notificationManager.cancel(NOTIFICATION_ID);
265 } else {
266 if (notify) {
267 this.markLastNotification();
268 }
269 final Builder mBuilder;
270 if (notifications.size() == 1 && Build.VERSION.SDK_INT < Build.VERSION_CODES.N) {
271 mBuilder = buildSingleConversations(notifications.values().iterator().next());
272 modifyForSoundVibrationAndLight(mBuilder, notify, preferences);
273 notificationManager.notify(NOTIFICATION_ID, mBuilder.build());
274 } else {
275 mBuilder = buildMultipleConversation();
276 modifyForSoundVibrationAndLight(mBuilder, notify, preferences);
277 if (!summaryOnly) {
278 for (Map.Entry<String, ArrayList<Message>> entry : notifications.entrySet()) {
279 Builder singleBuilder = buildSingleConversations(entry.getValue());
280 singleBuilder.setGroup(CONVERSATIONS_GROUP);
281 setNotificationColor(singleBuilder);
282 notificationManager.notify(entry.getKey(), NOTIFICATION_ID, singleBuilder.build());
283 }
284 }
285 notificationManager.notify(NOTIFICATION_ID, mBuilder.build());
286 }
287 }
288 }
289
290
291 private void modifyForSoundVibrationAndLight(Builder mBuilder, boolean notify, SharedPreferences preferences) {
292 final Resources resources = mXmppConnectionService.getResources();
293 final String ringtone = preferences.getString("notification_ringtone", resources.getString(R.string.notification_ringtone));
294 final boolean vibrate = preferences.getBoolean("vibrate_on_notification", resources.getBoolean(R.bool.vibrate_on_notification));
295 final boolean led = preferences.getBoolean("led", resources.getBoolean(R.bool.led));
296 final boolean headsup = preferences.getBoolean("notification_headsup", resources.getBoolean(R.bool.headsup_notifications));
297 if (notify && !isQuietHours()) {
298 if (vibrate) {
299 final int dat = 70;
300 final long[] pattern = {0, 3 * dat, dat, dat};
301 mBuilder.setVibrate(pattern);
302 } else {
303 mBuilder.setVibrate(new long[]{0});
304 }
305 Uri uri = Uri.parse(ringtone);
306 try {
307 mBuilder.setSound(fixRingtoneUri(uri));
308 } catch (SecurityException e) {
309 Log.d(Config.LOGTAG,"unable to use custom notification sound "+uri.toString());
310 }
311 }
312 if (android.os.Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
313 mBuilder.setCategory(Notification.CATEGORY_MESSAGE);
314 }
315 mBuilder.setPriority(notify ? (headsup ? NotificationCompat.PRIORITY_HIGH : NotificationCompat.PRIORITY_DEFAULT) : NotificationCompat.PRIORITY_LOW);
316 setNotificationColor(mBuilder);
317 mBuilder.setDefaults(0);
318 if (led) {
319 mBuilder.setLights(0xff00FF00, 2000, 3000);
320 }
321 }
322
323 private Uri fixRingtoneUri(Uri uri) {
324 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N && "file".equals(uri.getScheme())) {
325 return FileBackend.getUriForFile(mXmppConnectionService,new File(uri.getPath()));
326 } else {
327 return uri;
328 }
329 }
330
331 private Builder buildMultipleConversation() {
332 final Builder mBuilder = new NotificationCompat.Builder(
333 mXmppConnectionService);
334 final NotificationCompat.InboxStyle style = new NotificationCompat.InboxStyle();
335 style.setBigContentTitle(notifications.size()
336 + " "
337 + mXmppConnectionService
338 .getString(R.string.unread_conversations));
339 final StringBuilder names = new StringBuilder();
340 Conversation conversation = null;
341 for (final ArrayList<Message> messages : notifications.values()) {
342 if (messages.size() > 0) {
343 conversation = messages.get(0).getConversation();
344 final String name = conversation.getName();
345 SpannableString styledString;
346 if (Config.HIDE_MESSAGE_TEXT_IN_NOTIFICATION) {
347 int count = messages.size();
348 styledString = new SpannableString(name + ": " + mXmppConnectionService.getResources().getQuantityString(R.plurals.x_messages,count,count));
349 styledString.setSpan(new StyleSpan(Typeface.BOLD), 0, name.length(), 0);
350 style.addLine(styledString);
351 } else {
352 styledString = new SpannableString(name + ": " + UIHelper.getMessagePreview(mXmppConnectionService, messages.get(0)).first);
353 styledString.setSpan(new StyleSpan(Typeface.BOLD), 0, name.length(), 0);
354 style.addLine(styledString);
355 }
356 names.append(name);
357 names.append(", ");
358 }
359 }
360 if (names.length() >= 2) {
361 names.delete(names.length() - 2, names.length());
362 }
363 mBuilder.setContentTitle(notifications.size()
364 + " "
365 + mXmppConnectionService
366 .getString(R.string.unread_conversations));
367 mBuilder.setContentText(names.toString());
368 mBuilder.setStyle(style);
369 if (conversation != null) {
370 mBuilder.setContentIntent(createContentIntent(conversation));
371 }
372 mBuilder.setGroupSummary(true);
373 mBuilder.setGroup(CONVERSATIONS_GROUP);
374 mBuilder.setDeleteIntent(createDeleteIntent(null));
375 mBuilder.setSmallIcon(R.drawable.ic_notification);
376 return mBuilder;
377 }
378
379 private Builder buildSingleConversations(final ArrayList<Message> messages) {
380 final Builder mBuilder = new NotificationCompat.Builder(mXmppConnectionService);
381 if (messages.size() >= 1) {
382 final Conversation conversation = messages.get(0).getConversation();
383 final UnreadConversation.Builder mUnreadBuilder = new UnreadConversation.Builder(conversation.getName());
384 mBuilder.setLargeIcon(mXmppConnectionService.getAvatarService()
385 .get(conversation, getPixel(64)));
386 mBuilder.setContentTitle(conversation.getName());
387 if (Config.HIDE_MESSAGE_TEXT_IN_NOTIFICATION) {
388 int count = messages.size();
389 mBuilder.setContentText(mXmppConnectionService.getResources().getQuantityString(R.plurals.x_messages,count,count));
390 } else {
391 Message message;
392 if ((message = getImage(messages)) != null) {
393 modifyForImage(mBuilder, mUnreadBuilder, message, messages);
394 } else {
395 modifyForTextOnly(mBuilder, mUnreadBuilder, messages);
396 }
397 RemoteInput remoteInput = new RemoteInput.Builder("text_reply").setLabel(UIHelper.getMessageHint(mXmppConnectionService, conversation)).build();
398 NotificationCompat.Action markReadAction = new NotificationCompat.Action.Builder(R.drawable.ic_send_text_offline, "Mark As Read", createReadPendingIntent(conversation)).build();
399 NotificationCompat.Action replyAction = new NotificationCompat.Action.Builder(R.drawable.ic_send_text_offline, "Reply", createReplyIntent(conversation, false)).addRemoteInput(remoteInput).build();
400 NotificationCompat.Action wearReplyAction = new NotificationCompat.Action.Builder(R.drawable.ic_wear_reply, "Reply", createReplyIntent(conversation, true)).addRemoteInput(remoteInput).build();
401 mBuilder.extend(new NotificationCompat.WearableExtender().addAction(wearReplyAction));
402 mUnreadBuilder.setReplyAction(createReplyIntent(conversation, true), remoteInput);
403 mUnreadBuilder.setReadPendingIntent(createReadPendingIntent(conversation));
404 mBuilder.extend(new NotificationCompat.CarExtender().setUnreadConversation(mUnreadBuilder.build()));
405 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
406 mBuilder.addAction(markReadAction);
407 mBuilder.addAction(replyAction);
408 }
409 if ((message = getFirstDownloadableMessage(messages)) != null) {
410 mBuilder.addAction(
411 Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP ?
412 R.drawable.ic_file_download_white_24dp : R.drawable.ic_action_download,
413 mXmppConnectionService.getResources().getString(R.string.download_x_file,
414 UIHelper.getFileDescriptionString(mXmppConnectionService, message)),
415 createDownloadIntent(message)
416 );
417 }
418 if ((message = getFirstLocationMessage(messages)) != null) {
419 mBuilder.addAction(R.drawable.ic_room_white_24dp,
420 mXmppConnectionService.getString(R.string.show_location),
421 createShowLocationIntent(message));
422 }
423 }
424 if (conversation.getMode() == Conversation.MODE_SINGLE) {
425 Contact contact = conversation.getContact();
426 Uri systemAccount = contact.getSystemAccount();
427 if (systemAccount != null) {
428 mBuilder.addPerson(systemAccount.toString());
429 }
430 }
431 mBuilder.setWhen(conversation.getLatestMessage().getTimeSent());
432 mBuilder.setSmallIcon(R.drawable.ic_notification);
433 mBuilder.setDeleteIntent(createDeleteIntent(conversation));
434 mBuilder.setContentIntent(createContentIntent(conversation));
435 }
436 return mBuilder;
437 }
438
439 private void modifyForImage(final Builder builder, final UnreadConversation.Builder uBuilder,
440 final Message message, final ArrayList<Message> messages) {
441 try {
442 final Bitmap bitmap = mXmppConnectionService.getFileBackend()
443 .getThumbnail(message, getPixel(288), false);
444 final ArrayList<Message> tmp = new ArrayList<>();
445 for (final Message msg : messages) {
446 if (msg.getType() == Message.TYPE_TEXT
447 && msg.getTransferable() == null) {
448 tmp.add(msg);
449 }
450 }
451 final BigPictureStyle bigPictureStyle = new NotificationCompat.BigPictureStyle();
452 bigPictureStyle.bigPicture(bitmap);
453 if (tmp.size() > 0) {
454 CharSequence text = getMergedBodies(tmp);
455 bigPictureStyle.setSummaryText(text);
456 builder.setContentText(text);
457 } else {
458 builder.setContentText(mXmppConnectionService.getString(
459 R.string.received_x_file,
460 UIHelper.getFileDescriptionString(mXmppConnectionService, message)));
461 }
462 builder.setStyle(bigPictureStyle);
463 } catch (final FileNotFoundException e) {
464 modifyForTextOnly(builder, uBuilder, messages);
465 }
466 }
467
468 private void modifyForTextOnly(final Builder builder, final UnreadConversation.Builder uBuilder, final ArrayList<Message> messages) {
469 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.N) {
470 NotificationCompat.MessagingStyle messagingStyle = new NotificationCompat.MessagingStyle(mXmppConnectionService.getString(R.string.me));
471 Conversation conversation = messages.get(0).getConversation();
472 if (conversation.getMode() == Conversation.MODE_MULTI) {
473 messagingStyle.setConversationTitle(conversation.getName());
474 }
475 for (Message message : messages) {
476 String sender = message.getStatus() == Message.STATUS_RECEIVED ? UIHelper.getMessageDisplayName(message) : null;
477 messagingStyle.addMessage(UIHelper.getMessagePreview(mXmppConnectionService,message).first, message.getTimeSent(), sender);
478 }
479 builder.setStyle(messagingStyle);
480 } else {
481 if(messages.get(0).getConversation().getMode() == Conversation.MODE_SINGLE) {
482 builder.setStyle(new NotificationCompat.BigTextStyle().bigText(getMergedBodies(messages)));
483 builder.setContentText(UIHelper.getMessagePreview(mXmppConnectionService, messages.get(0)).first);
484 } else {
485 final NotificationCompat.InboxStyle style = new NotificationCompat.InboxStyle();
486 SpannableString styledString;
487 for (Message message : messages) {
488 final String name = UIHelper.getMessageDisplayName(message);
489 styledString = new SpannableString(name + ": " + message.getBody());
490 styledString.setSpan(new StyleSpan(Typeface.BOLD), 0, name.length(), 0);
491 style.addLine(styledString);
492 }
493 builder.setStyle(style);
494 int count = messages.size();
495 if(count == 1) {
496 final String name = UIHelper.getMessageDisplayName(messages.get(0));
497 styledString = new SpannableString(name + ": " + messages.get(0).getBody());
498 styledString.setSpan(new StyleSpan(Typeface.BOLD), 0, name.length(), 0);
499 builder.setContentText(styledString);
500 } else {
501 builder.setContentText(mXmppConnectionService.getResources().getQuantityString(R.plurals.x_messages,count,count));
502 }
503 }
504 }
505 /** message preview for Android Auto **/
506 for (Message message : messages) {
507 Pair<String,Boolean> preview = UIHelper.getMessagePreview(mXmppConnectionService, message);
508 // only show user written text
509 if (!preview.second) {
510 uBuilder.addMessage(preview.first);
511 uBuilder.setLatestTimestamp(message.getTimeSent());
512 }
513 }
514 }
515
516 private Message getImage(final Iterable<Message> messages) {
517 Message image = null;
518 for (final Message message : messages) {
519 if (message.getStatus() != Message.STATUS_RECEIVED) {
520 return null;
521 }
522 if (message.getType() != Message.TYPE_TEXT
523 && message.getTransferable() == null
524 && message.getEncryption() != Message.ENCRYPTION_PGP
525 && message.getFileParams().height > 0) {
526 image = message;
527 }
528 }
529 return image;
530 }
531
532 private Message getFirstDownloadableMessage(final Iterable<Message> messages) {
533 for (final Message message : messages) {
534 if (message.getTransferable() != null || (message.getType() == Message.TYPE_TEXT && message.treatAsDownloadable())) {
535 return message;
536 }
537 }
538 return null;
539 }
540
541 private Message getFirstLocationMessage(final Iterable<Message> messages) {
542 for (final Message message : messages) {
543 if (message.isGeoUri()) {
544 return message;
545 }
546 }
547 return null;
548 }
549
550 private CharSequence getMergedBodies(final ArrayList<Message> messages) {
551 final StringBuilder text = new StringBuilder();
552 for(Message message : messages) {
553 if (text.length() != 0) {
554 text.append("\n");
555 }
556 text.append(UIHelper.getMessagePreview(mXmppConnectionService, message).first);
557 }
558 return text.toString();
559 }
560
561 private PendingIntent createShowLocationIntent(final Message message) {
562 Iterable<Intent> intents = GeoHelper.createGeoIntentsFromMessage(message);
563 for (Intent intent : intents) {
564 if (intent.resolveActivity(mXmppConnectionService.getPackageManager()) != null) {
565 return PendingIntent.getActivity(mXmppConnectionService, 18, intent, PendingIntent.FLAG_UPDATE_CURRENT);
566 }
567 }
568 return createOpenConversationsIntent();
569 }
570
571 private PendingIntent createContentIntent(final String conversationUuid, final String downloadMessageUuid) {
572 final Intent viewConversationIntent = new Intent(mXmppConnectionService,ConversationActivity.class);
573 viewConversationIntent.setAction(ConversationActivity.ACTION_VIEW_CONVERSATION);
574 viewConversationIntent.putExtra(ConversationActivity.CONVERSATION, conversationUuid);
575 if (downloadMessageUuid != null) {
576 viewConversationIntent.putExtra(ConversationActivity.EXTRA_DOWNLOAD_UUID, downloadMessageUuid);
577 return PendingIntent.getActivity(mXmppConnectionService,
578 (conversationUuid.hashCode() % NOTIFICATION_ID_MULTIPLIER) + 8 * NOTIFICATION_ID_MULTIPLIER,
579 viewConversationIntent,
580 PendingIntent.FLAG_UPDATE_CURRENT);
581 } else {
582 return PendingIntent.getActivity(mXmppConnectionService,
583 (conversationUuid.hashCode() % NOTIFICATION_ID_MULTIPLIER) + 10 * NOTIFICATION_ID_MULTIPLIER,
584 viewConversationIntent,
585 PendingIntent.FLAG_UPDATE_CURRENT);
586 }
587 }
588
589 private PendingIntent createDownloadIntent(final Message message) {
590 return createContentIntent(message.getConversationUuid(), message.getUuid());
591 }
592
593 private PendingIntent createContentIntent(final Conversation conversation) {
594 return createContentIntent(conversation.getUuid(), null);
595 }
596
597 private PendingIntent createDeleteIntent(Conversation conversation) {
598 final Intent intent = new Intent(mXmppConnectionService, XmppConnectionService.class);
599 intent.setAction(XmppConnectionService.ACTION_CLEAR_NOTIFICATION);
600 if (conversation != null) {
601 intent.putExtra("uuid", conversation.getUuid());
602 return PendingIntent.getService(mXmppConnectionService, (conversation.getUuid().hashCode() % NOTIFICATION_ID_MULTIPLIER) + 12 * NOTIFICATION_ID_MULTIPLIER, intent, 0);
603 }
604 return PendingIntent.getService(mXmppConnectionService, 0, intent, 0);
605 }
606
607 private PendingIntent createReplyIntent(Conversation conversation, boolean dismissAfterReply) {
608 final Intent intent = new Intent(mXmppConnectionService, XmppConnectionService.class);
609 intent.setAction(XmppConnectionService.ACTION_REPLY_TO_CONVERSATION);
610 intent.putExtra("uuid",conversation.getUuid());
611 intent.putExtra("dismiss_notification",dismissAfterReply);
612 int id = (conversation.getUuid().hashCode() % NOTIFICATION_ID_MULTIPLIER) + (dismissAfterReply ? 12 : 14) * NOTIFICATION_ID_MULTIPLIER;
613 return PendingIntent.getService(mXmppConnectionService, id, intent, 0);
614 }
615
616 private PendingIntent createReadPendingIntent(Conversation conversation) {
617 final Intent intent = new Intent(mXmppConnectionService, XmppConnectionService.class);
618 intent.setAction(XmppConnectionService.ACTION_MARK_AS_READ);
619 intent.putExtra("uuid", conversation.getUuid());
620 intent.setPackage(mXmppConnectionService.getPackageName());
621 return PendingIntent.getService(mXmppConnectionService, (conversation.getUuid().hashCode() % NOTIFICATION_ID_MULTIPLIER) + 16 * NOTIFICATION_ID_MULTIPLIER, intent, PendingIntent.FLAG_UPDATE_CURRENT);
622 }
623
624 private PendingIntent createTryAgainIntent() {
625 final Intent intent = new Intent(mXmppConnectionService, XmppConnectionService.class);
626 intent.setAction(XmppConnectionService.ACTION_TRY_AGAIN);
627 return PendingIntent.getService(mXmppConnectionService, 45, intent, 0);
628 }
629
630 private PendingIntent createDismissErrorIntent() {
631 final Intent intent = new Intent(mXmppConnectionService, XmppConnectionService.class);
632 intent.setAction(XmppConnectionService.ACTION_DISMISS_ERROR_NOTIFICATIONS);
633 return PendingIntent.getService(mXmppConnectionService, 69, intent, 0);
634 }
635
636 private boolean wasHighlightedOrPrivate(final Message message) {
637 final String nick = message.getConversation().getMucOptions().getActualNick();
638 final Pattern highlight = generateNickHighlightPattern(nick);
639 if (message.getBody() == null || nick == null) {
640 return false;
641 }
642 final Matcher m = highlight.matcher(message.getBody());
643 return (m.find() || message.getType() == Message.TYPE_PRIVATE);
644 }
645
646 public static Pattern generateNickHighlightPattern(final String nick) {
647 // We expect a word boundary, i.e. space or start of string, followed by
648 // the
649 // nick (matched in case-insensitive manner), followed by optional
650 // punctuation (for example "bob: i disagree" or "how are you alice?"),
651 // followed by another word boundary.
652 return Pattern.compile("\\b" + Pattern.quote(nick) + "\\p{Punct}?\\b",
653 Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
654 }
655
656 public void setOpenConversation(final Conversation conversation) {
657 this.mOpenConversation = conversation;
658 }
659
660 public void setIsInForeground(final boolean foreground) {
661 this.mIsInForeground = foreground;
662 }
663
664 private int getPixel(final int dp) {
665 final DisplayMetrics metrics = mXmppConnectionService.getResources()
666 .getDisplayMetrics();
667 return ((int) (dp * metrics.density));
668 }
669
670 private void markLastNotification() {
671 this.mLastNotification = SystemClock.elapsedRealtime();
672 }
673
674 private boolean inMiniGracePeriod(final Account account) {
675 final int miniGrace = account.getStatus() == Account.State.ONLINE ? Config.MINI_GRACE_PERIOD
676 : Config.MINI_GRACE_PERIOD * 2;
677 return SystemClock.elapsedRealtime() < (this.mLastNotification + miniGrace);
678 }
679
680 public Notification createForegroundNotification() {
681 final NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(mXmppConnectionService);
682
683 mBuilder.setContentTitle(mXmppConnectionService.getString(R.string.conversations_foreground_service));
684 if (Config.SHOW_CONNECTED_ACCOUNTS) {
685 List<Account> accounts = mXmppConnectionService.getAccounts();
686 int enabled = 0;
687 int connected = 0;
688 for (Account account : accounts) {
689 if (account.isOnlineAndConnected()) {
690 connected++;
691 enabled++;
692 } else if (account.isEnabled()) {
693 enabled++;
694 }
695 }
696 mBuilder.setContentText(mXmppConnectionService.getString(R.string.connected_accounts, connected, enabled));
697 } else {
698 mBuilder.setContentText(mXmppConnectionService.getString(R.string.touch_to_open_conversations));
699 }
700 mBuilder.setContentIntent(createOpenConversationsIntent());
701 mBuilder.setWhen(0);
702 mBuilder.setPriority(Config.SHOW_CONNECTED_ACCOUNTS ? NotificationCompat.PRIORITY_DEFAULT : NotificationCompat.PRIORITY_MIN);
703 mBuilder.setSmallIcon(R.drawable.ic_link_white_24dp);
704 return mBuilder.build();
705 }
706
707 private PendingIntent createOpenConversationsIntent() {
708 return PendingIntent.getActivity(mXmppConnectionService, 0, new Intent(mXmppConnectionService, ConversationActivity.class), 0);
709 }
710
711 public void updateErrorNotification() {
712 final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(mXmppConnectionService);
713 final List<Account> errors = new ArrayList<>();
714 for (final Account account : mXmppConnectionService.getAccounts()) {
715 if (account.hasErrorStatus() && account.showErrorNotification()) {
716 errors.add(account);
717 }
718 }
719 if (mXmppConnectionService.keepForegroundService()) {
720 notificationManager.notify(FOREGROUND_NOTIFICATION_ID, createForegroundNotification());
721 }
722 final NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(mXmppConnectionService);
723 if (errors.size() == 0) {
724 notificationManager.cancel(ERROR_NOTIFICATION_ID);
725 return;
726 } else if (errors.size() == 1) {
727 mBuilder.setContentTitle(mXmppConnectionService.getString(R.string.problem_connecting_to_account));
728 mBuilder.setContentText(errors.get(0).getJid().toBareJid().toString());
729 } else {
730 mBuilder.setContentTitle(mXmppConnectionService.getString(R.string.problem_connecting_to_accounts));
731 mBuilder.setContentText(mXmppConnectionService.getString(R.string.touch_to_fix));
732 }
733 mBuilder.addAction(R.drawable.ic_autorenew_white_24dp,
734 mXmppConnectionService.getString(R.string.try_again),
735 createTryAgainIntent());
736 mBuilder.setDeleteIntent(createDismissErrorIntent());
737 mBuilder.setVisibility(NotificationCompat.VISIBILITY_PUBLIC);
738 if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP) {
739 mBuilder.setSmallIcon(R.drawable.ic_warning_white_24dp);
740 } else {
741 mBuilder.setSmallIcon(R.drawable.ic_stat_alert_warning);
742 }
743 mBuilder.setPriority(NotificationCompat.PRIORITY_LOW);
744 mBuilder.setContentIntent(PendingIntent.getActivity(mXmppConnectionService,
745 145,
746 new Intent(mXmppConnectionService,ManageAccountActivity.class),
747 PendingIntent.FLAG_UPDATE_CURRENT));
748 notificationManager.notify(ERROR_NOTIFICATION_ID, mBuilder.build());
749 }
750
751 public Notification updateFileAddingNotification(int current, Message message) {
752 final NotificationManagerCompat notificationManager = NotificationManagerCompat.from(mXmppConnectionService);
753 NotificationCompat.Builder mBuilder = new NotificationCompat.Builder(mXmppConnectionService);
754 mBuilder.setContentTitle(mXmppConnectionService.getString(R.string.transcoding_video));
755 mBuilder.setProgress(100, current, false);
756 mBuilder.setSmallIcon(R.drawable.ic_hourglass_empty_white_24dp);
757 mBuilder.setContentIntent(createContentIntent(message.getConversation()));
758 Notification notification = mBuilder.build();
759 notificationManager.notify(FOREGROUND_NOTIFICATION_ID, notification);
760 return notification;
761 }
762}