Move conversation classes to their own package.

src/org/thoughtcrime/securesms/conversation/ConversationAdapter.java

@@ -0,0 +1,475 @@
+/*
+ * Copyright (C) 2011 Whisper Systems
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License as published by
+ * the Free Software Foundation, either version 3 of the License, or
+ * (at your option) any later version.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+package org.thoughtcrime.securesms.conversation;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.support.annotation.LayoutRes;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.support.annotation.VisibleForTesting;
+import android.support.v7.widget.RecyclerView;
+
+import org.thoughtcrime.securesms.BindableConversationItem;
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.logging.Log;
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import com.annimon.stream.Stream;
+
+import org.thoughtcrime.securesms.conversation.ConversationAdapter.HeaderViewHolder;
+import org.thoughtcrime.securesms.attachments.DatabaseAttachment;
+import org.thoughtcrime.securesms.database.DatabaseFactory;
+import org.thoughtcrime.securesms.database.FastCursorRecyclerViewAdapter;
+import org.thoughtcrime.securesms.database.MmsSmsColumns;
+import org.thoughtcrime.securesms.database.MmsSmsDatabase;
+import org.thoughtcrime.securesms.database.model.MessageRecord;
+import org.thoughtcrime.securesms.database.model.MmsMessageRecord;
+import org.thoughtcrime.securesms.mms.GlideRequests;
+import org.thoughtcrime.securesms.mms.SlideDeck;
+import org.thoughtcrime.securesms.recipients.Recipient;
+import org.thoughtcrime.securesms.util.Conversions;
+import org.thoughtcrime.securesms.util.DateUtils;
+import org.thoughtcrime.securesms.util.LRUCache;
+import org.thoughtcrime.securesms.util.StickyHeaderDecoration;
+import org.thoughtcrime.securesms.util.Util;
+import org.thoughtcrime.securesms.util.ViewUtil;
+import org.whispersystems.libsignal.util.guava.Optional;
+
+import java.lang.ref.SoftReference;
+import java.security.MessageDigest;
+import java.security.NoSuchAlgorithmException;
+import java.util.Calendar;
+import java.util.Collections;
+import java.util.Date;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Set;
+
+/**
+ * A cursor adapter for a conversation thread.  Ultimately
+ * used by ComposeMessageActivity to display a conversation
+ * thread in a ListActivity.
+ *
+ * @author Moxie Marlinspike
+ *
+ */
+public class ConversationAdapter <V extends View & BindableConversationItem>
+    extends FastCursorRecyclerViewAdapter<ConversationAdapter.ViewHolder, MessageRecord>
+  implements StickyHeaderDecoration.StickyHeaderAdapter<HeaderViewHolder>
+{
+
+  private static final int MAX_CACHE_SIZE = 40;
+  private static final String TAG = ConversationAdapter.class.getSimpleName();
+  private final Map<String,SoftReference<MessageRecord>> messageRecordCache =
+      Collections.synchronizedMap(new LRUCache<String, SoftReference<MessageRecord>>(MAX_CACHE_SIZE));
+
+  private static final int MESSAGE_TYPE_OUTGOING           = 0;
+  private static final int MESSAGE_TYPE_INCOMING           = 1;
+  private static final int MESSAGE_TYPE_UPDATE             = 2;
+  private static final int MESSAGE_TYPE_AUDIO_OUTGOING     = 3;
+  private static final int MESSAGE_TYPE_AUDIO_INCOMING     = 4;
+  private static final int MESSAGE_TYPE_THUMBNAIL_OUTGOING = 5;
+  private static final int MESSAGE_TYPE_THUMBNAIL_INCOMING = 6;
+  private static final int MESSAGE_TYPE_DOCUMENT_OUTGOING  = 7;
+  private static final int MESSAGE_TYPE_DOCUMENT_INCOMING  = 8;
+
+  private final Set<MessageRecord> batchSelected = Collections.synchronizedSet(new HashSet<MessageRecord>());
+
+  private final @Nullable ItemClickListener clickListener;
+  private final @NonNull  GlideRequests     glideRequests;
+  private final @NonNull  Locale            locale;
+  private final @NonNull  Recipient         recipient;
+  private final @NonNull  MmsSmsDatabase    db;
+  private final @NonNull  LayoutInflater    inflater;
+  private final @NonNull  Calendar          calendar;
+  private final @NonNull  MessageDigest     digest;
+
+  private MessageRecord recordToPulseHighlight;
+
+  protected static class ViewHolder extends RecyclerView.ViewHolder {
+    public <V extends View & BindableConversationItem> ViewHolder(final @NonNull V itemView) {
+      super(itemView);
+    }
+
+    @SuppressWarnings("unchecked")
+    public <V extends View & BindableConversationItem> V getView() {
+      return (V)itemView;
+    }
+  }
+
+
+  static class HeaderViewHolder extends RecyclerView.ViewHolder {
+    TextView textView;
+
+    HeaderViewHolder(View itemView) {
+      super(itemView);
+      textView = ViewUtil.findById(itemView, R.id.text);
+    }
+
+    HeaderViewHolder(TextView textView) {
+      super(textView);
+      this.textView = textView;
+    }
+
+    public void setText(CharSequence text) {
+      textView.setText(text);
+    }
+  }
+
+
+  interface ItemClickListener extends BindableConversationItem.EventListener {
+    void onItemClick(MessageRecord item);
+    void onItemLongClick(MessageRecord item);
+  }
+
+  @SuppressWarnings("ConstantConditions")
+  @VisibleForTesting
+  ConversationAdapter(Context context, Cursor cursor) {
+    super(context, cursor);
+    try {
+      this.glideRequests = null;
+      this.locale        = null;
+      this.clickListener = null;
+      this.recipient     = null;
+      this.inflater      = null;
+      this.db            = null;
+      this.calendar      = null;
+      this.digest        = MessageDigest.getInstance("SHA1");
+    } catch (NoSuchAlgorithmException nsae) {
+      throw new AssertionError("SHA1 isn't supported!");
+    }
+  }
+
+  public ConversationAdapter(@NonNull Context context,
+                             @NonNull GlideRequests glideRequests,
+                             @NonNull Locale locale,
+                             @Nullable ItemClickListener clickListener,
+                             @Nullable Cursor cursor,
+                             @NonNull Recipient recipient)
+  {
+    super(context, cursor);
+
+    try {
+      this.glideRequests = glideRequests;
+      this.locale        = locale;
+      this.clickListener = clickListener;
+      this.recipient     = recipient;
+      this.inflater      = LayoutInflater.from(context);
+      this.db            = DatabaseFactory.getMmsSmsDatabase(context);
+      this.calendar      = Calendar.getInstance();
+      this.digest        = MessageDigest.getInstance("SHA1");
+
+      setHasStableIds(true);
+    } catch (NoSuchAlgorithmException nsae) {
+      throw new AssertionError("SHA1 isn't supported!");
+    }
+  }
+
+  @Override
+  public void changeCursor(Cursor cursor) {
+    messageRecordCache.clear();
+    super.cleanFastRecords();
+    super.changeCursor(cursor);
+  }
+
+  @Override
+  protected void onBindItemViewHolder(ViewHolder viewHolder, @NonNull MessageRecord messageRecord) {
+    int           adapterPosition = viewHolder.getAdapterPosition();
+    MessageRecord previousRecord  = adapterPosition < getItemCount() - 1 && !isFooterPosition(adapterPosition + 1) ? getRecordForPositionOrThrow(adapterPosition + 1) : null;
+    MessageRecord nextRecord      = adapterPosition > 0 && !isHeaderPosition(adapterPosition - 1) ? getRecordForPositionOrThrow(adapterPosition - 1) : null;
+
+    viewHolder.getView().bind(messageRecord,
+                              Optional.fromNullable(previousRecord),
+                              Optional.fromNullable(nextRecord),
+                              glideRequests,
+                              locale,
+                              batchSelected,
+                              recipient,
+                              messageRecord == recordToPulseHighlight);
+
+    if (messageRecord == recordToPulseHighlight) {
+      recordToPulseHighlight = null;
+    }
+  }
+
+  @Override
+  public ViewHolder onCreateItemViewHolder(ViewGroup parent, int viewType) {
+    long start = System.currentTimeMillis();
+    final V itemView = ViewUtil.inflate(inflater, parent, getLayoutForViewType(viewType));
+    itemView.setOnClickListener(view -> {
+      if (clickListener != null) {
+        clickListener.onItemClick(itemView.getMessageRecord());
+      }
+    });
+    itemView.setOnLongClickListener(view -> {
+      if (clickListener != null) {
+        clickListener.onItemLongClick(itemView.getMessageRecord());
+      }
+      return true;
+    });
+    itemView.setEventListener(clickListener);
+    Log.d(TAG, "Inflate time: " + (System.currentTimeMillis() - start));
+    return new ViewHolder(itemView);
+  }
+
+  @Override
+  public void onItemViewRecycled(ViewHolder holder) {
+    holder.getView().unbind();
+  }
+
+  private @LayoutRes int getLayoutForViewType(int viewType) {
+    switch (viewType) {
+      case MESSAGE_TYPE_AUDIO_OUTGOING:
+      case MESSAGE_TYPE_THUMBNAIL_OUTGOING:
+      case MESSAGE_TYPE_DOCUMENT_OUTGOING:
+      case MESSAGE_TYPE_OUTGOING:        return R.layout.conversation_item_sent;
+      case MESSAGE_TYPE_AUDIO_INCOMING:
+      case MESSAGE_TYPE_THUMBNAIL_INCOMING:
+      case MESSAGE_TYPE_DOCUMENT_INCOMING:
+      case MESSAGE_TYPE_INCOMING:        return R.layout.conversation_item_received;
+      case MESSAGE_TYPE_UPDATE:          return R.layout.conversation_item_update;
+      default: throw new IllegalArgumentException("unsupported item view type given to ConversationAdapter");
+    }
+  }
+
+  @Override
+  public int getItemViewType(@NonNull MessageRecord messageRecord) {
+    if (messageRecord.isUpdate()) {
+      return MESSAGE_TYPE_UPDATE;
+    } else if (hasAudio(messageRecord)) {
+      if (messageRecord.isOutgoing()) return MESSAGE_TYPE_AUDIO_OUTGOING;
+      else                            return MESSAGE_TYPE_AUDIO_INCOMING;
+    } else if (hasDocument(messageRecord)) {
+      if (messageRecord.isOutgoing()) return MESSAGE_TYPE_DOCUMENT_OUTGOING;
+      else                            return MESSAGE_TYPE_DOCUMENT_INCOMING;
+    } else if (hasThumbnail(messageRecord)) {
+      if (messageRecord.isOutgoing()) return MESSAGE_TYPE_THUMBNAIL_OUTGOING;
+      else                            return MESSAGE_TYPE_THUMBNAIL_INCOMING;
+    } else if (messageRecord.isOutgoing()) {
+      return MESSAGE_TYPE_OUTGOING;
+    } else {
+      return MESSAGE_TYPE_INCOMING;
+    }
+  }
+
+  @Override
+  protected boolean isRecordForId(@NonNull MessageRecord record, long id) {
+    return record.getId() == id;
+  }
+
+  @Override
+  public long getItemId(@NonNull Cursor cursor) {
+    List<DatabaseAttachment> attachments        = DatabaseFactory.getAttachmentDatabase(getContext()).getAttachment(cursor);
+    List<DatabaseAttachment> messageAttachments = Stream.of(attachments).filterNot(DatabaseAttachment::isQuote).toList();
+
+    if (messageAttachments.size() > 0 && messageAttachments.get(0).getFastPreflightId() != null) {
+      return Long.valueOf(messageAttachments.get(0).getFastPreflightId());
+    }
+
+    final String unique = cursor.getString(cursor.getColumnIndexOrThrow(MmsSmsColumns.UNIQUE_ROW_ID));
+    final byte[] bytes  = digest.digest(unique.getBytes());
+    return Conversions.byteArrayToLong(bytes);
+  }
+
+  @Override
+  protected long getItemId(@NonNull MessageRecord record) {
+    if (record.isOutgoing() && record.isMms()) {
+      SlideDeck slideDeck = ((MmsMessageRecord)record).getSlideDeck();
+
+      if (slideDeck.getThumbnailSlide() != null && slideDeck.getThumbnailSlide().getFastPreflightId() != null) {
+        return Long.valueOf(slideDeck.getThumbnailSlide().getFastPreflightId());
+      }
+    }
+
+    return record.getId();
+  }
+
+  @Override
+  protected MessageRecord getRecordFromCursor(@NonNull Cursor cursor) {
+    long   messageId = cursor.getLong(cursor.getColumnIndexOrThrow(MmsSmsColumns.ID));
+    String type      = cursor.getString(cursor.getColumnIndexOrThrow(MmsSmsDatabase.TRANSPORT));
+
+    final SoftReference<MessageRecord> reference = messageRecordCache.get(type + messageId);
+    if (reference != null) {
+      final MessageRecord record = reference.get();
+      if (record != null) return record;
+    }
+
+    final MessageRecord messageRecord = db.readerFor(cursor).getCurrent();
+    messageRecordCache.put(type + messageId, new SoftReference<>(messageRecord));
+
+    return messageRecord;
+  }
+
+  public void close() {
+    getCursor().close();
+  }
+
+  public int findLastSeenPosition(long lastSeen) {
+    if (lastSeen <= 0)     return -1;
+    if (!isActiveCursor()) return -1;
+
+    int count = getItemCount() - (hasFooterView() ? 1 : 0);
+
+    for (int i=(hasHeaderView() ? 1 : 0);i<count;i++) {
+      MessageRecord messageRecord = getRecordForPositionOrThrow(i);
+
+      if (messageRecord.isOutgoing() || messageRecord.getDateReceived() <= lastSeen) {
+        return i;
+      }
+    }
+
+    return -1;
+  }
+
+  public void toggleSelection(MessageRecord messageRecord) {
+    if (!batchSelected.remove(messageRecord)) {
+      batchSelected.add(messageRecord);
+    }
+  }
+
+  public void clearSelection() {
+    batchSelected.clear();
+  }
+
+  public Set<MessageRecord> getSelectedItems() {
+    return Collections.unmodifiableSet(new HashSet<>(batchSelected));
+  }
+
+  public void pulseHighlightItem(int position) {
+    if (position < getItemCount()) {
+      recordToPulseHighlight = getRecordForPositionOrThrow(position);
+      notifyItemChanged(position);
+    }
+  }
+
+  private boolean hasAudio(MessageRecord messageRecord) {
+    return messageRecord.isMms() && ((MmsMessageRecord)messageRecord).getSlideDeck().getAudioSlide() != null;
+  }
+
+  private boolean hasDocument(MessageRecord messageRecord) {
+    return messageRecord.isMms() && ((MmsMessageRecord)messageRecord).getSlideDeck().getDocumentSlide() != null;
+  }
+
+  private boolean hasThumbnail(MessageRecord messageRecord) {
+    return messageRecord.isMms() && ((MmsMessageRecord)messageRecord).getSlideDeck().getThumbnailSlide() != null;
+  }
+
+  @Override
+  public long getHeaderId(int position) {
+    if (!isActiveCursor())          return -1;
+    if (isHeaderPosition(position)) return -1;
+    if (isFooterPosition(position)) return -1;
+    if (position >= getItemCount()) return -1;
+    if (position < 0)               return -1;
+
+    MessageRecord record = getRecordForPositionOrThrow(position);
+
+    calendar.setTime(new Date(record.getDateSent()));
+    return Util.hashCode(calendar.get(Calendar.YEAR), calendar.get(Calendar.DAY_OF_YEAR));
+  }
+
+  public long getReceivedTimestamp(int position) {
+    if (!isActiveCursor())          return 0;
+    if (isHeaderPosition(position)) return 0;
+    if (isFooterPosition(position)) return 0;
+    if (position >= getItemCount()) return 0;
+    if (position < 0)               return 0;
+
+    MessageRecord messageRecord = getRecordForPositionOrThrow(position);
+
+    if (messageRecord.isOutgoing()) return 0;
+    else                            return messageRecord.getDateReceived();
+  }
+
+  @Override
+  public HeaderViewHolder onCreateHeaderViewHolder(ViewGroup parent) {
+    return new HeaderViewHolder(LayoutInflater.from(getContext()).inflate(R.layout.conversation_item_header, parent, false));
+  }
+
+  public HeaderViewHolder onCreateLastSeenViewHolder(ViewGroup parent) {
+    return new HeaderViewHolder(LayoutInflater.from(getContext()).inflate(R.layout.conversation_item_last_seen, parent, false));
+  }
+
+  @Override
+  public void onBindHeaderViewHolder(HeaderViewHolder viewHolder, int position) {
+    MessageRecord messageRecord = getRecordForPositionOrThrow(position);
+    viewHolder.setText(DateUtils.getRelativeDate(getContext(), locale, messageRecord.getDateReceived()));
+  }
+
+  public void onBindLastSeenViewHolder(HeaderViewHolder viewHolder, int position) {
+    viewHolder.setText(getContext().getResources().getQuantityString(R.plurals.ConversationAdapter_n_unread_messages, (position + 1), (position + 1)));
+  }
+
+  static class LastSeenHeader extends StickyHeaderDecoration {
+
+    private final ConversationAdapter adapter;
+    private final long                lastSeenTimestamp;
+
+    LastSeenHeader(ConversationAdapter adapter, long lastSeenTimestamp) {
+      super(adapter, false, false);
+      this.adapter           = adapter;
+      this.lastSeenTimestamp = lastSeenTimestamp;
+    }
+
+    @Override
+    protected boolean hasHeader(RecyclerView parent, StickyHeaderAdapter stickyAdapter, int position) {
+      if (!adapter.isActiveCursor()) {
+        return false;
+      }
+
+      if (lastSeenTimestamp <= 0) {
+        return false;
+      }
+
+      long currentRecordTimestamp  = adapter.getReceivedTimestamp(position);
+      long previousRecordTimestamp = adapter.getReceivedTimestamp(position + 1);
+
+      return currentRecordTimestamp > lastSeenTimestamp && previousRecordTimestamp < lastSeenTimestamp;
+    }
+
+    @Override
+    protected int getHeaderTop(RecyclerView parent, View child, View header, int adapterPos, int layoutPos) {
+      return parent.getLayoutManager().getDecoratedTop(child);
+    }
+
+    @Override
+    protected HeaderViewHolder getHeader(RecyclerView parent, StickyHeaderAdapter stickyAdapter, int position) {
+      HeaderViewHolder viewHolder = adapter.onCreateLastSeenViewHolder(parent);
+      adapter.onBindLastSeenViewHolder(viewHolder, position);
+
+      int widthSpec  = View.MeasureSpec.makeMeasureSpec(parent.getWidth(), View.MeasureSpec.EXACTLY);
+      int heightSpec = View.MeasureSpec.makeMeasureSpec(parent.getHeight(), View.MeasureSpec.UNSPECIFIED);
+
+      int childWidth  = ViewGroup.getChildMeasureSpec(widthSpec, parent.getPaddingLeft() + parent.getPaddingRight(), viewHolder.itemView.getLayoutParams().width);
+      int childHeight = ViewGroup.getChildMeasureSpec(heightSpec, parent.getPaddingTop() + parent.getPaddingBottom(), viewHolder.itemView.getLayoutParams().height);
+
+      viewHolder.itemView.measure(childWidth, childHeight);
+      viewHolder.itemView.layout(0, 0, viewHolder.itemView.getMeasuredWidth(), viewHolder.itemView.getMeasuredHeight());
+
+      return viewHolder;
+    }
+  }
+
+}
+

src/org/thoughtcrime/securesms/conversation/ConversationPopupActivity.java

@@ -0,0 +1,129 @@
+package org.thoughtcrime.securesms.conversation;
+
+import android.content.Intent;
+import android.os.Build.VERSION;
+import android.os.Build.VERSION_CODES;
+import android.os.Bundle;
+import android.support.v4.app.ActivityOptionsCompat;
+
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.logging.Log;
+import android.view.Display;
+import android.view.Gravity;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.view.WindowManager;
+
+import org.thoughtcrime.securesms.util.concurrent.ListenableFuture;
+
+import java.util.concurrent.ExecutionException;
+
+public class ConversationPopupActivity extends ConversationActivity {
+
+  private static final String TAG = ConversationPopupActivity.class.getSimpleName();
+
+  @Override
+  protected void onPreCreate() {
+    super.onPreCreate();
+    overridePendingTransition(R.anim.slide_from_top, R.anim.slide_to_top);
+  }
+
+  @Override
+  protected void onCreate(Bundle bundle, boolean ready) {
+    getWindow().setFlags(WindowManager.LayoutParams.FLAG_DIM_BEHIND,
+                         WindowManager.LayoutParams.FLAG_DIM_BEHIND);
+
+    WindowManager.LayoutParams params = getWindow().getAttributes();
+    params.alpha     = 1.0f;
+    params.dimAmount = 0.1f;
+    params.gravity   = Gravity.TOP;
+    getWindow().setAttributes(params);
+
+    Display display = getWindowManager().getDefaultDisplay();
+    int     width   = display.getWidth();
+    int     height  = display.getHeight();
+
+    if (height > width) getWindow().setLayout((int) (width * .85), (int) (height * .5));
+    else                getWindow().setLayout((int) (width * .7), (int) (height * .75));
+
+    super.onCreate(bundle, ready);
+
+    titleView.setOnClickListener(null);
+  }
+
+  @Override
+  protected void onResume() {
+    super.onResume();
+    composeText.requestFocus();
+    quickAttachmentToggle.disable();
+  }
+
+  @Override
+  protected void onPause() {
+    super.onPause();
+    if (isFinishing()) overridePendingTransition(R.anim.slide_from_top, R.anim.slide_to_top);
+  }
+
+  @Override
+  public boolean onPrepareOptionsMenu(Menu menu) {
+    MenuInflater inflater = this.getMenuInflater();
+    menu.clear();
+
+    inflater.inflate(R.menu.conversation_popup, menu);
+    return true;
+  }
+
+  @Override
+  public boolean onOptionsItemSelected(MenuItem item) {
+    switch (item.getItemId()) {
+      case R.id.menu_expand:
+        saveDraft().addListener(new ListenableFuture.Listener<Long>() {
+          @Override
+          public void onSuccess(Long result) {
+            ActivityOptionsCompat transition = ActivityOptionsCompat.makeScaleUpAnimation(getWindow().getDecorView(), 0, 0, getWindow().getAttributes().width, getWindow().getAttributes().height);
+            Intent intent = new Intent(ConversationPopupActivity.this, ConversationActivity.class);
+            intent.putExtra(ConversationActivity.ADDRESS_EXTRA, getRecipient().getAddress());
+            intent.putExtra(ConversationActivity.THREAD_ID_EXTRA, result);
+
+            if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
+              startActivity(intent, transition.toBundle());
+            } else {
+              startActivity(intent);
+              overridePendingTransition(R.anim.fade_scale_in, R.anim.slide_to_right);
+            }
+
+            finish();
+          }
+
+          @Override
+          public void onFailure(ExecutionException e) {
+            Log.w(TAG, e);
+          }
+        });
+        return true;
+    }
+
+    return false;
+  }
+
+  @Override
+  protected void initializeActionBar() {
+    super.initializeActionBar();
+    getSupportActionBar().setDisplayHomeAsUpEnabled(false);
+  }
+
+  @Override
+  protected void sendComplete(long threadId) {
+    super.sendComplete(threadId);
+    finish();
+  }
+
+  @Override
+  protected void updateReminders(boolean seenInvite) {
+    if (reminderView.resolved()) {
+      reminderView.get().setVisibility(View.GONE);
+    }
+  }
+}

src/org/thoughtcrime/securesms/conversation/ConversationTitleView.java

@@ -0,0 +1,142 @@
+package org.thoughtcrime.securesms.conversation;
+
+import android.annotation.SuppressLint;
+import android.content.Context;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.text.TextUtils;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.RelativeLayout;
+import android.widget.TextView;
+
+import com.annimon.stream.Collectors;
+import com.annimon.stream.Stream;
+
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.components.AvatarImageView;
+import org.thoughtcrime.securesms.mms.GlideRequests;
+import org.thoughtcrime.securesms.recipients.Recipient;
+import org.thoughtcrime.securesms.util.TextSecurePreferences;
+import org.thoughtcrime.securesms.util.ViewUtil;
+
+public class ConversationTitleView extends RelativeLayout {
+
+  @SuppressWarnings("unused")
+  private static final String TAG = ConversationTitleView.class.getSimpleName();
+
+  private View            content;
+  private ImageView       back;
+  private AvatarImageView avatar;
+  private TextView        title;
+  private TextView        subtitle;
+  private ImageView       verified;
+
+  public ConversationTitleView(Context context) {
+    this(context, null);
+  }
+
+  public ConversationTitleView(Context context, AttributeSet attrs) {
+    super(context, attrs);
+
+  }
+
+  @Override
+  public void onFinishInflate() {
+    super.onFinishInflate();
+
+    this.back     = ViewUtil.findById(this, R.id.up_button);
+    this.content  = ViewUtil.findById(this, R.id.content);
+    this.title    = ViewUtil.findById(this, R.id.title);
+    this.subtitle = ViewUtil.findById(this, R.id.subtitle);
+    this.verified = ViewUtil.findById(this, R.id.verified_indicator);
+    this.avatar   = ViewUtil.findById(this, R.id.contact_photo_image);
+
+    ViewUtil.setTextViewGravityStart(this.title, getContext());
+    ViewUtil.setTextViewGravityStart(this.subtitle, getContext());
+  }
+
+  public void setTitle(@NonNull GlideRequests glideRequests, @Nullable Recipient recipient) {
+    if      (recipient == null) setComposeTitle();
+    else                        setRecipientTitle(recipient);
+
+    if (recipient != null && recipient.isBlocked()) {
+      title.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_block_white_18dp, 0, 0, 0);
+    } else if (recipient != null && recipient.isMuted()) {
+      title.setCompoundDrawablesWithIntrinsicBounds(R.drawable.ic_volume_off_white_18dp, 0, 0, 0);
+    } else {
+      title.setCompoundDrawablesWithIntrinsicBounds(0, 0, 0, 0);
+    }
+
+    if (recipient != null) {
+      this.avatar.setAvatar(glideRequests, recipient, false);
+    }
+  }
+
+  public void setVerified(boolean verified) {
+    this.verified.setVisibility(verified ? View.VISIBLE : View.GONE);
+  }
+
+  @Override
+  public void setOnClickListener(@Nullable OnClickListener listener) {
+    this.content.setOnClickListener(listener);
+    this.avatar.setOnClickListener(listener);
+  }
+
+  @Override
+  public void setOnLongClickListener(@Nullable OnLongClickListener listener) {
+    this.content.setOnLongClickListener(listener);
+    this.avatar.setOnLongClickListener(listener);
+  }
+
+  public void setOnBackClickedListener(@Nullable OnClickListener listener) {
+    this.back.setOnClickListener(listener);
+  }
+
+  private void setComposeTitle() {
+    this.title.setText(R.string.ConversationActivity_compose_message);
+    this.subtitle.setText(null);
+    this.subtitle.setVisibility(View.GONE);
+  }
+
+  private void setRecipientTitle(Recipient recipient) {
+    if      (recipient.isGroupRecipient())           setGroupRecipientTitle(recipient);
+    else if (TextUtils.isEmpty(recipient.getName())) setNonContactRecipientTitle(recipient);
+    else                                             setContactRecipientTitle(recipient);
+  }
+
+  private void setGroupRecipientTitle(Recipient recipient) {
+    String localNumber = TextSecurePreferences.getLocalNumber(getContext());
+
+    this.title.setText(recipient.getName());
+    this.subtitle.setText(Stream.of(recipient.getParticipants())
+                                .filter(r -> !r.getAddress().serialize().equals(localNumber))
+                                .map(Recipient::toShortString)
+                                .collect(Collectors.joining(", ")));
+
+    this.subtitle.setVisibility(View.VISIBLE);
+  }
+
+  @SuppressLint("SetTextI18n")
+  private void setNonContactRecipientTitle(Recipient recipient) {
+    this.title.setText(recipient.getAddress().serialize());
+
+    if (TextUtils.isEmpty(recipient.getProfileName())) {
+      this.subtitle.setText(null);
+      this.subtitle.setVisibility(View.GONE);
+    } else {
+      this.subtitle.setText("~" + recipient.getProfileName());
+      this.subtitle.setVisibility(View.VISIBLE);
+    }
+  }
+
+  private void setContactRecipientTitle(Recipient recipient) {
+    this.title.setText(recipient.getName());
+
+    if (recipient.getCustomLabel() != null) this.subtitle.setText(recipient.getCustomLabel());
+    else                                    this.subtitle.setText(recipient.getAddress().serialize());
+
+    this.subtitle.setVisibility(View.VISIBLE);
+  }
+}

src/org/thoughtcrime/securesms/conversation/ConversationUpdateItem.java

@@ -0,0 +1,263 @@
+package org.thoughtcrime.securesms.conversation;
+
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Color;
+import android.graphics.PorterDuff;
+import android.graphics.PorterDuffColorFilter;
+import android.support.annotation.NonNull;
+import android.support.annotation.Nullable;
+import android.util.AttributeSet;
+import android.view.View;
+import android.widget.ImageView;
+import android.widget.LinearLayout;
+import android.widget.TextView;
+
+import org.thoughtcrime.securesms.BindableConversationItem;
+import org.thoughtcrime.securesms.R;
+import org.thoughtcrime.securesms.VerifyIdentityActivity;
+import org.thoughtcrime.securesms.crypto.IdentityKeyParcelable;
+import org.thoughtcrime.securesms.database.IdentityDatabase;
+import org.thoughtcrime.securesms.database.IdentityDatabase.IdentityRecord;
+import org.thoughtcrime.securesms.database.model.MessageRecord;
+import org.thoughtcrime.securesms.logging.Log;
+import org.thoughtcrime.securesms.mms.GlideRequests;
+import org.thoughtcrime.securesms.recipients.Recipient;
+import org.thoughtcrime.securesms.recipients.RecipientModifiedListener;
+import org.thoughtcrime.securesms.util.DateUtils;
+import org.thoughtcrime.securesms.util.ExpirationUtil;
+import org.thoughtcrime.securesms.util.GroupUtil;
+import org.thoughtcrime.securesms.util.IdentityUtil;
+import org.thoughtcrime.securesms.util.Util;
+import org.thoughtcrime.securesms.util.concurrent.ListenableFuture;
+import org.whispersystems.libsignal.util.guava.Optional;
+
+import java.util.Locale;
+import java.util.Set;
+import java.util.concurrent.ExecutionException;
+
+public class ConversationUpdateItem extends LinearLayout
+    implements RecipientModifiedListener, BindableConversationItem
+{
+  private static final String TAG = ConversationUpdateItem.class.getSimpleName();
+
+  private Set<MessageRecord> batchSelected;
+
+  private ImageView     icon;
+  private TextView      title;
+  private TextView      body;
+  private TextView      date;
+  private Recipient     sender;
+  private MessageRecord messageRecord;
+  private Locale        locale;
+
+  public ConversationUpdateItem(Context context) {
+    super(context);
+  }
+
+  public ConversationUpdateItem(Context context, AttributeSet attrs) {
+    super(context, attrs);
+  }
+
+  @Override
+  public void onFinishInflate() {
+    super.onFinishInflate();
+
+    this.icon  = findViewById(R.id.conversation_update_icon);
+    this.title = findViewById(R.id.conversation_update_title);
+    this.body  = findViewById(R.id.conversation_update_body);
+    this.date  = findViewById(R.id.conversation_update_date);
+
+    this.setOnClickListener(new InternalClickListener(null));
+  }
+
+  @Override
+  public void bind(@NonNull MessageRecord           messageRecord,
+                   @NonNull Optional<MessageRecord> previousMessageRecord,
+                   @NonNull Optional<MessageRecord> nextMessageRecord,
+                   @NonNull GlideRequests           glideRequests,
+                   @NonNull Locale                  locale,
+                   @NonNull Set<MessageRecord>      batchSelected,
+                   @NonNull Recipient               conversationRecipient,
+                            boolean                 pulseUpdate)
+  {
+    this.batchSelected = batchSelected;
+
+    bind(messageRecord, locale);
+  }
+
+  @Override
+  public void setEventListener(@Nullable EventListener listener) {
+    // No events to report yet
+  }
+
+  @Override
+  public MessageRecord getMessageRecord() {
+    return messageRecord;
+  }
+
+  private void bind(@NonNull MessageRecord messageRecord, @NonNull Locale locale) {
+    this.messageRecord = messageRecord;
+    this.sender        = messageRecord.getIndividualRecipient();
+    this.locale        = locale;
+
+    this.sender.addListener(this);
+
+    if      (messageRecord.isGroupAction())           setGroupRecord(messageRecord);
+    else if (messageRecord.isCallLog())               setCallRecord(messageRecord);
+    else if (messageRecord.isJoined())                setJoinedRecord(messageRecord);
+    else if (messageRecord.isExpirationTimerUpdate()) setTimerRecord(messageRecord);
+    else if (messageRecord.isEndSession())            setEndSessionRecord(messageRecord);
+    else if (messageRecord.isIdentityUpdate())        setIdentityRecord(messageRecord);
+    else if (messageRecord.isIdentityVerified() ||
+             messageRecord.isIdentityDefault())       setIdentityVerifyUpdate(messageRecord);
+    else                                              throw new AssertionError("Neither group nor log nor joined.");
+
+    if (batchSelected.contains(messageRecord)) setSelected(true);
+    else                                       setSelected(false);
+  }
+
+  private void setCallRecord(MessageRecord messageRecord) {
+    if      (messageRecord.isIncomingCall()) icon.setImageResource(R.drawable.ic_call_received_grey600_24dp);
+    else if (messageRecord.isOutgoingCall()) icon.setImageResource(R.drawable.ic_call_made_grey600_24dp);
+    else                                     icon.setImageResource(R.drawable.ic_call_missed_grey600_24dp);
+
+    body.setText(messageRecord.getDisplayBody());
+    date.setText(DateUtils.getExtendedRelativeTimeSpanString(getContext(), locale, messageRecord.getDateReceived()));
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(View.VISIBLE);
+  }
+
+  private void setTimerRecord(final MessageRecord messageRecord) {
+    if (messageRecord.getExpiresIn() > 0) {
+      icon.setImageResource(R.drawable.ic_timer);
+      icon.setColorFilter(new PorterDuffColorFilter(Color.parseColor("#757575"), PorterDuff.Mode.MULTIPLY));
+    } else {
+      icon.setImageResource(R.drawable.ic_timer_disabled);
+      icon.setColorFilter(new PorterDuffColorFilter(Color.parseColor("#757575"), PorterDuff.Mode.MULTIPLY));
+    }
+
+    title.setText(ExpirationUtil.getExpirationDisplayValue(getContext(), (int)(messageRecord.getExpiresIn() / 1000)));
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(VISIBLE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+
+  private void setIdentityRecord(final MessageRecord messageRecord) {
+    icon.setImageResource(R.drawable.ic_security_white_24dp);
+    icon.setColorFilter(new PorterDuffColorFilter(Color.parseColor("#757575"), PorterDuff.Mode.MULTIPLY));
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+
+  private void setIdentityVerifyUpdate(final MessageRecord messageRecord) {
+    if (messageRecord.isIdentityVerified()) icon.setImageResource(R.drawable.ic_check_white_24dp);
+    else                                    icon.setImageResource(R.drawable.ic_info_outline_white_24dp);
+
+    icon.setColorFilter(new PorterDuffColorFilter(Color.parseColor("#757575"), PorterDuff.Mode.MULTIPLY));
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+
+  private void setGroupRecord(MessageRecord messageRecord) {
+    icon.setImageResource(R.drawable.ic_group_grey600_24dp);
+    icon.clearColorFilter();
+
+    GroupUtil.getDescription(getContext(), messageRecord.getBody()).addListener(this);
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+
+  private void setJoinedRecord(MessageRecord messageRecord) {
+    icon.setImageResource(R.drawable.ic_favorite_grey600_24dp);
+    icon.clearColorFilter();
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+
+  private void setEndSessionRecord(MessageRecord messageRecord) {
+    icon.setImageResource(R.drawable.ic_refresh_white_24dp);
+    icon.setColorFilter(new PorterDuffColorFilter(Color.parseColor("#757575"), PorterDuff.Mode.MULTIPLY));
+    body.setText(messageRecord.getDisplayBody());
+
+    title.setVisibility(GONE);
+    body.setVisibility(VISIBLE);
+    date.setVisibility(GONE);
+  }
+  
+  @Override
+  public void onModified(Recipient recipient) {
+    Util.runOnMain(() -> bind(messageRecord, locale));
+  }
+
+  @Override
+  public void setOnClickListener(View.OnClickListener l) {
+    super.setOnClickListener(new InternalClickListener(l));
+  }
+
+  @Override
+  public void unbind() {
+    if (sender != null) {
+      sender.removeListener(this);
+    }
+  }
+
+  private class InternalClickListener implements View.OnClickListener {
+
+    @Nullable private final View.OnClickListener parent;
+
+    InternalClickListener(@Nullable View.OnClickListener parent) {
+      this.parent = parent;
+    }
+
+    @Override
+    public void onClick(View v) {
+      if ((!messageRecord.isIdentityUpdate()  &&
+           !messageRecord.isIdentityDefault() &&
+           !messageRecord.isIdentityVerified()) ||
+          !batchSelected.isEmpty())
+      {
+        if (parent != null) parent.onClick(v);
+        return;
+      }
+
+      final Recipient sender = ConversationUpdateItem.this.sender;
+
+      IdentityUtil.getRemoteIdentityKey(getContext(), sender).addListener(new ListenableFuture.Listener<Optional<IdentityRecord>>() {
+        @Override
+        public void onSuccess(Optional<IdentityRecord> result) {
+          if (result.isPresent()) {
+            Intent intent = new Intent(getContext(), VerifyIdentityActivity.class);
+            intent.putExtra(VerifyIdentityActivity.ADDRESS_EXTRA, sender.getAddress());
+            intent.putExtra(VerifyIdentityActivity.IDENTITY_EXTRA, new IdentityKeyParcelable(result.get().getIdentityKey()));
+            intent.putExtra(VerifyIdentityActivity.VERIFIED_EXTRA, result.get().getVerifiedStatus() == IdentityDatabase.VerifiedStatus.VERIFIED);
+
+            getContext().startActivity(intent);
+          }
+        }
+
+        @Override
+        public void onFailure(ExecutionException e) {
+          Log.w(TAG, e);
+        }
+      });
+    }
+  }
+
+}