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