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