1package eu.siacs.conversations.ui;
2
3import android.app.Activity;
4import android.app.AlertDialog;
5import android.app.Fragment;
6import android.app.PendingIntent;
7import android.content.ActivityNotFoundException;
8import android.content.Context;
9import android.content.DialogInterface;
10import android.content.Intent;
11import android.content.IntentSender.SendIntentException;
12import android.os.Bundle;
13import android.os.Handler;
14import android.os.SystemClock;
15import android.support.v13.view.inputmethod.InputConnectionCompat;
16import android.support.v13.view.inputmethod.InputContentInfoCompat;
17import android.text.Editable;
18import android.text.InputType;
19import android.util.Log;
20import android.util.Pair;
21import android.view.ContextMenu;
22import android.view.ContextMenu.ContextMenuInfo;
23import android.view.Gravity;
24import android.view.KeyEvent;
25import android.view.LayoutInflater;
26import android.view.MenuItem;
27import android.view.MotionEvent;
28import android.view.View;
29import android.view.View.OnClickListener;
30import android.view.ViewGroup;
31import android.view.inputmethod.EditorInfo;
32import android.view.inputmethod.InputMethodManager;
33import android.widget.AbsListView;
34import android.widget.AbsListView.OnScrollListener;
35import android.widget.AdapterView;
36import android.widget.AdapterView.AdapterContextMenuInfo;
37import android.widget.ImageButton;
38import android.widget.ListView;
39import android.widget.PopupMenu;
40import android.widget.RelativeLayout;
41import android.widget.TextView;
42import android.widget.TextView.OnEditorActionListener;
43import android.widget.Toast;
44
45import net.java.otr4j.session.SessionStatus;
46
47import java.util.ArrayList;
48import java.util.Arrays;
49import java.util.Collections;
50import java.util.HashSet;
51import java.util.List;
52import java.util.Set;
53import java.util.UUID;
54import java.util.concurrent.atomic.AtomicBoolean;
55
56import eu.siacs.conversations.Config;
57import eu.siacs.conversations.R;
58import eu.siacs.conversations.entities.Account;
59import eu.siacs.conversations.entities.Blockable;
60import eu.siacs.conversations.entities.Contact;
61import eu.siacs.conversations.entities.Conversation;
62import eu.siacs.conversations.entities.DownloadableFile;
63import eu.siacs.conversations.entities.Message;
64import eu.siacs.conversations.entities.MucOptions;
65import eu.siacs.conversations.entities.Presence;
66import eu.siacs.conversations.entities.ReadByMarker;
67import eu.siacs.conversations.entities.Transferable;
68import eu.siacs.conversations.entities.TransferablePlaceholder;
69import eu.siacs.conversations.http.HttpDownloadConnection;
70import eu.siacs.conversations.persistance.FileBackend;
71import eu.siacs.conversations.services.MessageArchiveService;
72import eu.siacs.conversations.services.XmppConnectionService;
73import eu.siacs.conversations.ui.XmppActivity.OnPresenceSelected;
74import eu.siacs.conversations.ui.XmppActivity.OnValueEdited;
75import eu.siacs.conversations.ui.adapter.MessageAdapter;
76import eu.siacs.conversations.ui.adapter.MessageAdapter.OnContactPictureClicked;
77import eu.siacs.conversations.ui.adapter.MessageAdapter.OnContactPictureLongClicked;
78import eu.siacs.conversations.ui.widget.EditMessage;
79import eu.siacs.conversations.utils.MessageUtils;
80import eu.siacs.conversations.utils.NickValidityChecker;
81import eu.siacs.conversations.utils.StylingHelper;
82import eu.siacs.conversations.utils.UIHelper;
83import eu.siacs.conversations.xmpp.XmppConnection;
84import eu.siacs.conversations.xmpp.chatstate.ChatState;
85import eu.siacs.conversations.xmpp.jid.Jid;
86
87public class ConversationFragment extends Fragment implements EditMessage.KeyboardListener {
88
89 final protected List<Message> messageList = new ArrayList<>();
90 protected Conversation conversation;
91 protected ListView messagesView;
92 protected MessageAdapter messageListAdapter;
93 private EditMessage mEditMessage;
94 private ImageButton mSendButton;
95 private RelativeLayout snackbar;
96 private TextView snackbarMessage;
97 private TextView snackbarAction;
98 private Toast messageLoaderToast;
99 private OnClickListener clickToMuc = new OnClickListener() {
100
101 @Override
102 public void onClick(View v) {
103 Intent intent = new Intent(getActivity(), ConferenceDetailsActivity.class);
104 intent.setAction(ConferenceDetailsActivity.ACTION_VIEW_MUC);
105 intent.putExtra("uuid", conversation.getUuid());
106 startActivity(intent);
107 }
108 };
109 private ConversationActivity activity;
110 private OnClickListener leaveMuc = new OnClickListener() {
111
112 @Override
113 public void onClick(View v) {
114 activity.endConversation(conversation);
115 }
116 };
117 private OnClickListener joinMuc = new OnClickListener() {
118
119 @Override
120 public void onClick(View v) {
121 activity.xmppConnectionService.joinMuc(conversation);
122 }
123 };
124 private OnClickListener enterPassword = new OnClickListener() {
125
126 @Override
127 public void onClick(View v) {
128 MucOptions muc = conversation.getMucOptions();
129 String password = muc.getPassword();
130 if (password == null) {
131 password = "";
132 }
133 activity.quickPasswordEdit(password, new OnValueEdited() {
134
135 @Override
136 public void onValueEdited(String value) {
137 activity.xmppConnectionService.providePasswordForMuc(
138 conversation, value);
139 }
140 });
141 }
142 };
143 private OnScrollListener mOnScrollListener = new OnScrollListener() {
144
145 @Override
146 public void onScrollStateChanged(AbsListView view, int scrollState) {
147 // TODO Auto-generated method stub
148
149 }
150
151 @Override
152 public void onScroll(final AbsListView view, int firstVisibleItem, int visibleItemCount, int totalItemCount) {
153 synchronized (ConversationFragment.this.messageList) {
154 if (firstVisibleItem < 5 && conversation != null && conversation.messagesLoaded.compareAndSet(true, false) && messageList.size() > 0) {
155 long timestamp;
156 if (messageList.get(0).getType() == Message.TYPE_STATUS && messageList.size() >= 2) {
157 timestamp = messageList.get(1).getTimeSent();
158 } else {
159 timestamp = messageList.get(0).getTimeSent();
160 }
161 activity.xmppConnectionService.loadMoreMessages(conversation, timestamp, new XmppConnectionService.OnMoreMessagesLoaded() {
162 @Override
163 public void onMoreMessagesLoaded(final int c, final Conversation conversation) {
164 if (ConversationFragment.this.conversation != conversation) {
165 conversation.messagesLoaded.set(true);
166 return;
167 }
168 activity.runOnUiThread(new Runnable() {
169 @Override
170 public void run() {
171 final int oldPosition = messagesView.getFirstVisiblePosition();
172 Message message = null;
173 int childPos;
174 for (childPos = 0; childPos + oldPosition < messageList.size(); ++childPos) {
175 message = messageList.get(oldPosition + childPos);
176 if (message.getType() != Message.TYPE_STATUS) {
177 break;
178 }
179 }
180 final String uuid = message != null ? message.getUuid() : null;
181 View v = messagesView.getChildAt(childPos);
182 final int pxOffset = (v == null) ? 0 : v.getTop();
183 ConversationFragment.this.conversation.populateWithMessages(ConversationFragment.this.messageList);
184 try {
185 updateStatusMessages();
186 } catch (IllegalStateException e) {
187 Log.d(Config.LOGTAG, "caught illegal state exception while updating status messages");
188 }
189 messageListAdapter.notifyDataSetChanged();
190 int pos = Math.max(getIndexOf(uuid, messageList), 0);
191 messagesView.setSelectionFromTop(pos, pxOffset);
192 if (messageLoaderToast != null) {
193 messageLoaderToast.cancel();
194 }
195 conversation.messagesLoaded.set(true);
196 }
197 });
198 }
199
200 @Override
201 public void informUser(final int resId) {
202
203 activity.runOnUiThread(new Runnable() {
204 @Override
205 public void run() {
206 if (messageLoaderToast != null) {
207 messageLoaderToast.cancel();
208 }
209 if (ConversationFragment.this.conversation != conversation) {
210 return;
211 }
212 messageLoaderToast = Toast.makeText(view.getContext(), resId, Toast.LENGTH_LONG);
213 messageLoaderToast.show();
214 }
215 });
216
217 }
218 });
219
220 }
221 }
222 }
223 };
224 protected OnClickListener clickToVerify = new OnClickListener() {
225
226 @Override
227 public void onClick(View v) {
228 activity.verifyOtrSessionDialog(conversation, v);
229 }
230 };
231 private EditMessage.OnCommitContentListener mEditorContentListener = new EditMessage.OnCommitContentListener() {
232 @Override
233 public boolean onCommitContent(InputContentInfoCompat inputContentInfo, int flags, Bundle opts, String[] contentMimeTypes) {
234 // try to get permission to read the image, if applicable
235 if ((flags & InputConnectionCompat.INPUT_CONTENT_GRANT_READ_URI_PERMISSION) != 0) {
236 try {
237 inputContentInfo.requestPermission();
238 } catch (Exception e) {
239 Log.e(Config.LOGTAG, "InputContentInfoCompat#requestPermission() failed.", e);
240 Toast.makeText(
241 activity,
242 activity.getString(R.string.no_permission_to_access_x, inputContentInfo.getDescription()),
243 Toast.LENGTH_LONG
244 ).show();
245 return false;
246 }
247 }
248 if (activity.hasStoragePermission(ConversationActivity.REQUEST_ADD_EDITOR_CONTENT)) {
249 activity.attachImageToConversation(inputContentInfo.getContentUri());
250 } else {
251 activity.mPendingEditorContent = inputContentInfo.getContentUri();
252 }
253 return true;
254 }
255 };
256 private Message selectedMessage;
257 private OnClickListener mEnableAccountListener = new OnClickListener() {
258 @Override
259 public void onClick(View v) {
260 final Account account = conversation == null ? null : conversation.getAccount();
261 if (account != null) {
262 account.setOption(Account.OPTION_DISABLED, false);
263 activity.xmppConnectionService.updateAccount(account);
264 }
265 }
266 };
267 private OnClickListener mUnblockClickListener = new OnClickListener() {
268 @Override
269 public void onClick(final View v) {
270 v.post(new Runnable() {
271 @Override
272 public void run() {
273 v.setVisibility(View.INVISIBLE);
274 }
275 });
276 if (conversation.isDomainBlocked()) {
277 BlockContactDialog.show(activity, conversation);
278 } else {
279 activity.unblockConversation(conversation);
280 }
281 }
282 };
283 private OnClickListener mBlockClickListener = new OnClickListener() {
284 @Override
285 public void onClick(final View view) {
286 showBlockSubmenu(view);
287 }
288 };
289 private OnClickListener mAddBackClickListener = new OnClickListener() {
290
291 @Override
292 public void onClick(View v) {
293 final Contact contact = conversation == null ? null : conversation.getContact();
294 if (contact != null) {
295 activity.xmppConnectionService.createContact(contact);
296 activity.switchToContactDetails(contact);
297 }
298 }
299 };
300 private View.OnLongClickListener mLongPressBlockListener = new View.OnLongClickListener() {
301 @Override
302 public boolean onLongClick(View v) {
303 showBlockSubmenu(v);
304 return true;
305 }
306 };
307 private OnClickListener mAllowPresenceSubscription = new OnClickListener() {
308 @Override
309 public void onClick(View v) {
310 final Contact contact = conversation == null ? null : conversation.getContact();
311 if (contact != null) {
312 activity.xmppConnectionService.sendPresencePacket(contact.getAccount(),
313 activity.xmppConnectionService.getPresenceGenerator()
314 .sendPresenceUpdatesTo(contact));
315 hideSnackbar();
316 }
317 }
318 };
319 private OnClickListener mAnswerSmpClickListener = new OnClickListener() {
320 @Override
321 public void onClick(View view) {
322 Intent intent = new Intent(activity, VerifyOTRActivity.class);
323 intent.setAction(VerifyOTRActivity.ACTION_VERIFY_CONTACT);
324 intent.putExtra("contact", conversation.getContact().getJid().toBareJid().toString());
325 intent.putExtra(VerifyOTRActivity.EXTRA_ACCOUNT, conversation.getAccount().getJid().toBareJid().toString());
326 intent.putExtra("mode", VerifyOTRActivity.MODE_ANSWER_QUESTION);
327 startActivity(intent);
328 }
329 };
330 protected OnClickListener clickToDecryptListener = new OnClickListener() {
331
332 @Override
333 public void onClick(View v) {
334 PendingIntent pendingIntent = conversation.getAccount().getPgpDecryptionService().getPendingIntent();
335 if (pendingIntent != null) {
336 try {
337 activity.startIntentSenderForResult(pendingIntent.getIntentSender(),
338 ConversationActivity.REQUEST_DECRYPT_PGP,
339 null,
340 0,
341 0,
342 0);
343 } catch (SendIntentException e) {
344 Toast.makeText(activity, R.string.unable_to_connect_to_keychain, Toast.LENGTH_SHORT).show();
345 conversation.getAccount().getPgpDecryptionService().continueDecryption(true);
346 }
347 }
348 updateSnackBar(conversation);
349 }
350 };
351 private AtomicBoolean mSendingPgpMessage = new AtomicBoolean(false);
352 private OnEditorActionListener mEditorActionListener = new OnEditorActionListener() {
353
354 @Override
355 public boolean onEditorAction(TextView v, int actionId, KeyEvent event) {
356 if (actionId == EditorInfo.IME_ACTION_SEND) {
357 InputMethodManager imm = (InputMethodManager) v.getContext()
358 .getSystemService(Context.INPUT_METHOD_SERVICE);
359 if (imm.isFullscreenMode()) {
360 imm.hideSoftInputFromWindow(v.getWindowToken(), 0);
361 }
362 sendMessage();
363 return true;
364 } else {
365 return false;
366 }
367 }
368 };
369 private OnClickListener mSendButtonListener = new OnClickListener() {
370
371 @Override
372 public void onClick(View v) {
373 Object tag = v.getTag();
374 if (tag instanceof SendButtonAction) {
375 SendButtonAction action = (SendButtonAction) tag;
376 switch (action) {
377 case TAKE_PHOTO:
378 activity.attachFile(ConversationActivity.ATTACHMENT_CHOICE_TAKE_PHOTO);
379 break;
380 case RECORD_VIDEO:
381 activity.attachFile(ConversationActivity.ATTACHMENT_CHOICE_RECORD_VIDEO);
382 break;
383 case SEND_LOCATION:
384 activity.attachFile(ConversationActivity.ATTACHMENT_CHOICE_LOCATION);
385 break;
386 case RECORD_VOICE:
387 activity.attachFile(ConversationActivity.ATTACHMENT_CHOICE_RECORD_VOICE);
388 break;
389 case CHOOSE_PICTURE:
390 activity.attachFile(ConversationActivity.ATTACHMENT_CHOICE_CHOOSE_IMAGE);
391 break;
392 case CANCEL:
393 if (conversation != null) {
394 if (conversation.setCorrectingMessage(null)) {
395 mEditMessage.setText("");
396 mEditMessage.append(conversation.getDraftMessage());
397 conversation.setDraftMessage(null);
398 } else if (conversation.getMode() == Conversation.MODE_MULTI) {
399 conversation.setNextCounterpart(null);
400 }
401 updateChatMsgHint();
402 updateSendButton();
403 updateEditablity();
404 }
405 break;
406 default:
407 sendMessage();
408 }
409 } else {
410 sendMessage();
411 }
412 }
413 };
414 private int completionIndex = 0;
415 private int lastCompletionLength = 0;
416 private String incomplete;
417 private int lastCompletionCursor;
418 private boolean firstWord = false;
419
420 private int getIndexOf(String uuid, List<Message> messages) {
421 if (uuid == null) {
422 return messages.size() - 1;
423 }
424 for (int i = 0; i < messages.size(); ++i) {
425 if (uuid.equals(messages.get(i).getUuid())) {
426 return i;
427 } else {
428 Message next = messages.get(i);
429 while (next != null && next.wasMergedIntoPrevious()) {
430 if (uuid.equals(next.getUuid())) {
431 return i;
432 }
433 next = next.next();
434 }
435
436 }
437 }
438 return -1;
439 }
440
441 public Pair<Integer, Integer> getScrollPosition() {
442 if (this.messagesView.getCount() == 0 ||
443 this.messagesView.getLastVisiblePosition() == this.messagesView.getCount() - 1) {
444 return null;
445 } else {
446 final int pos = messagesView.getFirstVisiblePosition();
447 final View view = messagesView.getChildAt(0);
448 if (view == null) {
449 return null;
450 } else {
451 return new Pair<>(pos, view.getTop());
452 }
453 }
454 }
455
456 public void setScrollPosition(Pair<Integer, Integer> scrollPosition) {
457 if (scrollPosition != null) {
458 this.messagesView.setSelectionFromTop(scrollPosition.first, scrollPosition.second);
459 }
460 }
461
462 private void sendMessage() {
463 final String body = mEditMessage.getText().toString();
464 final Conversation conversation = this.conversation;
465 if (body.length() == 0 || conversation == null) {
466 return;
467 }
468 final Message message;
469 if (conversation.getCorrectingMessage() == null) {
470 message = new Message(conversation, body, conversation.getNextEncryption());
471 if (conversation.getMode() == Conversation.MODE_MULTI) {
472 if (conversation.getNextCounterpart() != null) {
473 message.setCounterpart(conversation.getNextCounterpart());
474 message.setType(Message.TYPE_PRIVATE);
475 }
476 }
477 } else {
478 message = conversation.getCorrectingMessage();
479 message.setBody(body);
480 message.setEdited(message.getUuid());
481 message.setUuid(UUID.randomUUID().toString());
482 }
483 switch (message.getConversation().getNextEncryption()) {
484 case Message.ENCRYPTION_OTR:
485 sendOtrMessage(message);
486 break;
487 case Message.ENCRYPTION_PGP:
488 sendPgpMessage(message);
489 break;
490 case Message.ENCRYPTION_AXOLOTL:
491 if (!activity.trustKeysIfNeeded(ConversationActivity.REQUEST_TRUST_KEYS_TEXT)) {
492 sendAxolotlMessage(message);
493 }
494 break;
495 default:
496 sendPlainTextMessage(message);
497 }
498 }
499
500 public void updateChatMsgHint() {
501 final boolean multi = conversation.getMode() == Conversation.MODE_MULTI;
502 if (conversation.getCorrectingMessage() != null) {
503 this.mEditMessage.setHint(R.string.send_corrected_message);
504 } else if (multi && conversation.getNextCounterpart() != null) {
505 this.mEditMessage.setHint(getString(
506 R.string.send_private_message_to,
507 conversation.getNextCounterpart().getResourcepart()));
508 } else if (multi && !conversation.getMucOptions().participating()) {
509 this.mEditMessage.setHint(R.string.you_are_not_participating);
510 } else {
511 this.mEditMessage.setHint(UIHelper.getMessageHint(activity, conversation));
512 getActivity().invalidateOptionsMenu();
513 }
514 }
515
516 public void setupIme() {
517 if (activity != null) {
518 if (activity.usingEnterKey() && activity.enterIsSend()) {
519 mEditMessage.setInputType(mEditMessage.getInputType() & (~InputType.TYPE_TEXT_FLAG_MULTI_LINE));
520 mEditMessage.setInputType(mEditMessage.getInputType() & (~InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE));
521 } else if (activity.usingEnterKey()) {
522 mEditMessage.setInputType(mEditMessage.getInputType() | InputType.TYPE_TEXT_FLAG_MULTI_LINE);
523 mEditMessage.setInputType(mEditMessage.getInputType() & (~InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE));
524 } else {
525 mEditMessage.setInputType(mEditMessage.getInputType() | InputType.TYPE_TEXT_FLAG_MULTI_LINE);
526 mEditMessage.setInputType(mEditMessage.getInputType() | InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE);
527 }
528 }
529 }
530
531 @Override
532 public View onCreateView(final LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
533 final View view = inflater.inflate(R.layout.fragment_conversation, container, false);
534 view.setOnClickListener(null);
535
536 mEditMessage = (EditMessage) view.findViewById(R.id.textinput);
537 mEditMessage.setOnClickListener(new OnClickListener() {
538
539 @Override
540 public void onClick(View v) {
541 if (activity != null) {
542 activity.hideConversationsOverview();
543 }
544 }
545 });
546
547 mEditMessage.addTextChangedListener(new StylingHelper.MessageEditorStyler(mEditMessage));
548
549 mEditMessage.setOnEditorActionListener(mEditorActionListener);
550 mEditMessage.setRichContentListener(new String[]{"image/*"}, mEditorContentListener);
551
552 mSendButton = (ImageButton) view.findViewById(R.id.textSendButton);
553 mSendButton.setOnClickListener(this.mSendButtonListener);
554
555 snackbar = (RelativeLayout) view.findViewById(R.id.snackbar);
556 snackbarMessage = (TextView) view.findViewById(R.id.snackbar_message);
557 snackbarAction = (TextView) view.findViewById(R.id.snackbar_action);
558
559 messagesView = (ListView) view.findViewById(R.id.messages_view);
560 messagesView.setOnScrollListener(mOnScrollListener);
561 messagesView.setTranscriptMode(ListView.TRANSCRIPT_MODE_NORMAL);
562 messageListAdapter = new MessageAdapter((ConversationActivity) getActivity(), this.messageList);
563 messageListAdapter.setOnContactPictureClicked(new OnContactPictureClicked() {
564
565 @Override
566 public void onContactPictureClicked(Message message) {
567 if (message.getStatus() <= Message.STATUS_RECEIVED) {
568 if (message.getConversation().getMode() == Conversation.MODE_MULTI) {
569 Jid user = message.getCounterpart();
570 if (user != null && !user.isBareJid()) {
571 if (!message.getConversation().getMucOptions().isUserInRoom(user)) {
572 Toast.makeText(activity, activity.getString(R.string.user_has_left_conference, user.getResourcepart()), Toast.LENGTH_SHORT).show();
573 }
574 highlightInConference(user.getResourcepart());
575 }
576 } else {
577 if (!message.getContact().isSelf()) {
578 String fingerprint;
579 if (message.getEncryption() == Message.ENCRYPTION_PGP
580 || message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
581 fingerprint = "pgp";
582 } else {
583 fingerprint = message.getFingerprint();
584 }
585 activity.switchToContactDetails(message.getContact(), fingerprint);
586 }
587 }
588 } else {
589 Account account = message.getConversation().getAccount();
590 Intent intent;
591 if (activity.manuallyChangePresence()) {
592 intent = new Intent(activity, SetPresenceActivity.class);
593 intent.putExtra(SetPresenceActivity.EXTRA_ACCOUNT, account.getJid().toBareJid().toString());
594 } else {
595 intent = new Intent(activity, EditAccountActivity.class);
596 intent.putExtra("jid", account.getJid().toBareJid().toString());
597 String fingerprint;
598 if (message.getEncryption() == Message.ENCRYPTION_PGP
599 || message.getEncryption() == Message.ENCRYPTION_DECRYPTED) {
600 fingerprint = "pgp";
601 } else if (message.getEncryption() == Message.ENCRYPTION_OTR) {
602 fingerprint = "otr";
603 } else {
604 fingerprint = message.getFingerprint();
605 }
606 intent.putExtra("fingerprint", fingerprint);
607 }
608 startActivity(intent);
609 }
610 }
611 });
612 messageListAdapter
613 .setOnContactPictureLongClicked(new OnContactPictureLongClicked() {
614
615 @Override
616 public void onContactPictureLongClicked(Message message) {
617 if (message.getStatus() <= Message.STATUS_RECEIVED) {
618 if (message.getConversation().getMode() == Conversation.MODE_MULTI) {
619 Jid user = message.getCounterpart();
620 if (user != null && !user.isBareJid()) {
621 if (message.getConversation().getMucOptions().isUserInRoom(user)) {
622 privateMessageWith(user);
623 } else {
624 Toast.makeText(activity, activity.getString(R.string.user_has_left_conference, user.getResourcepart()), Toast.LENGTH_SHORT).show();
625 }
626 }
627 }
628 } else {
629 activity.showQrCode();
630 }
631 }
632 });
633 messageListAdapter.setOnQuoteListener(new MessageAdapter.OnQuoteListener() {
634
635 @Override
636 public void onQuote(String text) {
637 quoteText(text);
638 }
639 });
640 messagesView.setAdapter(messageListAdapter);
641
642 registerForContextMenu(messagesView);
643
644 return view;
645 }
646
647 private void quoteText(String text) {
648 if (mEditMessage.isEnabled()) {
649 text = text.replaceAll("(\n *){2,}", "\n").replaceAll("(^|\n)", "$1> ").replaceAll("\n$", "");
650 Editable editable = mEditMessage.getEditableText();
651 int position = mEditMessage.getSelectionEnd();
652 if (position == -1) position = editable.length();
653 if (position > 0 && editable.charAt(position - 1) != '\n') {
654 editable.insert(position++, "\n");
655 }
656 editable.insert(position, text);
657 position += text.length();
658 editable.insert(position++, "\n");
659 if (position < editable.length() && editable.charAt(position) != '\n') {
660 editable.insert(position, "\n");
661 }
662 mEditMessage.setSelection(position);
663 mEditMessage.requestFocus();
664 InputMethodManager inputMethodManager = (InputMethodManager) getActivity()
665 .getSystemService(Context.INPUT_METHOD_SERVICE);
666 if (inputMethodManager != null) {
667 inputMethodManager.showSoftInput(mEditMessage, InputMethodManager.SHOW_IMPLICIT);
668 }
669 }
670 }
671
672 private void quoteMessage(Message message) {
673 quoteText(MessageUtils.prepareQuote(message));
674 }
675
676 @Override
677 public void onCreateContextMenu(ContextMenu menu, View v, ContextMenuInfo menuInfo) {
678 synchronized (this.messageList) {
679 super.onCreateContextMenu(menu, v, menuInfo);
680 AdapterView.AdapterContextMenuInfo acmi = (AdapterContextMenuInfo) menuInfo;
681 this.selectedMessage = this.messageList.get(acmi.position);
682 populateContextMenu(menu);
683 }
684 }
685
686 private void populateContextMenu(ContextMenu menu) {
687 final Message m = this.selectedMessage;
688 final Transferable t = m.getTransferable();
689 Message relevantForCorrection = m;
690 while (relevantForCorrection.mergeable(relevantForCorrection.next())) {
691 relevantForCorrection = relevantForCorrection.next();
692 }
693 if (m.getType() != Message.TYPE_STATUS) {
694 final boolean treatAsFile = m.getType() != Message.TYPE_TEXT
695 && m.getType() != Message.TYPE_PRIVATE
696 && t == null;
697 final boolean encrypted = m.getEncryption() == Message.ENCRYPTION_DECRYPTION_FAILED
698 || m.getEncryption() == Message.ENCRYPTION_PGP;
699 activity.getMenuInflater().inflate(R.menu.message_context, menu);
700 menu.setHeaderTitle(R.string.message_options);
701 MenuItem copyMessage = menu.findItem(R.id.copy_message);
702 MenuItem quoteMessage = menu.findItem(R.id.quote_message);
703 MenuItem retryDecryption = menu.findItem(R.id.retry_decryption);
704 MenuItem correctMessage = menu.findItem(R.id.correct_message);
705 MenuItem shareWith = menu.findItem(R.id.share_with);
706 MenuItem sendAgain = menu.findItem(R.id.send_again);
707 MenuItem copyUrl = menu.findItem(R.id.copy_url);
708 MenuItem downloadFile = menu.findItem(R.id.download_file);
709 MenuItem cancelTransmission = menu.findItem(R.id.cancel_transmission);
710 MenuItem deleteFile = menu.findItem(R.id.delete_file);
711 MenuItem showErrorMessage = menu.findItem(R.id.show_error_message);
712 if (!treatAsFile && !encrypted && !m.isGeoUri() && !m.treatAsDownloadable()) {
713 copyMessage.setVisible(true);
714 quoteMessage.setVisible(MessageUtils.prepareQuote(m).length() > 0);
715 }
716 if (m.getEncryption() == Message.ENCRYPTION_DECRYPTION_FAILED) {
717 retryDecryption.setVisible(true);
718 }
719 if (relevantForCorrection.getType() == Message.TYPE_TEXT
720 && relevantForCorrection.isLastCorrectableMessage()
721 && (m.getConversation().getMucOptions().nonanonymous() || m.getConversation().getMode() == Conversation.MODE_SINGLE)) {
722 correctMessage.setVisible(true);
723 }
724 if (treatAsFile || (m.getType() == Message.TYPE_TEXT && !m.treatAsDownloadable())) {
725 shareWith.setVisible(true);
726 }
727 if (m.getStatus() == Message.STATUS_SEND_FAILED) {
728 sendAgain.setVisible(true);
729 }
730 if (m.hasFileOnRemoteHost()
731 || m.isGeoUri()
732 || m.treatAsDownloadable()
733 || (t != null && t instanceof HttpDownloadConnection)) {
734 copyUrl.setVisible(true);
735 }
736 if ((m.isFileOrImage() && t instanceof TransferablePlaceholder && m.hasFileOnRemoteHost())) {
737 downloadFile.setVisible(true);
738 downloadFile.setTitle(activity.getString(R.string.download_x_file, UIHelper.getFileDescriptionString(activity, m)));
739 }
740 boolean waitingOfferedSending = m.getStatus() == Message.STATUS_WAITING
741 || m.getStatus() == Message.STATUS_UNSEND
742 || m.getStatus() == Message.STATUS_OFFERED;
743 if ((t != null && !(t instanceof TransferablePlaceholder)) || waitingOfferedSending && m.needsUploading()) {
744 cancelTransmission.setVisible(true);
745 }
746 if (treatAsFile) {
747 String path = m.getRelativeFilePath();
748 if (path == null || !path.startsWith("/")) {
749 deleteFile.setVisible(true);
750 deleteFile.setTitle(activity.getString(R.string.delete_x_file, UIHelper.getFileDescriptionString(activity, m)));
751 }
752 }
753 if (m.getStatus() == Message.STATUS_SEND_FAILED && m.getErrorMessage() != null) {
754 showErrorMessage.setVisible(true);
755 }
756 }
757 }
758
759 @Override
760 public boolean onContextItemSelected(MenuItem item) {
761 switch (item.getItemId()) {
762 case R.id.share_with:
763 shareWith(selectedMessage);
764 return true;
765 case R.id.correct_message:
766 correctMessage(selectedMessage);
767 return true;
768 case R.id.copy_message:
769 copyMessage(selectedMessage);
770 return true;
771 case R.id.quote_message:
772 quoteMessage(selectedMessage);
773 return true;
774 case R.id.send_again:
775 resendMessage(selectedMessage);
776 return true;
777 case R.id.copy_url:
778 copyUrl(selectedMessage);
779 return true;
780 case R.id.download_file:
781 downloadFile(selectedMessage);
782 return true;
783 case R.id.cancel_transmission:
784 cancelTransmission(selectedMessage);
785 return true;
786 case R.id.retry_decryption:
787 retryDecryption(selectedMessage);
788 return true;
789 case R.id.delete_file:
790 deleteFile(selectedMessage);
791 return true;
792 case R.id.show_error_message:
793 showErrorMessage(selectedMessage);
794 return true;
795 default:
796 return super.onContextItemSelected(item);
797 }
798 }
799
800 private void showErrorMessage(final Message message) {
801 AlertDialog.Builder builder = new AlertDialog.Builder(activity);
802 builder.setTitle(R.string.error_message);
803 builder.setMessage(message.getErrorMessage());
804 builder.setPositiveButton(R.string.confirm, null);
805 builder.create().show();
806 }
807
808 private void shareWith(Message message) {
809 Intent shareIntent = new Intent();
810 shareIntent.setAction(Intent.ACTION_SEND);
811 if (message.isGeoUri()) {
812 shareIntent.putExtra(Intent.EXTRA_TEXT, message.getBody());
813 shareIntent.setType("text/plain");
814 } else if (!message.isFileOrImage()) {
815 shareIntent.putExtra(Intent.EXTRA_TEXT, message.getMergedBody().toString());
816 shareIntent.setType("text/plain");
817 } else {
818 final DownloadableFile file = activity.xmppConnectionService.getFileBackend().getFile(message);
819 try {
820 shareIntent.putExtra(Intent.EXTRA_STREAM, FileBackend.getUriForFile(activity, file));
821 } catch (SecurityException e) {
822 Toast.makeText(activity, activity.getString(R.string.no_permission_to_access_x, file.getAbsolutePath()), Toast.LENGTH_SHORT).show();
823 return;
824 }
825 shareIntent.setFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
826 String mime = message.getMimeType();
827 if (mime == null) {
828 mime = "*/*";
829 }
830 shareIntent.setType(mime);
831 }
832 try {
833 activity.startActivity(Intent.createChooser(shareIntent, getText(R.string.share_with)));
834 } catch (ActivityNotFoundException e) {
835 //This should happen only on faulty androids because normally chooser is always available
836 Toast.makeText(activity, R.string.no_application_found_to_open_file, Toast.LENGTH_SHORT).show();
837 }
838 }
839
840 private void copyMessage(Message message) {
841 if (activity.copyTextToClipboard(message.getMergedBody().toString(), R.string.message)) {
842 Toast.makeText(activity, R.string.message_copied_to_clipboard, Toast.LENGTH_SHORT).show();
843 }
844 }
845
846 private void deleteFile(Message message) {
847 if (activity.xmppConnectionService.getFileBackend().deleteFile(message)) {
848 message.setTransferable(new TransferablePlaceholder(Transferable.STATUS_DELETED));
849 activity.updateConversationList();
850 updateMessages();
851 }
852 }
853
854 private void resendMessage(final Message message) {
855 if (message.isFileOrImage()) {
856 DownloadableFile file = activity.xmppConnectionService.getFileBackend().getFile(message);
857 if (file.exists()) {
858 final Conversation conversation = message.getConversation();
859 final XmppConnection xmppConnection = conversation.getAccount().getXmppConnection();
860 if (!message.hasFileOnRemoteHost()
861 && xmppConnection != null
862 && !xmppConnection.getFeatures().httpUpload(message.getFileParams().size)) {
863 activity.selectPresence(conversation, new OnPresenceSelected() {
864 @Override
865 public void onPresenceSelected() {
866 message.setCounterpart(conversation.getNextCounterpart());
867 activity.xmppConnectionService.resendFailedMessages(message);
868 }
869 });
870 return;
871 }
872 } else {
873 Toast.makeText(activity, R.string.file_deleted, Toast.LENGTH_SHORT).show();
874 message.setTransferable(new TransferablePlaceholder(Transferable.STATUS_DELETED));
875 activity.updateConversationList();
876 updateMessages();
877 return;
878 }
879 }
880 activity.xmppConnectionService.resendFailedMessages(message);
881 }
882
883 private void copyUrl(Message message) {
884 final String url;
885 final int resId;
886 if (message.isGeoUri()) {
887 resId = R.string.location;
888 url = message.getBody();
889 } else if (message.hasFileOnRemoteHost()) {
890 resId = R.string.file_url;
891 url = message.getFileParams().url.toString();
892 } else {
893 url = message.getBody().trim();
894 resId = R.string.file_url;
895 }
896 if (activity.copyTextToClipboard(url, resId)) {
897 Toast.makeText(activity, R.string.url_copied_to_clipboard,
898 Toast.LENGTH_SHORT).show();
899 }
900 }
901
902 private void downloadFile(Message message) {
903 activity.xmppConnectionService.getHttpConnectionManager().createNewDownloadConnection(message, true);
904 }
905
906 private void cancelTransmission(Message message) {
907 Transferable transferable = message.getTransferable();
908 if (transferable != null) {
909 transferable.cancel();
910 } else if (message.getStatus() != Message.STATUS_RECEIVED) {
911 activity.xmppConnectionService.markMessage(message, Message.STATUS_SEND_FAILED);
912 }
913 }
914
915 private void retryDecryption(Message message) {
916 message.setEncryption(Message.ENCRYPTION_PGP);
917 activity.updateConversationList();
918 updateMessages();
919 conversation.getAccount().getPgpDecryptionService().decrypt(message, false);
920 }
921
922 protected void privateMessageWith(final Jid counterpart) {
923 if (conversation.setOutgoingChatState(Config.DEFAULT_CHATSTATE)) {
924 activity.xmppConnectionService.sendChatState(conversation);
925 }
926 this.mEditMessage.setText("");
927 this.conversation.setNextCounterpart(counterpart);
928 updateChatMsgHint();
929 updateSendButton();
930 updateEditablity();
931 }
932
933 private void correctMessage(Message message) {
934 while (message.mergeable(message.next())) {
935 message = message.next();
936 }
937 this.conversation.setCorrectingMessage(message);
938 final Editable editable = mEditMessage.getText();
939 this.conversation.setDraftMessage(editable.toString());
940 this.mEditMessage.setText("");
941 this.mEditMessage.append(message.getBody());
942
943 }
944
945 protected void highlightInConference(String nick) {
946 final Editable editable = mEditMessage.getText();
947 String oldString = editable.toString().trim();
948 final int pos = mEditMessage.getSelectionStart();
949 if (oldString.isEmpty() || pos == 0) {
950 editable.insert(0, nick + ": ");
951 } else {
952 final char before = editable.charAt(pos - 1);
953 final char after = editable.length() > pos ? editable.charAt(pos) : '\0';
954 if (before == '\n') {
955 editable.insert(pos, nick + ": ");
956 } else {
957 if (pos > 2 && editable.subSequence(pos - 2, pos).toString().equals(": ")) {
958 if (NickValidityChecker.check(conversation, Arrays.asList(editable.subSequence(0, pos - 2).toString().split(", ")))) {
959 editable.insert(pos - 2, ", " + nick);
960 return;
961 }
962 }
963 editable.insert(pos, (Character.isWhitespace(before) ? "" : " ") + nick + (Character.isWhitespace(after) ? "" : " "));
964 if (Character.isWhitespace(after)) {
965 mEditMessage.setSelection(mEditMessage.getSelectionStart() + 1);
966 }
967 }
968 }
969 }
970
971 @Override
972 public void onStop() {
973 super.onStop();
974 if (activity == null || !activity.isChangingConfigurations()) {
975 messageListAdapter.stopAudioPlayer();
976 }
977 if (this.conversation != null) {
978 final String msg = mEditMessage.getText().toString();
979 if (this.conversation.setNextMessage(msg)) {
980 activity.xmppConnectionService.updateConversation(this.conversation);
981 }
982 updateChatState(this.conversation, msg);
983 }
984 }
985
986 private void updateChatState(final Conversation conversation, final String msg) {
987 ChatState state = msg.length() == 0 ? Config.DEFAULT_CHATSTATE : ChatState.PAUSED;
988 Account.State status = conversation.getAccount().getStatus();
989 if (status == Account.State.ONLINE && conversation.setOutgoingChatState(state)) {
990 activity.xmppConnectionService.sendChatState(conversation);
991 }
992 }
993
994 public boolean reInit(Conversation conversation) {
995 if (conversation == null) {
996 return false;
997 }
998 this.activity = (ConversationActivity) getActivity();
999 setupIme();
1000 if (this.conversation != null) {
1001 final String msg = mEditMessage.getText().toString();
1002 if (this.conversation.setNextMessage(msg)) {
1003 activity.xmppConnectionService.updateConversation(conversation);
1004 }
1005 if (this.conversation != conversation) {
1006 updateChatState(this.conversation, msg);
1007 messageListAdapter.stopAudioPlayer();
1008 }
1009 this.conversation.trim();
1010
1011 }
1012
1013 if (activity != null) {
1014 this.mSendButton.setContentDescription(activity.getString(R.string.send_message_to_x, conversation.getName()));
1015 }
1016
1017 this.conversation = conversation;
1018 this.mEditMessage.setKeyboardListener(null);
1019 this.mEditMessage.setText("");
1020 this.mEditMessage.append(this.conversation.getNextMessage());
1021 this.mEditMessage.setKeyboardListener(this);
1022 messageListAdapter.updatePreferences();
1023 this.messagesView.setAdapter(messageListAdapter);
1024 updateMessages();
1025 this.conversation.messagesLoaded.set(true);
1026 synchronized (this.messageList) {
1027 final Message first = conversation.getFirstUnreadMessage();
1028 final int bottom = Math.max(0, this.messageList.size() - 1);
1029 final int pos;
1030 if (first == null) {
1031 pos = bottom;
1032 } else {
1033 int i = getIndexOf(first.getUuid(), this.messageList);
1034 pos = i < 0 ? bottom : i;
1035 }
1036 messagesView.setSelection(pos);
1037 return pos == bottom;
1038 }
1039 }
1040
1041 private void showBlockSubmenu(View view) {
1042 final Jid jid = conversation.getJid();
1043 if (jid.isDomainJid()) {
1044 BlockContactDialog.show(activity, conversation);
1045 } else {
1046 PopupMenu popupMenu = new PopupMenu(activity, view);
1047 popupMenu.inflate(R.menu.block);
1048 popupMenu.setOnMenuItemClickListener(new PopupMenu.OnMenuItemClickListener() {
1049 @Override
1050 public boolean onMenuItemClick(MenuItem menuItem) {
1051 Blockable blockable;
1052 switch (menuItem.getItemId()) {
1053 case R.id.block_domain:
1054 blockable = conversation.getAccount().getRoster().getContact(jid.toDomainJid());
1055 break;
1056 default:
1057 blockable = conversation;
1058 }
1059 BlockContactDialog.show(activity, blockable);
1060 return true;
1061 }
1062 });
1063 popupMenu.show();
1064 }
1065 }
1066
1067 private void updateSnackBar(final Conversation conversation) {
1068 final Account account = conversation.getAccount();
1069 final XmppConnection connection = account.getXmppConnection();
1070 final int mode = conversation.getMode();
1071 final Contact contact = mode == Conversation.MODE_SINGLE ? conversation.getContact() : null;
1072 if (account.getStatus() == Account.State.DISABLED) {
1073 showSnackbar(R.string.this_account_is_disabled, R.string.enable, this.mEnableAccountListener);
1074 } else if (conversation.isBlocked()) {
1075 showSnackbar(R.string.contact_blocked, R.string.unblock, this.mUnblockClickListener);
1076 } else if (contact != null && !contact.showInRoster() && contact.getOption(Contact.Options.PENDING_SUBSCRIPTION_REQUEST)) {
1077 showSnackbar(R.string.contact_added_you, R.string.add_back, this.mAddBackClickListener, this.mLongPressBlockListener);
1078 } else if (contact != null && contact.getOption(Contact.Options.PENDING_SUBSCRIPTION_REQUEST)) {
1079 showSnackbar(R.string.contact_asks_for_presence_subscription, R.string.allow, this.mAllowPresenceSubscription, this.mLongPressBlockListener);
1080 } else if (mode == Conversation.MODE_MULTI
1081 && !conversation.getMucOptions().online()
1082 && account.getStatus() == Account.State.ONLINE) {
1083 switch (conversation.getMucOptions().getError()) {
1084 case NICK_IN_USE:
1085 showSnackbar(R.string.nick_in_use, R.string.edit, clickToMuc);
1086 break;
1087 case NO_RESPONSE:
1088 showSnackbar(R.string.joining_conference, 0, null);
1089 break;
1090 case SERVER_NOT_FOUND:
1091 if (conversation.receivedMessagesCount() > 0) {
1092 showSnackbar(R.string.remote_server_not_found, R.string.try_again, joinMuc);
1093 } else {
1094 showSnackbar(R.string.remote_server_not_found, R.string.leave, leaveMuc);
1095 }
1096 break;
1097 case PASSWORD_REQUIRED:
1098 showSnackbar(R.string.conference_requires_password, R.string.enter_password, enterPassword);
1099 break;
1100 case BANNED:
1101 showSnackbar(R.string.conference_banned, R.string.leave, leaveMuc);
1102 break;
1103 case MEMBERS_ONLY:
1104 showSnackbar(R.string.conference_members_only, R.string.leave, leaveMuc);
1105 break;
1106 case KICKED:
1107 showSnackbar(R.string.conference_kicked, R.string.join, joinMuc);
1108 break;
1109 case UNKNOWN:
1110 showSnackbar(R.string.conference_unknown_error, R.string.try_again, joinMuc);
1111 break;
1112 case SHUTDOWN:
1113 showSnackbar(R.string.conference_shutdown, R.string.try_again, joinMuc);
1114 break;
1115 default:
1116 hideSnackbar();
1117 break;
1118 }
1119 } else if (account.hasPendingPgpIntent(conversation)) {
1120 showSnackbar(R.string.openpgp_messages_found, R.string.decrypt, clickToDecryptListener);
1121 } else if (mode == Conversation.MODE_SINGLE
1122 && conversation.smpRequested()) {
1123 showSnackbar(R.string.smp_requested, R.string.verify, this.mAnswerSmpClickListener);
1124 } else if (mode == Conversation.MODE_SINGLE
1125 && conversation.hasValidOtrSession()
1126 && (conversation.getOtrSession().getSessionStatus() == SessionStatus.ENCRYPTED)
1127 && (!conversation.isOtrFingerprintVerified())) {
1128 showSnackbar(R.string.unknown_otr_fingerprint, R.string.verify, clickToVerify);
1129 } else if (connection != null
1130 && connection.getFeatures().blocking()
1131 && conversation.countMessages() != 0
1132 && !conversation.isBlocked()
1133 && conversation.isWithStranger()) {
1134 showSnackbar(R.string.received_message_from_stranger, R.string.block, mBlockClickListener);
1135 } else {
1136 hideSnackbar();
1137 }
1138 }
1139
1140 public void updateMessages() {
1141 synchronized (this.messageList) {
1142 if (getView() == null) {
1143 return;
1144 }
1145 final ConversationActivity activity = (ConversationActivity) getActivity();
1146 if (this.conversation != null) {
1147 conversation.populateWithMessages(ConversationFragment.this.messageList);
1148 updateSnackBar(conversation);
1149 updateStatusMessages();
1150 this.messageListAdapter.notifyDataSetChanged();
1151 updateChatMsgHint();
1152 if (!activity.isConversationsOverviewVisable() || !activity.isConversationsOverviewHideable()) {
1153 activity.sendReadMarkerIfNecessary(conversation);
1154 }
1155 updateSendButton();
1156 updateEditablity();
1157 }
1158 }
1159 }
1160
1161 protected void messageSent() {
1162 mSendingPgpMessage.set(false);
1163 mEditMessage.setText("");
1164 if (conversation.setCorrectingMessage(null)) {
1165 mEditMessage.append(conversation.getDraftMessage());
1166 conversation.setDraftMessage(null);
1167 }
1168 if (conversation.setNextMessage(mEditMessage.getText().toString())) {
1169 activity.xmppConnectionService.updateConversation(conversation);
1170 }
1171 updateChatMsgHint();
1172 new Handler().post(new Runnable() {
1173 @Override
1174 public void run() {
1175 int size = messageList.size();
1176 messagesView.setSelection(size - 1);
1177 }
1178 });
1179 }
1180
1181 public void setFocusOnInputField() {
1182 mEditMessage.requestFocus();
1183 }
1184
1185 public void doneSendingPgpMessage() {
1186 mSendingPgpMessage.set(false);
1187 }
1188
1189 private int getSendButtonImageResource(SendButtonAction action, Presence.Status status) {
1190 switch (action) {
1191 case TEXT:
1192 switch (status) {
1193 case CHAT:
1194 case ONLINE:
1195 return R.drawable.ic_send_text_online;
1196 case AWAY:
1197 return R.drawable.ic_send_text_away;
1198 case XA:
1199 case DND:
1200 return R.drawable.ic_send_text_dnd;
1201 default:
1202 return activity.getThemeResource(R.attr.ic_send_text_offline, R.drawable.ic_send_text_offline);
1203 }
1204 case RECORD_VIDEO:
1205 switch (status) {
1206 case CHAT:
1207 case ONLINE:
1208 return R.drawable.ic_send_videocam_online;
1209 case AWAY:
1210 return R.drawable.ic_send_videocam_away;
1211 case XA:
1212 case DND:
1213 return R.drawable.ic_send_videocam_dnd;
1214 default:
1215 return activity.getThemeResource(R.attr.ic_send_videocam_offline, R.drawable.ic_send_videocam_offline);
1216 }
1217 case TAKE_PHOTO:
1218 switch (status) {
1219 case CHAT:
1220 case ONLINE:
1221 return R.drawable.ic_send_photo_online;
1222 case AWAY:
1223 return R.drawable.ic_send_photo_away;
1224 case XA:
1225 case DND:
1226 return R.drawable.ic_send_photo_dnd;
1227 default:
1228 return activity.getThemeResource(R.attr.ic_send_photo_offline, R.drawable.ic_send_photo_offline);
1229 }
1230 case RECORD_VOICE:
1231 switch (status) {
1232 case CHAT:
1233 case ONLINE:
1234 return R.drawable.ic_send_voice_online;
1235 case AWAY:
1236 return R.drawable.ic_send_voice_away;
1237 case XA:
1238 case DND:
1239 return R.drawable.ic_send_voice_dnd;
1240 default:
1241 return activity.getThemeResource(R.attr.ic_send_voice_offline, R.drawable.ic_send_voice_offline);
1242 }
1243 case SEND_LOCATION:
1244 switch (status) {
1245 case CHAT:
1246 case ONLINE:
1247 return R.drawable.ic_send_location_online;
1248 case AWAY:
1249 return R.drawable.ic_send_location_away;
1250 case XA:
1251 case DND:
1252 return R.drawable.ic_send_location_dnd;
1253 default:
1254 return activity.getThemeResource(R.attr.ic_send_location_offline, R.drawable.ic_send_location_offline);
1255 }
1256 case CANCEL:
1257 switch (status) {
1258 case CHAT:
1259 case ONLINE:
1260 return R.drawable.ic_send_cancel_online;
1261 case AWAY:
1262 return R.drawable.ic_send_cancel_away;
1263 case XA:
1264 case DND:
1265 return R.drawable.ic_send_cancel_dnd;
1266 default:
1267 return activity.getThemeResource(R.attr.ic_send_cancel_offline, R.drawable.ic_send_cancel_offline);
1268 }
1269 case CHOOSE_PICTURE:
1270 switch (status) {
1271 case CHAT:
1272 case ONLINE:
1273 return R.drawable.ic_send_picture_online;
1274 case AWAY:
1275 return R.drawable.ic_send_picture_away;
1276 case XA:
1277 case DND:
1278 return R.drawable.ic_send_picture_dnd;
1279 default:
1280 return activity.getThemeResource(R.attr.ic_send_picture_offline, R.drawable.ic_send_picture_offline);
1281 }
1282 }
1283 return activity.getThemeResource(R.attr.ic_send_text_offline, R.drawable.ic_send_text_offline);
1284 }
1285
1286 private void updateEditablity() {
1287 boolean canWrite = this.conversation.getMode() == Conversation.MODE_SINGLE || this.conversation.getMucOptions().participating() || this.conversation.getNextCounterpart() != null;
1288 this.mEditMessage.setFocusable(canWrite);
1289 this.mEditMessage.setFocusableInTouchMode(canWrite);
1290 this.mSendButton.setEnabled(canWrite);
1291 this.mEditMessage.setCursorVisible(canWrite);
1292 }
1293
1294 public void updateSendButton() {
1295 final Conversation c = this.conversation;
1296 final SendButtonAction action;
1297 final Presence.Status status;
1298 final String text = this.mEditMessage == null ? "" : this.mEditMessage.getText().toString();
1299 final boolean empty = text.length() == 0;
1300 final boolean conference = c.getMode() == Conversation.MODE_MULTI;
1301 if (c.getCorrectingMessage() != null && (empty || text.equals(c.getCorrectingMessage().getBody()))) {
1302 action = SendButtonAction.CANCEL;
1303 } else if (conference && !c.getAccount().httpUploadAvailable()) {
1304 if (empty && c.getNextCounterpart() != null) {
1305 action = SendButtonAction.CANCEL;
1306 } else {
1307 action = SendButtonAction.TEXT;
1308 }
1309 } else {
1310 if (empty) {
1311 if (conference && c.getNextCounterpart() != null) {
1312 action = SendButtonAction.CANCEL;
1313 } else {
1314 String setting = activity.getPreferences().getString("quick_action", activity.getResources().getString(R.string.quick_action));
1315 if (!setting.equals("none") && UIHelper.receivedLocationQuestion(conversation.getLatestMessage())) {
1316 action = SendButtonAction.SEND_LOCATION;
1317 } else {
1318 if (setting.equals("recent")) {
1319 setting = activity.getPreferences().getString(ConversationActivity.RECENTLY_USED_QUICK_ACTION, SendButtonAction.TEXT.toString());
1320 action = SendButtonAction.valueOfOrDefault(setting, SendButtonAction.TEXT);
1321 } else {
1322 action = SendButtonAction.valueOfOrDefault(setting, SendButtonAction.TEXT);
1323 }
1324 }
1325 }
1326 } else {
1327 action = SendButtonAction.TEXT;
1328 }
1329 }
1330 if (activity.useSendButtonToIndicateStatus() && c.getAccount().getStatus() == Account.State.ONLINE) {
1331 if (activity.xmppConnectionService != null && activity.xmppConnectionService.getMessageArchiveService().isCatchingUp(c)) {
1332 status = Presence.Status.OFFLINE;
1333 } else if (c.getMode() == Conversation.MODE_SINGLE) {
1334 status = c.getContact().getShownStatus();
1335 } else {
1336 status = c.getMucOptions().online() ? Presence.Status.ONLINE : Presence.Status.OFFLINE;
1337 }
1338 } else {
1339 status = Presence.Status.OFFLINE;
1340 }
1341 this.mSendButton.setTag(action);
1342 this.mSendButton.setImageResource(getSendButtonImageResource(action, status));
1343 }
1344
1345 protected void updateDateSeparators() {
1346 synchronized (this.messageList) {
1347 for (int i = 0; i < this.messageList.size(); ++i) {
1348 final Message current = this.messageList.get(i);
1349 if (i == 0 || !UIHelper.sameDay(this.messageList.get(i - 1).getTimeSent(), current.getTimeSent())) {
1350 this.messageList.add(i, Message.createDateSeparator(current));
1351 i++;
1352 }
1353 }
1354 }
1355 }
1356
1357 protected void updateStatusMessages() {
1358 updateDateSeparators();
1359 synchronized (this.messageList) {
1360 if (showLoadMoreMessages(conversation)) {
1361 this.messageList.add(0, Message.createLoadMoreMessage(conversation));
1362 }
1363 if (conversation.getMode() == Conversation.MODE_SINGLE) {
1364 ChatState state = conversation.getIncomingChatState();
1365 if (state == ChatState.COMPOSING) {
1366 this.messageList.add(Message.createStatusMessage(conversation, getString(R.string.contact_is_typing, conversation.getName())));
1367 } else if (state == ChatState.PAUSED) {
1368 this.messageList.add(Message.createStatusMessage(conversation, getString(R.string.contact_has_stopped_typing, conversation.getName())));
1369 } else {
1370 for (int i = this.messageList.size() - 1; i >= 0; --i) {
1371 if (this.messageList.get(i).getStatus() == Message.STATUS_RECEIVED) {
1372 return;
1373 } else {
1374 if (this.messageList.get(i).getStatus() == Message.STATUS_SEND_DISPLAYED) {
1375 this.messageList.add(i + 1,
1376 Message.createStatusMessage(conversation, getString(R.string.contact_has_read_up_to_this_point, conversation.getName())));
1377 return;
1378 }
1379 }
1380 }
1381 }
1382 } else {
1383 final MucOptions mucOptions = conversation.getMucOptions();
1384 final List<MucOptions.User> allUsers = mucOptions.getUsers();
1385 final Set<ReadByMarker> addedMarkers = new HashSet<>();
1386 ChatState state = ChatState.COMPOSING;
1387 List<MucOptions.User> users = conversation.getMucOptions().getUsersWithChatState(state, 5);
1388 if (users.size() == 0) {
1389 state = ChatState.PAUSED;
1390 users = conversation.getMucOptions().getUsersWithChatState(state, 5);
1391 }
1392 int markersAdded = 0;
1393 if (mucOptions.membersOnly() && mucOptions.nonanonymous()) {
1394 //addedMarkers.addAll(ReadByMarker.from(users));
1395 for (int i = this.messageList.size() - 1; i >= 0; --i) {
1396 final Set<ReadByMarker> markersForMessage = messageList.get(i).getReadByMarkers();
1397 final List<MucOptions.User> shownMarkers = new ArrayList<>();
1398 for (ReadByMarker marker : markersForMessage) {
1399 if (!ReadByMarker.contains(marker, addedMarkers)) {
1400 addedMarkers.add(marker); //may be put outside this condition. set should do dedup anyway
1401 MucOptions.User user = mucOptions.findUser(marker);
1402 if (user != null && !users.contains(user)) {
1403 shownMarkers.add(user);
1404 }
1405 }
1406 }
1407 final ReadByMarker markerForSender = ReadByMarker.from(messageList.get(i));
1408 final Message statusMessage;
1409 final int size = shownMarkers.size();
1410 if (size > 1) {
1411 final String body;
1412 if (size <= 4) {
1413 body = getString(R.string.contacts_have_read_up_to_this_point, UIHelper.concatNames(shownMarkers));
1414 } else {
1415 body = getString(R.string.contacts_and_n_more_have_read_up_to_this_point, UIHelper.concatNames(shownMarkers, 3), size - 3);
1416 }
1417 statusMessage = Message.createStatusMessage(conversation, body);
1418 statusMessage.setCounterparts(shownMarkers);
1419 } else if (size == 1) {
1420 statusMessage = Message.createStatusMessage(conversation, getString(R.string.contact_has_read_up_to_this_point, UIHelper.getDisplayName(shownMarkers.get(0))));
1421 statusMessage.setCounterpart(shownMarkers.get(0).getFullJid());
1422 statusMessage.setTrueCounterpart(shownMarkers.get(0).getRealJid());
1423 } else {
1424 statusMessage = null;
1425 }
1426 if (statusMessage != null) {
1427 ++markersAdded;
1428 this.messageList.add(i + 1, statusMessage);
1429 }
1430 addedMarkers.add(markerForSender);
1431 if (ReadByMarker.allUsersRepresented(allUsers, addedMarkers)) {
1432 break;
1433 }
1434 }
1435 }
1436 if (users.size() > 0) {
1437 Message statusMessage;
1438 if (users.size() == 1) {
1439 MucOptions.User user = users.get(0);
1440 int id = state == ChatState.COMPOSING ? R.string.contact_is_typing : R.string.contact_has_stopped_typing;
1441 statusMessage = Message.createStatusMessage(conversation, getString(id, UIHelper.getDisplayName(user)));
1442 statusMessage.setTrueCounterpart(user.getRealJid());
1443 statusMessage.setCounterpart(user.getFullJid());
1444 } else {
1445 int id = state == ChatState.COMPOSING ? R.string.contacts_are_typing : R.string.contacts_have_stopped_typing;
1446 statusMessage = Message.createStatusMessage(conversation, getString(id, UIHelper.concatNames(users)));
1447 statusMessage.setCounterparts(users);
1448 }
1449 this.messageList.add(statusMessage);
1450 }
1451
1452 }
1453 }
1454 }
1455
1456 public void stopScrolling() {
1457 long now = SystemClock.uptimeMillis();
1458 MotionEvent cancel = MotionEvent.obtain(now, now, MotionEvent.ACTION_CANCEL, 0, 0, 0);
1459 messagesView.dispatchTouchEvent(cancel);
1460 }
1461
1462 private boolean showLoadMoreMessages(final Conversation c) {
1463 final boolean mam = hasMamSupport(c);
1464 final MessageArchiveService service = activity.xmppConnectionService.getMessageArchiveService();
1465 return mam && (c.getLastClearHistory().getTimestamp() != 0 || (c.countMessages() == 0 && c.messagesLoaded.get() && c.hasMessagesLeftOnServer() && !service.queryInProgress(c)));
1466 }
1467
1468 private boolean hasMamSupport(final Conversation c) {
1469 if (c.getMode() == Conversation.MODE_SINGLE) {
1470 final XmppConnection connection = c.getAccount().getXmppConnection();
1471 return connection != null && connection.getFeatures().mam();
1472 } else {
1473 return c.getMucOptions().mamSupport();
1474 }
1475 }
1476
1477 protected void showSnackbar(final int message, final int action, final OnClickListener clickListener) {
1478 showSnackbar(message, action, clickListener, null);
1479 }
1480
1481 protected void showSnackbar(final int message, final int action, final OnClickListener clickListener, final View.OnLongClickListener longClickListener) {
1482 snackbar.setVisibility(View.VISIBLE);
1483 snackbar.setOnClickListener(null);
1484 snackbarMessage.setText(message);
1485 snackbarMessage.setOnClickListener(null);
1486 snackbarAction.setVisibility(clickListener == null ? View.GONE : View.VISIBLE);
1487 if (action != 0) {
1488 snackbarAction.setText(action);
1489 }
1490 snackbarAction.setOnClickListener(clickListener);
1491 snackbarAction.setOnLongClickListener(longClickListener);
1492 }
1493
1494 protected void hideSnackbar() {
1495 snackbar.setVisibility(View.GONE);
1496 }
1497
1498 protected void sendPlainTextMessage(Message message) {
1499 ConversationActivity activity = (ConversationActivity) getActivity();
1500 activity.xmppConnectionService.sendMessage(message);
1501 messageSent();
1502 }
1503
1504 protected void sendPgpMessage(final Message message) {
1505 final ConversationActivity activity = (ConversationActivity) getActivity();
1506 final XmppConnectionService xmppService = activity.xmppConnectionService;
1507 final Contact contact = message.getConversation().getContact();
1508 if (!activity.hasPgp()) {
1509 activity.showInstallPgpDialog();
1510 return;
1511 }
1512 if (conversation.getAccount().getPgpSignature() == null) {
1513 activity.announcePgp(conversation.getAccount(), conversation, null, activity.onOpenPGPKeyPublished);
1514 return;
1515 }
1516 if (!mSendingPgpMessage.compareAndSet(false, true)) {
1517 Log.d(Config.LOGTAG, "sending pgp message already in progress");
1518 }
1519 if (conversation.getMode() == Conversation.MODE_SINGLE) {
1520 if (contact.getPgpKeyId() != 0) {
1521 xmppService.getPgpEngine().hasKey(contact,
1522 new UiCallback<Contact>() {
1523
1524 @Override
1525 public void userInputRequried(PendingIntent pi,
1526 Contact contact) {
1527 activity.runIntent(
1528 pi,
1529 ConversationActivity.REQUEST_ENCRYPT_MESSAGE);
1530 }
1531
1532 @Override
1533 public void success(Contact contact) {
1534 activity.encryptTextMessage(message);
1535 }
1536
1537 @Override
1538 public void error(int error, Contact contact) {
1539 activity.runOnUiThread(new Runnable() {
1540 @Override
1541 public void run() {
1542 Toast.makeText(activity,
1543 R.string.unable_to_connect_to_keychain,
1544 Toast.LENGTH_SHORT
1545 ).show();
1546 }
1547 });
1548 mSendingPgpMessage.set(false);
1549 }
1550 });
1551
1552 } else {
1553 showNoPGPKeyDialog(false,
1554 new DialogInterface.OnClickListener() {
1555
1556 @Override
1557 public void onClick(DialogInterface dialog,
1558 int which) {
1559 conversation
1560 .setNextEncryption(Message.ENCRYPTION_NONE);
1561 xmppService.updateConversation(conversation);
1562 message.setEncryption(Message.ENCRYPTION_NONE);
1563 xmppService.sendMessage(message);
1564 messageSent();
1565 }
1566 });
1567 }
1568 } else {
1569 if (conversation.getMucOptions().pgpKeysInUse()) {
1570 if (!conversation.getMucOptions().everybodyHasKeys()) {
1571 Toast warning = Toast
1572 .makeText(getActivity(),
1573 R.string.missing_public_keys,
1574 Toast.LENGTH_LONG);
1575 warning.setGravity(Gravity.CENTER_VERTICAL, 0, 0);
1576 warning.show();
1577 }
1578 activity.encryptTextMessage(message);
1579 } else {
1580 showNoPGPKeyDialog(true,
1581 new DialogInterface.OnClickListener() {
1582
1583 @Override
1584 public void onClick(DialogInterface dialog,
1585 int which) {
1586 conversation
1587 .setNextEncryption(Message.ENCRYPTION_NONE);
1588 message.setEncryption(Message.ENCRYPTION_NONE);
1589 xmppService.updateConversation(conversation);
1590 xmppService.sendMessage(message);
1591 messageSent();
1592 }
1593 });
1594 }
1595 }
1596 }
1597
1598 public void showNoPGPKeyDialog(boolean plural,
1599 DialogInterface.OnClickListener listener) {
1600 AlertDialog.Builder builder = new AlertDialog.Builder(getActivity());
1601 builder.setIconAttribute(android.R.attr.alertDialogIcon);
1602 if (plural) {
1603 builder.setTitle(getString(R.string.no_pgp_keys));
1604 builder.setMessage(getText(R.string.contacts_have_no_pgp_keys));
1605 } else {
1606 builder.setTitle(getString(R.string.no_pgp_key));
1607 builder.setMessage(getText(R.string.contact_has_no_pgp_key));
1608 }
1609 builder.setNegativeButton(getString(R.string.cancel), null);
1610 builder.setPositiveButton(getString(R.string.send_unencrypted),
1611 listener);
1612 builder.create().show();
1613 }
1614
1615 protected void sendAxolotlMessage(final Message message) {
1616 final ConversationActivity activity = (ConversationActivity) getActivity();
1617 final XmppConnectionService xmppService = activity.xmppConnectionService;
1618 xmppService.sendMessage(message);
1619 messageSent();
1620 }
1621
1622 protected void sendOtrMessage(final Message message) {
1623 final ConversationActivity activity = (ConversationActivity) getActivity();
1624 final XmppConnectionService xmppService = activity.xmppConnectionService;
1625 activity.selectPresence(message.getConversation(),
1626 new OnPresenceSelected() {
1627
1628 @Override
1629 public void onPresenceSelected() {
1630 message.setCounterpart(conversation.getNextCounterpart());
1631 xmppService.sendMessage(message);
1632 messageSent();
1633 }
1634 });
1635 }
1636
1637 public void appendText(String text) {
1638 if (text == null) {
1639 return;
1640 }
1641 String previous = this.mEditMessage.getText().toString();
1642 if (previous.length() != 0 && !previous.endsWith(" ")) {
1643 text = " " + text;
1644 }
1645 this.mEditMessage.append(text);
1646 }
1647
1648 @Override
1649 public boolean onEnterPressed() {
1650 if (activity.enterIsSend()) {
1651 sendMessage();
1652 return true;
1653 } else {
1654 return false;
1655 }
1656 }
1657
1658 @Override
1659 public void onTypingStarted() {
1660 Account.State status = conversation.getAccount().getStatus();
1661 if (status == Account.State.ONLINE && conversation.setOutgoingChatState(ChatState.COMPOSING)) {
1662 activity.xmppConnectionService.sendChatState(conversation);
1663 }
1664 activity.hideConversationsOverview();
1665 updateSendButton();
1666 }
1667
1668 @Override
1669 public void onTypingStopped() {
1670 Account.State status = conversation.getAccount().getStatus();
1671 if (status == Account.State.ONLINE && conversation.setOutgoingChatState(ChatState.PAUSED)) {
1672 activity.xmppConnectionService.sendChatState(conversation);
1673 }
1674 }
1675
1676 @Override
1677 public void onTextDeleted() {
1678 Account.State status = conversation.getAccount().getStatus();
1679 if (status == Account.State.ONLINE && conversation.setOutgoingChatState(Config.DEFAULT_CHATSTATE)) {
1680 activity.xmppConnectionService.sendChatState(conversation);
1681 }
1682 updateSendButton();
1683 }
1684
1685 @Override
1686 public void onTextChanged() {
1687 if (conversation != null && conversation.getCorrectingMessage() != null) {
1688 updateSendButton();
1689 }
1690 }
1691
1692 @Override
1693 public boolean onTabPressed(boolean repeated) {
1694 if (conversation == null || conversation.getMode() == Conversation.MODE_SINGLE) {
1695 return false;
1696 }
1697 if (repeated) {
1698 completionIndex++;
1699 } else {
1700 lastCompletionLength = 0;
1701 completionIndex = 0;
1702 final String content = mEditMessage.getText().toString();
1703 lastCompletionCursor = mEditMessage.getSelectionEnd();
1704 int start = lastCompletionCursor > 0 ? content.lastIndexOf(" ", lastCompletionCursor - 1) + 1 : 0;
1705 firstWord = start == 0;
1706 incomplete = content.substring(start, lastCompletionCursor);
1707 }
1708 List<String> completions = new ArrayList<>();
1709 for (MucOptions.User user : conversation.getMucOptions().getUsers()) {
1710 String name = user.getName();
1711 if (name != null && name.startsWith(incomplete)) {
1712 completions.add(name + (firstWord ? ": " : " "));
1713 }
1714 }
1715 Collections.sort(completions);
1716 if (completions.size() > completionIndex) {
1717 String completion = completions.get(completionIndex).substring(incomplete.length());
1718 mEditMessage.getEditableText().delete(lastCompletionCursor, lastCompletionCursor + lastCompletionLength);
1719 mEditMessage.getEditableText().insert(lastCompletionCursor, completion);
1720 lastCompletionLength = completion.length();
1721 } else {
1722 completionIndex = -1;
1723 mEditMessage.getEditableText().delete(lastCompletionCursor, lastCompletionCursor + lastCompletionLength);
1724 lastCompletionLength = 0;
1725 }
1726 return true;
1727 }
1728
1729 @Override
1730 public void onActivityResult(int requestCode, int resultCode,
1731 final Intent data) {
1732 if (resultCode == Activity.RESULT_OK) {
1733 if (requestCode == ConversationActivity.REQUEST_DECRYPT_PGP) {
1734 activity.getSelectedConversation().getAccount().getPgpDecryptionService().continueDecryption(data);
1735 } else if (requestCode == ConversationActivity.REQUEST_TRUST_KEYS_TEXT) {
1736 final String body = mEditMessage.getText().toString();
1737 Message message = new Message(conversation, body, conversation.getNextEncryption());
1738 sendAxolotlMessage(message);
1739 } else if (requestCode == ConversationActivity.REQUEST_TRUST_KEYS_MENU) {
1740 int choice = data.getIntExtra("choice", ConversationActivity.ATTACHMENT_CHOICE_INVALID);
1741 activity.selectPresenceToAttachFile(choice, conversation.getNextEncryption());
1742 }
1743 } else if (resultCode == Activity.RESULT_CANCELED) {
1744 if (requestCode == ConversationActivity.REQUEST_DECRYPT_PGP) {
1745 // discard the message to prevent decryption being blocked
1746 conversation.getAccount().getPgpDecryptionService().giveUpCurrentDecryption();
1747 }
1748 }
1749 }
1750
1751 enum SendButtonAction {
1752 TEXT, TAKE_PHOTO, SEND_LOCATION, RECORD_VOICE, CANCEL, CHOOSE_PICTURE, RECORD_VIDEO;
1753
1754 public static SendButtonAction valueOfOrDefault(String setting, SendButtonAction text) {
1755 try {
1756 return valueOf(setting);
1757 } catch (IllegalArgumentException e) {
1758 return TEXT;
1759 }
1760 }
1761 }
1762
1763}