1package eu.siacs.conversations.ui.adapter;
   2
   3import android.Manifest;
   4import android.app.Activity;
   5import android.content.Intent;
   6import android.content.pm.PackageManager;
   7import android.graphics.PorterDuff;
   8import android.graphics.drawable.Drawable;
   9import android.content.res.ColorStateList;
  10import android.graphics.Typeface;
  11import android.net.Uri;
  12import android.os.AsyncTask;
  13import android.os.Build;
  14import android.preference.PreferenceManager;
  15import android.text.Editable;
  16import android.text.Spanned;
  17import android.text.Spannable;
  18import android.text.SpannableString;
  19import android.text.SpannableStringBuilder;
  20import android.text.style.ImageSpan;
  21import android.text.style.ClickableSpan;
  22import android.text.format.DateUtils;
  23import android.text.style.ForegroundColorSpan;
  24import android.text.style.RelativeSizeSpan;
  25import android.text.style.StyleSpan;
  26import android.text.style.URLSpan;
  27import android.util.DisplayMetrics;
  28import android.util.LruCache;
  29import android.view.accessibility.AccessibilityEvent;
  30import android.view.Gravity;
  31import android.view.MotionEvent;
  32import android.view.View;
  33import android.view.ViewGroup;
  34import android.view.WindowManager;
  35import android.widget.ArrayAdapter;
  36import android.widget.ImageView;
  37import android.widget.LinearLayout;
  38import android.widget.ListAdapter;
  39import android.widget.ListView;
  40import android.widget.RelativeLayout;
  41import android.widget.TextView;
  42import android.widget.Toast;
  43
  44import androidx.annotation.AttrRes;
  45import androidx.annotation.ColorInt;
  46import androidx.annotation.DrawableRes;
  47import androidx.annotation.NonNull;
  48import androidx.annotation.Nullable;
  49import androidx.core.app.ActivityCompat;
  50import androidx.core.content.ContextCompat;
  51import androidx.core.content.res.ResourcesCompat;
  52import androidx.core.widget.ImageViewCompat;
  53
  54import com.google.android.material.imageview.ShapeableImageView;
  55import com.google.android.material.shape.CornerFamily;
  56import com.google.android.material.shape.ShapeAppearanceModel;
  57
  58import com.cheogram.android.BobTransfer;
  59import com.cheogram.android.MessageTextActionModeCallback;
  60import com.cheogram.android.SwipeDetector;
  61import com.cheogram.android.WebxdcPage;
  62import com.cheogram.android.WebxdcUpdate;
  63
  64import com.google.android.material.button.MaterialButton;
  65import com.google.android.material.color.MaterialColors;
  66import com.google.common.base.Joiner;
  67import com.google.common.base.Strings;
  68import com.google.common.collect.ImmutableList;
  69
  70import com.lelloman.identicon.view.GithubIdenticonView;
  71
  72import io.ipfs.cid.Cid;
  73
  74import java.io.IOException;
  75import java.net.URI;
  76import java.net.URISyntaxException;
  77import java.security.NoSuchAlgorithmException;
  78import java.util.HashMap;
  79import java.util.List;
  80import java.util.Map;
  81import java.util.Locale;
  82import java.util.regex.Matcher;
  83import java.util.regex.Pattern;
  84
  85import me.saket.bettermovementmethod.BetterLinkMovementMethod;
  86
  87import net.fellbaum.jemoji.EmojiManager;
  88
  89import eu.siacs.conversations.AppSettings;
  90import eu.siacs.conversations.Config;
  91import eu.siacs.conversations.R;
  92import eu.siacs.conversations.crypto.axolotl.FingerprintStatus;
  93import eu.siacs.conversations.entities.Account;
  94import eu.siacs.conversations.entities.Contact;
  95import eu.siacs.conversations.entities.Conversation;
  96import eu.siacs.conversations.entities.Conversational;
  97import eu.siacs.conversations.entities.DownloadableFile;
  98import eu.siacs.conversations.entities.Message.FileParams;
  99import eu.siacs.conversations.entities.Message;
 100import eu.siacs.conversations.entities.MucOptions;
 101import eu.siacs.conversations.entities.Roster;
 102import eu.siacs.conversations.entities.RtpSessionStatus;
 103import eu.siacs.conversations.entities.Transferable;
 104import eu.siacs.conversations.persistance.FileBackend;
 105import eu.siacs.conversations.services.MessageArchiveService;
 106import eu.siacs.conversations.services.NotificationService;
 107import eu.siacs.conversations.ui.Activities;
 108import eu.siacs.conversations.ui.ConversationFragment;
 109import eu.siacs.conversations.ui.ConversationsActivity;
 110import eu.siacs.conversations.ui.XmppActivity;
 111import eu.siacs.conversations.ui.service.AudioPlayer;
 112import eu.siacs.conversations.ui.text.DividerSpan;
 113import eu.siacs.conversations.ui.text.QuoteSpan;
 114import eu.siacs.conversations.ui.util.Attachment;
 115import eu.siacs.conversations.ui.util.AvatarWorkerTask;
 116import eu.siacs.conversations.ui.util.MyLinkify;
 117import eu.siacs.conversations.ui.util.QuoteHelper;
 118import eu.siacs.conversations.ui.util.ShareUtil;
 119import eu.siacs.conversations.ui.util.ViewUtil;
 120import eu.siacs.conversations.utils.CryptoHelper;
 121import eu.siacs.conversations.utils.Emoticons;
 122import eu.siacs.conversations.utils.GeoHelper;
 123import eu.siacs.conversations.utils.MessageUtils;
 124import eu.siacs.conversations.utils.StylingHelper;
 125import eu.siacs.conversations.utils.TimeFrameUtils;
 126import eu.siacs.conversations.utils.UIHelper;
 127import eu.siacs.conversations.xmpp.Jid;
 128import eu.siacs.conversations.xmpp.mam.MamReference;
 129import eu.siacs.conversations.xml.Element;
 130
 131import java.net.URI;
 132import java.util.Arrays;
 133import java.util.Collection;
 134import java.util.List;
 135import java.util.Locale;
 136import java.util.regex.Matcher;
 137import java.util.regex.Pattern;
 138
 139public class MessageAdapter extends ArrayAdapter<Message> {
 140
 141    public static final String DATE_SEPARATOR_BODY = "DATE_SEPARATOR";
 142    private static final int SENT = 0;
 143    private static final int RECEIVED = 1;
 144    private static final int STATUS = 2;
 145    private static final int DATE_SEPARATOR = 3;
 146    private static final int RTP_SESSION = 4;
 147    private final XmppActivity activity;
 148    private final AudioPlayer audioPlayer;
 149    private List<String> highlightedTerm = null;
 150    private final DisplayMetrics metrics;
 151    private ConversationFragment mConversationFragment = null;
 152    private OnContactPictureClicked mOnContactPictureClickedListener;
 153    private OnContactPictureClicked mOnMessageBoxClickedListener;
 154    private OnContactPictureClicked mOnMessageBoxSwipedListener;
 155    private OnContactPictureLongClicked mOnContactPictureLongClickedListener;
 156    private OnInlineImageLongClicked mOnInlineImageLongClickedListener;
 157    private boolean mUseGreenBackground = false;
 158    private BubbleDesign bubbleDesign = new BubbleDesign(false, false);
 159    private final boolean mForceNames;
 160    private final Map<String, WebxdcUpdate> lastWebxdcUpdate = new HashMap<>();
 161    private String selectionUuid = null;
 162
 163    public MessageAdapter(
 164            final XmppActivity activity, final List<Message> messages, final boolean forceNames) {
 165        super(activity, 0, messages);
 166        this.audioPlayer = new AudioPlayer(this);
 167        this.activity = activity;
 168        metrics = getContext().getResources().getDisplayMetrics();
 169        updatePreferences();
 170        this.mForceNames = forceNames;
 171    }
 172
 173    public MessageAdapter(final XmppActivity activity, final List<Message> messages) {
 174        this(activity, messages, false);
 175    }
 176
 177    private static void resetClickListener(View... views) {
 178        for (View view : views) {
 179            if (view != null) view.setOnClickListener(null);
 180        }
 181    }
 182
 183    public void flagScreenOn() {
 184        activity.getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 185    }
 186
 187    public void flagScreenOff() {
 188        activity.getWindow().clearFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 189    }
 190
 191    public void setVolumeControl(final int stream) {
 192        activity.setVolumeControlStream(stream);
 193    }
 194
 195    public void setOnContactPictureClicked(OnContactPictureClicked listener) {
 196        this.mOnContactPictureClickedListener = listener;
 197    }
 198
 199    public void setOnMessageBoxClicked(OnContactPictureClicked listener) {
 200        this.mOnMessageBoxClickedListener = listener;
 201    }
 202
 203    public void setOnMessageBoxSwiped(OnContactPictureClicked listener) {
 204        this.mOnMessageBoxSwipedListener = listener;
 205    }
 206
 207    public void setConversationFragment(ConversationFragment frag) {
 208        mConversationFragment = frag;
 209    }
 210
 211    public void quoteText(String text) {
 212        if (mConversationFragment != null) mConversationFragment.quoteText(text);
 213    }
 214
 215    public boolean hasSelection() {
 216        return selectionUuid != null;
 217    }
 218
 219    public Activity getActivity() {
 220        return activity;
 221    }
 222
 223    public void setOnContactPictureLongClicked(OnContactPictureLongClicked listener) {
 224        this.mOnContactPictureLongClickedListener = listener;
 225    }
 226
 227    public void setOnInlineImageLongClicked(OnInlineImageLongClicked listener) {
 228        this.mOnInlineImageLongClickedListener = listener;
 229    }
 230
 231    @Override
 232    public int getViewTypeCount() {
 233        return 5;
 234    }
 235
 236    private int getItemViewType(Message message) {
 237        if (message.getType() == Message.TYPE_STATUS) {
 238            if (DATE_SEPARATOR_BODY.equals(message.getBody())) {
 239                return DATE_SEPARATOR;
 240            } else {
 241                return STATUS;
 242            }
 243        } else if (message.getType() == Message.TYPE_RTP_SESSION) {
 244            return RTP_SESSION;
 245        } else if (message.getStatus() <= Message.STATUS_RECEIVED) {
 246            return RECEIVED;
 247        } else {
 248            return SENT;
 249        }
 250    }
 251
 252    @Override
 253    public int getItemViewType(int position) {
 254        return this.getItemViewType(getItem(position));
 255    }
 256
 257    private void displayStatus(
 258            final ViewHolder viewHolder,
 259            final Message message,
 260            final int type,
 261            final BubbleColor bubbleColor) {
 262        final int mergedStatus = message.getMergedStatus();
 263        final boolean error;
 264        if (viewHolder.indicatorReceived != null) {
 265            viewHolder.indicatorReceived.setVisibility(View.GONE);
 266        }
 267        final Transferable transferable = message.getTransferable();
 268        final boolean multiReceived =
 269                message.getConversation().getMode() == Conversation.MODE_MULTI
 270                        && mergedStatus <= Message.STATUS_RECEIVED;
 271        final String fileSize;
 272        if (message.isFileOrImage()
 273                || transferable != null
 274                || MessageUtils.unInitiatedButKnownSize(message)) {
 275            final FileParams params = message.getFileParams();
 276            fileSize = params.size != null ? UIHelper.filesizeToString(params.size) : null;
 277            if (message.getStatus() == Message.STATUS_SEND_FAILED
 278                    || (transferable != null
 279                            && (transferable.getStatus() == Transferable.STATUS_FAILED
 280                                    || transferable.getStatus()
 281                                            == Transferable.STATUS_CANCELLED))) {
 282                error = true;
 283            } else {
 284                error = message.getStatus() == Message.STATUS_SEND_FAILED;
 285            }
 286        } else {
 287            fileSize = null;
 288            error = message.getStatus() == Message.STATUS_SEND_FAILED;
 289        }
 290        if (type == SENT) {
 291            final @DrawableRes Integer receivedIndicator =
 292                    getMessageStatusAsDrawable(message, mergedStatus);
 293            if (receivedIndicator == null) {
 294                viewHolder.indicatorReceived.setVisibility(View.INVISIBLE);
 295            } else {
 296                viewHolder.indicatorReceived.setImageResource(receivedIndicator);
 297                if (mergedStatus == Message.STATUS_SEND_FAILED) {
 298                    setImageTintError(viewHolder.indicatorReceived);
 299                } else {
 300                    setImageTint(viewHolder.indicatorReceived, bubbleColor);
 301                }
 302                viewHolder.indicatorReceived.setVisibility(View.VISIBLE);
 303            }
 304        }
 305        final var additionalStatusInfo = getAdditionalStatusInfo(message, mergedStatus);
 306
 307        if (error && type == SENT) {
 308            viewHolder.time.setTextColor(
 309                    MaterialColors.getColor(
 310                            viewHolder.time, com.google.android.material.R.attr.colorError));
 311        } else {
 312            setTextColor(viewHolder.time, bubbleColor);
 313        }
 314        setTextColor(viewHolder.subject, bubbleColor);
 315        if (message.getEncryption() == Message.ENCRYPTION_NONE) {
 316            viewHolder.indicator.setVisibility(View.GONE);
 317        } else {
 318            boolean verified = false;
 319            if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL) {
 320                final FingerprintStatus status =
 321                        message.getConversation()
 322                                .getAccount()
 323                                .getAxolotlService()
 324                                .getFingerprintTrust(message.getFingerprint());
 325                if (status != null && status.isVerified()) {
 326                    verified = true;
 327                }
 328            }
 329            if (verified) {
 330                viewHolder.indicator.setImageResource(R.drawable.ic_verified_user_24dp);
 331            } else {
 332                viewHolder.indicator.setImageResource(R.drawable.ic_lock_24dp);
 333            }
 334            if (error && type == SENT) {
 335                setImageTintError(viewHolder.indicator);
 336            } else {
 337                setImageTint(viewHolder.indicator, bubbleColor);
 338            }
 339            viewHolder.indicator.setVisibility(View.VISIBLE);
 340        }
 341
 342        if (viewHolder.edit_indicator != null) {
 343            if (message.edited()) {
 344                viewHolder.edit_indicator.setVisibility(View.VISIBLE);
 345                if (error && type == SENT) {
 346                    setImageTintError(viewHolder.edit_indicator);
 347                } else {
 348                    setImageTint(viewHolder.edit_indicator, bubbleColor);
 349                }
 350            } else {
 351                viewHolder.edit_indicator.setVisibility(View.GONE);
 352            }
 353        }
 354
 355        final String formattedTime =
 356                UIHelper.readableTimeDifferenceFull(getContext(), message.getMergedTimeSent());
 357        final String bodyLanguage = message.getBodyLanguage();
 358        final ImmutableList.Builder<String> timeInfoBuilder = new ImmutableList.Builder<>();
 359        if (message.getStatus() <= Message.STATUS_RECEIVED) {
 360            timeInfoBuilder.add(formattedTime);
 361            if (fileSize != null) {
 362                timeInfoBuilder.add(fileSize);
 363            }
 364            if (mForceNames || multiReceived || (message.getTrueCounterpart() != null && message.getContact() != null)) {
 365                final String displayName = UIHelper.getMessageDisplayName(message);
 366                if (displayName != null) {
 367                    timeInfoBuilder.add(displayName);
 368                }
 369            }
 370            if (bodyLanguage != null) {
 371                timeInfoBuilder.add(bodyLanguage.toUpperCase(Locale.US));
 372            }
 373        } else {
 374            if (bodyLanguage != null) {
 375                timeInfoBuilder.add(bodyLanguage.toUpperCase(Locale.US));
 376            }
 377            if (fileSize != null) {
 378                timeInfoBuilder.add(fileSize);
 379            }
 380            // for space reasons we display only 'additional status info' (send progress or concrete
 381            // failure reason) or the time
 382            if (additionalStatusInfo != null) {
 383                timeInfoBuilder.add(additionalStatusInfo);
 384            } else {
 385                timeInfoBuilder.add(formattedTime);
 386            }
 387        }
 388        final var timeInfo = timeInfoBuilder.build();
 389        viewHolder.time.setText(Joiner.on(" \u00B7 ").join(timeInfo));
 390    }
 391
 392    public static @DrawableRes Integer getMessageStatusAsDrawable(
 393            final Message message, final int status) {
 394        final var transferable = message.getTransferable();
 395        return switch (status) {
 396            case Message.STATUS_WAITING -> R.drawable.ic_more_horiz_24dp;
 397            case Message.STATUS_UNSEND -> transferable == null ? null : R.drawable.ic_upload_24dp;
 398            case Message.STATUS_SEND -> R.drawable.ic_done_24dp;
 399            case Message.STATUS_SEND_RECEIVED, Message.STATUS_SEND_DISPLAYED -> R.drawable
 400                    .ic_done_all_24dp;
 401            case Message.STATUS_SEND_FAILED -> {
 402                final String errorMessage = message.getErrorMessage();
 403                if (Message.ERROR_MESSAGE_CANCELLED.equals(errorMessage)) {
 404                    yield R.drawable.ic_cancel_24dp;
 405                } else {
 406                    yield R.drawable.ic_error_24dp;
 407                }
 408            }
 409            case Message.STATUS_OFFERED -> R.drawable.ic_p2p_24dp;
 410            default -> null;
 411        };
 412    }
 413
 414    @Nullable
 415    private String getAdditionalStatusInfo(final Message message, final int mergedStatus) {
 416        final String additionalStatusInfo;
 417        if (mergedStatus == Message.STATUS_SEND_FAILED) {
 418            final String errorMessage = Strings.nullToEmpty(message.getErrorMessage());
 419            final String[] errorParts = errorMessage.split("\\u001f", 2);
 420            if (errorParts.length == 2 && errorParts[0].equals("file-too-large")) {
 421                additionalStatusInfo = getContext().getString(R.string.file_too_large);
 422            } else {
 423                additionalStatusInfo = null;
 424            }
 425        } else if (mergedStatus == Message.STATUS_UNSEND) {
 426            final var transferable = message.getTransferable();
 427            if (transferable == null) {
 428                return null;
 429            }
 430            return getContext().getString(R.string.sending_file, transferable.getProgress());
 431        } else {
 432            additionalStatusInfo = null;
 433        }
 434        return additionalStatusInfo;
 435    }
 436
 437    private void displayInfoMessage(
 438            ViewHolder viewHolder, CharSequence text, final BubbleColor bubbleColor) {
 439        viewHolder.download_button.setVisibility(View.GONE);
 440        viewHolder.audioPlayer.setVisibility(View.GONE);
 441        viewHolder.image.setVisibility(View.GONE);
 442        viewHolder.messageBody.setVisibility(View.VISIBLE);
 443        viewHolder.messageBody.setText(text);
 444        viewHolder.messageBody.setTextColor(
 445                bubbleToOnSurfaceVariant(viewHolder.messageBody, bubbleColor));
 446        viewHolder.messageBody.setTextIsSelectable(false);
 447    }
 448
 449    private void displayEmojiMessage(
 450            final ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, int type) {
 451        displayTextMessage(viewHolder, message, bubbleColor, type);
 452        viewHolder.download_button.setVisibility(View.GONE);
 453        viewHolder.audioPlayer.setVisibility(View.GONE);
 454        viewHolder.image.setVisibility(View.GONE);
 455        viewHolder.messageBody.setVisibility(View.VISIBLE);
 456        setTextColor(viewHolder.messageBody, bubbleColor);
 457        final var body = getSpannableBody(message);
 458        ImageSpan[] imageSpans = body.getSpans(0, body.length(), ImageSpan.class);
 459        float size = imageSpans.length == 1 || Emoticons.isEmoji(body.toString()) ? 3.0f : 2.0f;
 460        body.setSpan(
 461                new RelativeSizeSpan(size), 0, body.length(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 462        viewHolder.messageBody.setText(body);
 463    }
 464
 465    private void applyQuoteSpan(
 466            final TextView textView,
 467            Editable body,
 468            int start,
 469            int end,
 470            final BubbleColor bubbleColor,
 471            final boolean makeEdits) {
 472        if (makeEdits && start > 1 && !"\n\n".equals(body.subSequence(start - 2, start).toString())) {
 473            body.insert(start++, "\n");
 474            body.setSpan(
 475                    new DividerSpan(false), start - 2, start, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 476            end++;
 477        }
 478        if (makeEdits && end < body.length() - 1 && !"\n\n".equals(body.subSequence(end, end + 2).toString())) {
 479            body.insert(end, "\n");
 480            body.setSpan(
 481                new DividerSpan(false),
 482                end,
 483                end + ("\n".equals(body.subSequence(end + 1, end + 2).toString()) ? 2 : 1),
 484                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE
 485            );
 486        }
 487        final DisplayMetrics metrics = getContext().getResources().getDisplayMetrics();
 488        body.setSpan(
 489                new QuoteSpan(bubbleToOnSurfaceVariant(textView, bubbleColor), metrics),
 490                start,
 491                end,
 492                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 493    }
 494
 495    public boolean handleTextQuotes(final TextView textView, final Editable body) {
 496        return handleTextQuotes(textView, body, true);
 497    }
 498
 499    public boolean handleTextQuotes(final TextView textView, final Editable body, final boolean deleteMarkers) {
 500        final boolean colorfulBackground = this.bubbleDesign.colorfulChatBubbles;
 501        final BubbleColor bubbleColor = colorfulBackground ? (deleteMarkers ? BubbleColor.SECONDARY : BubbleColor.TERTIARY) : BubbleColor.SURFACE;
 502        return handleTextQuotes(textView, body, bubbleColor, deleteMarkers);
 503    }
 504
 505    /**
 506     * Applies QuoteSpan to group of lines which starts with > or » characters. Appends likebreaks
 507     * and applies DividerSpan to them to show a padding between quote and text.
 508     */
 509    public boolean handleTextQuotes(
 510            final TextView textView,
 511            final Editable body,
 512            final BubbleColor bubbleColor,
 513            final boolean deleteMarkers) {
 514        boolean startsWithQuote = false;
 515        int quoteDepth = 1;
 516        while (QuoteHelper.bodyContainsQuoteStart(body) && quoteDepth <= Config.QUOTE_MAX_DEPTH) {
 517            char previous = '\n';
 518            int lineStart = -1;
 519            int lineTextStart = -1;
 520            int quoteStart = -1;
 521            int skipped = 0;
 522            for (int i = 0; i <= body.length(); i++) {
 523                if (!deleteMarkers && QuoteHelper.isRelativeSizeSpanned(body, i)) {
 524                    skipped++;
 525                    continue;
 526                }
 527                char current = body.length() > i ? body.charAt(i) : '\n';
 528                if (lineStart == -1) {
 529                    if (previous == '\n') {
 530                        if (i < body.length() && QuoteHelper.isPositionQuoteStart(body, i)) {
 531                            // Line start with quote
 532                            lineStart = i;
 533                            if (quoteStart == -1) quoteStart = i - skipped;
 534                            if (i == 0) startsWithQuote = true;
 535                        } else if (quoteStart >= 0) {
 536                            // Line start without quote, apply spans there
 537                            applyQuoteSpan(textView, body, quoteStart, i - 1, bubbleColor, deleteMarkers);
 538                            quoteStart = -1;
 539                        }
 540                    }
 541                } else {
 542                    // Remove extra spaces between > and first character in the line
 543                    // > character will be removed too
 544                    if (current != ' ' && lineTextStart == -1) {
 545                        lineTextStart = i;
 546                    }
 547                    if (current == '\n') {
 548                        if (deleteMarkers) {
 549                            i -= lineTextStart - lineStart;
 550                            body.delete(lineStart, lineTextStart);
 551                            if (i == lineStart) {
 552                                // Avoid empty lines because span over empty line can be hidden
 553                                body.insert(i++, " ");
 554                            }
 555                        } else {
 556                            body.setSpan(new RelativeSizeSpan(i - (lineTextStart - lineStart) == lineStart ? 1 : 0), lineStart, lineTextStart, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE | StylingHelper.XHTML_REMOVE << Spanned.SPAN_USER_SHIFT);
 557                        }
 558                        lineStart = -1;
 559                        lineTextStart = -1;
 560                    }
 561                }
 562                previous = current;
 563                skipped = 0;
 564            }
 565            if (quoteStart >= 0) {
 566                // Apply spans to finishing open quote
 567                applyQuoteSpan(textView, body, quoteStart, body.length(), bubbleColor, deleteMarkers);
 568            }
 569            quoteDepth++;
 570        }
 571        return startsWithQuote;
 572    }
 573
 574    private SpannableStringBuilder getSpannableBody(final Message message) {
 575        Drawable fallbackImg = ResourcesCompat.getDrawable(activity.getResources(), R.drawable.ic_photo_24dp, null);
 576        return message.getMergedBody((cid) -> {
 577            try {
 578                DownloadableFile f = activity.xmppConnectionService.getFileForCid(cid);
 579                if (f == null || !f.canRead()) {
 580                    if (!message.trusted() && !message.getConversation().canInferPresence()) return null;
 581
 582                    try {
 583                        new BobTransfer(BobTransfer.uri(cid), message.getConversation().getAccount(), message.getCounterpart(), activity.xmppConnectionService).start();
 584                    } catch (final NoSuchAlgorithmException | URISyntaxException e) { }
 585                    return null;
 586                }
 587
 588                Drawable d = activity.xmppConnectionService.getFileBackend().getThumbnail(f, activity.getResources(), (int) (metrics.density * 288), true);
 589                if (d == null) {
 590                    new ThumbnailTask().execute(f);
 591                }
 592                return d;
 593            } catch (final IOException e) {
 594                return null;
 595            }
 596        }, fallbackImg);
 597    }
 598
 599    private void displayTextMessage(
 600            final ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 601        viewHolder.download_button.setVisibility(View.GONE);
 602        viewHolder.image.setVisibility(View.GONE);
 603        viewHolder.audioPlayer.setVisibility(View.GONE);
 604        viewHolder.messageBody.setVisibility(View.VISIBLE);
 605        setTextColor(viewHolder.messageBody, bubbleColor);
 606        setTextSize(viewHolder.messageBody, this.bubbleDesign.largeFont);
 607
 608        final ViewGroup.LayoutParams layoutParams = viewHolder.messageBody.getLayoutParams();
 609        layoutParams.width = ViewGroup.LayoutParams.WRAP_CONTENT;
 610        viewHolder.messageBody.setLayoutParams(layoutParams);
 611
 612        viewHolder.messageBody.setTypeface(null, Typeface.NORMAL);
 613
 614        if (message.getBody() != null && !message.getBody().equals("")) {
 615            viewHolder.messageBody.setTextIsSelectable(true);
 616            viewHolder.messageBody.setVisibility(View.VISIBLE);
 617            final String nick = UIHelper.getMessageDisplayName(message);
 618            SpannableStringBuilder body = getSpannableBody(message);
 619            final var processMarkup = body.getSpans(0, body.length(), Message.PlainTextSpan.class).length > 0;
 620            boolean hasMeCommand = message.hasMeCommand();
 621            if (hasMeCommand) {
 622                body = body.replace(0, Message.ME_COMMAND.length(), nick + " ");
 623            }
 624            if (body.length() > Config.MAX_DISPLAY_MESSAGE_CHARS) {
 625                body = new SpannableStringBuilder(body, 0, Config.MAX_DISPLAY_MESSAGE_CHARS);
 626                body.append("\u2026");
 627            }
 628            Message.MergeSeparator[] mergeSeparators =
 629                    body.getSpans(0, body.length(), Message.MergeSeparator.class);
 630            for (Message.MergeSeparator mergeSeparator : mergeSeparators) {
 631                int start = body.getSpanStart(mergeSeparator);
 632                int end = body.getSpanEnd(mergeSeparator);
 633                body.setSpan(new DividerSpan(true), start, end, Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 634            }
 635            for (final android.text.style.QuoteSpan quote : body.getSpans(0, body.length(), android.text.style.QuoteSpan.class)) {
 636                int start = body.getSpanStart(quote);
 637                int end = body.getSpanEnd(quote);
 638                body.removeSpan(quote);
 639                applyQuoteSpan(viewHolder.messageBody, body, start, end, bubbleColor, true);
 640            }
 641            boolean startsWithQuote = processMarkup ? handleTextQuotes(viewHolder.messageBody, body, bubbleColor, true) : false;
 642            if (!message.isPrivateMessage()) {
 643                if (hasMeCommand) {
 644                    body.setSpan(
 645                            new StyleSpan(Typeface.BOLD_ITALIC),
 646                            0,
 647                            nick.length(),
 648                            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 649                }
 650            } else {
 651                String privateMarker;
 652                if (message.getStatus() <= Message.STATUS_RECEIVED) {
 653                    privateMarker = activity.getString(R.string.private_message);
 654                } else {
 655                    Jid cp = message.getCounterpart();
 656                    privateMarker =
 657                            activity.getString(
 658                                    R.string.private_message_to,
 659                                    Strings.nullToEmpty(cp == null ? null : cp.getResource()));
 660                }
 661                body.insert(0, privateMarker);
 662                int privateMarkerIndex = privateMarker.length();
 663                if (startsWithQuote) {
 664                    body.insert(privateMarkerIndex, "\n\n");
 665                    body.setSpan(
 666                            new DividerSpan(false),
 667                            privateMarkerIndex,
 668                            privateMarkerIndex + 2,
 669                            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 670                } else {
 671                    body.insert(privateMarkerIndex, " ");
 672                }
 673                body.setSpan(
 674                        new ForegroundColorSpan(
 675                                bubbleToOnSurfaceVariant(viewHolder.messageBody, bubbleColor)),
 676                        0,
 677                        privateMarkerIndex,
 678                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 679                body.setSpan(
 680                        new StyleSpan(Typeface.BOLD),
 681                        0,
 682                        privateMarkerIndex,
 683                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 684                if (hasMeCommand) {
 685                    body.setSpan(
 686                            new StyleSpan(Typeface.BOLD_ITALIC),
 687                            privateMarkerIndex + 1,
 688                            privateMarkerIndex + 1 + nick.length(),
 689                            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 690                }
 691            }
 692            if (message.getConversation().getMode() == Conversation.MODE_MULTI
 693                    && message.getStatus() == Message.STATUS_RECEIVED) {
 694                if (message.getConversation() instanceof Conversation conversation) {
 695                    Pattern pattern =
 696                            NotificationService.generateNickHighlightPattern(
 697                                    conversation.getMucOptions().getActualNick());
 698                    Matcher matcher = pattern.matcher(body);
 699                    while (matcher.find()) {
 700                        body.setSpan(
 701                                new StyleSpan(Typeface.BOLD),
 702                                matcher.start(),
 703                                matcher.end(),
 704                                Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 705                    }
 706
 707                    pattern = NotificationService.generateNickHighlightPattern(conversation.getMucOptions().getActualName());
 708                    matcher = pattern.matcher(body);
 709                    while (matcher.find()) {
 710                        body.setSpan(new StyleSpan(Typeface.BOLD), matcher.start(), matcher.end(), Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 711                    }
 712                }
 713            }
 714            for (final var emoji : EmojiManager.extractEmojisInOrderWithIndex(body.toString())) {
 715                    body.setSpan(
 716                            new RelativeSizeSpan(1.2f),
 717                            emoji.getCharIndex(),
 718                            emoji.getCharIndex() + emoji.getEmoji().getEmoji().length(),
 719                            Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 720            }
 721
 722            if (processMarkup) StylingHelper.format(body, viewHolder.messageBody.getCurrentTextColor());
 723            MyLinkify.addLinks(body, message.getConversation().getAccount(), message.getConversation().getJid());
 724            if (highlightedTerm != null) {
 725                StylingHelper.highlight(viewHolder.messageBody, body, highlightedTerm);
 726            }
 727
 728            viewHolder.messageBody.setAutoLinkMask(0);
 729            viewHolder.messageBody.setText(body);
 730            BetterLinkMovementMethod method = new BetterLinkMovementMethod() {
 731                @Override
 732                protected void dispatchUrlLongClick(TextView tv, ClickableSpan span) {
 733                    if (span instanceof URLSpan || mOnInlineImageLongClickedListener == null) {
 734                        tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 735                        super.dispatchUrlLongClick(tv, span);
 736                        return;
 737                    }
 738
 739                    Spannable body = (Spannable) tv.getText();
 740                    ImageSpan[] imageSpans = body.getSpans(body.getSpanStart(span), body.getSpanEnd(span), ImageSpan.class);
 741                    if (imageSpans.length > 0) {
 742                        Uri uri = Uri.parse(imageSpans[0].getSource());
 743                        Cid cid = BobTransfer.cid(uri);
 744                        if (cid == null) return;
 745                        if (mOnInlineImageLongClickedListener.onInlineImageLongClicked(cid)) {
 746                            tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 747                        }
 748                    }
 749                }
 750            };
 751            method.setOnLinkLongClickListener((tv, url) -> {
 752                tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 753                ShareUtil.copyLinkToClipboard(activity, url);
 754                return true;
 755            });
 756            viewHolder.messageBody.setMovementMethod(method);
 757        } else {
 758            viewHolder.messageBody.setText("");
 759            viewHolder.messageBody.setTextIsSelectable(false);
 760            toggleWhisperInfo(viewHolder, message, bubbleColor);
 761        }
 762    }
 763
 764    private void displayDownloadableMessage(
 765            ViewHolder viewHolder,
 766            final Message message,
 767            String text,
 768            final BubbleColor bubbleColor, final int type) {
 769        displayTextMessage(viewHolder, message, bubbleColor, type);
 770        viewHolder.image.setVisibility(View.GONE);
 771        List<Element> thumbs = message.getFileParams() != null ? message.getFileParams().getThumbnails() : null;
 772        if (thumbs != null && !thumbs.isEmpty()) {
 773            for (Element thumb : thumbs) {
 774                Uri uri = Uri.parse(thumb.getAttribute("uri"));
 775                if (uri.getScheme().equals("data")) {
 776                    String[] parts = uri.getSchemeSpecificPart().split(",", 2);
 777                    parts = parts[0].split(";");
 778                    if (!parts[0].equals("image/blurhash") && !parts[0].equals("image/thumbhash") && !parts[0].equals("image/jpeg") && !parts[0].equals("image/png") && !parts[0].equals("image/webp") && !parts[0].equals("image/gif")) continue;
 779                } else if (uri.getScheme().equals("cid")) {
 780                    Cid cid = BobTransfer.cid(uri);
 781                    if (cid == null) continue;
 782                    DownloadableFile f = activity.xmppConnectionService.getFileForCid(cid);
 783                    if (f == null || !f.canRead()) {
 784                        if (!message.trusted() && !message.getConversation().canInferPresence()) continue;
 785
 786                        try {
 787                            new BobTransfer(BobTransfer.uri(cid), message.getConversation().getAccount(), message.getCounterpart(), activity.xmppConnectionService).start();
 788                        } catch (final NoSuchAlgorithmException | URISyntaxException e) { }
 789                        continue;
 790                    }
 791                } else {
 792                    continue;
 793                }
 794
 795                int width = message.getFileParams().width;
 796                if (width < 1 && thumb.getAttribute("width") != null) width = Integer.parseInt(thumb.getAttribute("width"));
 797                if (width < 1) width = 1920;
 798
 799                int height = message.getFileParams().height;
 800                if (height < 1 && thumb.getAttribute("height") != null) height = Integer.parseInt(thumb.getAttribute("height"));
 801                if (height < 1) height = 1080;
 802
 803                viewHolder.image.setVisibility(View.VISIBLE);
 804                imagePreviewLayout(width, height, viewHolder.image, true, type, viewHolder);
 805                activity.loadBitmap(message, viewHolder.image);
 806                viewHolder.image.setOnClickListener(v -> ConversationFragment.downloadFile(activity, message));
 807
 808                break;
 809            }
 810        }
 811        viewHolder.audioPlayer.setVisibility(View.GONE);
 812        viewHolder.download_button.setVisibility(View.VISIBLE);
 813        viewHolder.download_button.setText(text);
 814        final var attachment = Attachment.of(message);
 815        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 816        viewHolder.download_button.setIconResource(imageResource);
 817        viewHolder.download_button.setOnClickListener(
 818                v -> ConversationFragment.downloadFile(activity, message));
 819    }
 820
 821    private void displayWebxdcMessage(ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 822        Cid webxdcCid = message.getFileParams().getCids().get(0);
 823        WebxdcPage webxdc = new WebxdcPage(activity, webxdcCid, message, activity.xmppConnectionService);
 824        displayTextMessage(viewHolder, message, bubbleColor, type);
 825        viewHolder.image.setVisibility(View.GONE);
 826        viewHolder.audioPlayer.setVisibility(View.GONE);
 827        viewHolder.download_button.setVisibility(View.VISIBLE);
 828        viewHolder.download_button.setText("Open " + webxdc.getName());
 829        viewHolder.download_button.setOnClickListener(v -> {
 830            Conversation conversation = (Conversation) message.getConversation();
 831            if (!conversation.switchToSession("webxdc\0" + message.getUuid())) {
 832                conversation.startWebxdc(webxdc);
 833            }
 834        });
 835
 836        final WebxdcUpdate lastUpdate;
 837        synchronized(lastWebxdcUpdate) { lastUpdate = lastWebxdcUpdate.get(message.getUuid()); }
 838        if (lastUpdate == null) {
 839            new Thread(() -> {
 840                final WebxdcUpdate update = activity.xmppConnectionService.findLastWebxdcUpdate(message);
 841                if (update != null) {
 842                    synchronized(lastWebxdcUpdate) { lastWebxdcUpdate.put(message.getUuid(), update); }
 843                    activity.xmppConnectionService.updateConversationUi();
 844                }
 845            }).start();
 846        } else {
 847            if (lastUpdate != null && (lastUpdate.getSummary() != null || lastUpdate.getDocument() != null)) {
 848                viewHolder.messageBody.setVisibility(View.VISIBLE);
 849                viewHolder.messageBody.setText(
 850                    (lastUpdate.getDocument() == null ? "" : lastUpdate.getDocument() + "\n") +
 851                    (lastUpdate.getSummary() == null ? "" : lastUpdate.getSummary())
 852                );
 853            }
 854        }
 855
 856        final LruCache<String, Drawable> cache = activity.xmppConnectionService.getDrawableCache();
 857        final Drawable d = cache.get("webxdc:icon:" + webxdcCid);
 858        if (d == null) {
 859            new Thread(() -> {
 860                Drawable icon = webxdc.getIcon();
 861                if (icon != null) {
 862                    cache.put("webxdc:icon:" + webxdcCid, icon);
 863                    activity.xmppConnectionService.updateConversationUi();
 864                }
 865            }).start();
 866        } else {
 867            viewHolder.image.setVisibility(View.VISIBLE);
 868            viewHolder.image.setImageDrawable(d);
 869        }
 870    }
 871
 872    private void displayOpenableMessage(
 873            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 874        displayTextMessage(viewHolder, message, bubbleColor, type);
 875        viewHolder.image.setVisibility(View.GONE);
 876        viewHolder.audioPlayer.setVisibility(View.GONE);
 877        viewHolder.download_button.setVisibility(View.VISIBLE);
 878        viewHolder.download_button.setText(
 879                activity.getString(
 880                        R.string.open_x_file,
 881                        UIHelper.getFileDescriptionString(activity, message)));
 882        final var attachment = Attachment.of(message);
 883        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 884        viewHolder.download_button.setIconResource(imageResource);
 885        viewHolder.download_button.setOnClickListener(v -> openDownloadable(message));
 886    }
 887
 888    private void displayLocationMessage(
 889            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 890        displayTextMessage(viewHolder, message, bubbleColor, type);
 891        viewHolder.image.setVisibility(View.GONE);
 892        viewHolder.audioPlayer.setVisibility(View.GONE);
 893        viewHolder.download_button.setVisibility(View.VISIBLE);
 894        viewHolder.download_button.setText(R.string.show_location);
 895        final var attachment = Attachment.of(message);
 896        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 897        viewHolder.download_button.setIconResource(imageResource);
 898        viewHolder.download_button.setOnClickListener(v -> showLocation(message));
 899    }
 900
 901    private void displayAudioMessage(
 902            ViewHolder viewHolder, Message message, final BubbleColor bubbleColor, final int type) {
 903        displayTextMessage(viewHolder, message, bubbleColor, type);
 904        viewHolder.image.setVisibility(View.GONE);
 905        viewHolder.download_button.setVisibility(View.GONE);
 906        final RelativeLayout audioPlayer = viewHolder.audioPlayer;
 907        audioPlayer.setVisibility(View.VISIBLE);
 908        AudioPlayer.ViewHolder.get(audioPlayer).setBubbleColor(bubbleColor);
 909        this.audioPlayer.init(audioPlayer, message);
 910    }
 911
 912    private void displayMediaPreviewMessage(
 913            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 914        displayTextMessage(viewHolder, message, bubbleColor, type);
 915        viewHolder.download_button.setVisibility(View.GONE);
 916        viewHolder.audioPlayer.setVisibility(View.GONE);
 917        viewHolder.image.setVisibility(View.VISIBLE);
 918        final FileParams params = message.getFileParams();
 919        imagePreviewLayout(params.width, params.height, viewHolder.image, viewHolder.messageBody.getVisibility() != View.GONE, type, viewHolder);
 920        activity.loadBitmap(message, viewHolder.image);
 921        viewHolder.image.setOnClickListener(v -> openDownloadable(message));
 922    }
 923
 924    private void imagePreviewLayout(int w, int h, ShapeableImageView image, boolean withOther, int type, ViewHolder viewHolder) {
 925        final float target = activity.getResources().getDimension(R.dimen.image_preview_width);
 926        final int scaledW;
 927        final int scaledH;
 928        if (Math.max(h, w) * metrics.density <= target) {
 929            scaledW = (int) (w * metrics.density);
 930            scaledH = (int) (h * metrics.density);
 931        } else if (Math.max(h, w) <= target) {
 932            scaledW = w;
 933            scaledH = h;
 934        } else if (w <= h) {
 935            scaledW = (int) (w / ((double) h / target));
 936            scaledH = (int) target;
 937        } else {
 938            scaledW = (int) target;
 939            scaledH = (int) (h / ((double) w / target));
 940        }
 941        final var small = withOther ? scaledW < target : scaledW < 110 * metrics.density;
 942        final LinearLayout.LayoutParams layoutParams =
 943                new LinearLayout.LayoutParams(scaledW, scaledH);
 944        image.setLayoutParams(layoutParams);
 945
 946        final var bubbleRadius = activity.getResources().getDimension(R.dimen.bubble_radius);
 947        var shape = new ShapeAppearanceModel.Builder().setTopRightCorner(CornerFamily.ROUNDED, bubbleRadius);
 948        if (type == SENT) {
 949            shape = shape.setTopLeftCorner(CornerFamily.ROUNDED, bubbleRadius);
 950        }
 951        if (small) {
 952            final var imageRadius = activity.getResources().getDimension(R.dimen.image_radius);
 953            shape = shape.setAllCorners(CornerFamily.ROUNDED, imageRadius);
 954            image.setPadding(0, (int)(8 * metrics.density), 0, 0);
 955        } else {
 956            image.setPadding(0, 0, 0, 0);
 957        }
 958        image.setShapeAppearanceModel(shape.build());
 959
 960        if (!small) {
 961            final ViewGroup.LayoutParams blayoutParams = viewHolder.messageBody.getLayoutParams();
 962            blayoutParams.width = (int) (target - (22 * metrics.density));
 963            viewHolder.messageBody.setLayoutParams(blayoutParams);
 964        }
 965    }
 966
 967    private void toggleWhisperInfo(
 968            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor) {
 969        if (message.isPrivateMessage()) {
 970            final String privateMarker;
 971            if (message.getStatus() <= Message.STATUS_RECEIVED) {
 972                privateMarker = activity.getString(R.string.private_message);
 973            } else {
 974                Jid cp = message.getCounterpart();
 975                privateMarker =
 976                        activity.getString(
 977                                R.string.private_message_to,
 978                                Strings.nullToEmpty(cp == null ? null : cp.getResource()));
 979            }
 980            final SpannableString body = new SpannableString(privateMarker);
 981            body.setSpan(
 982                    new ForegroundColorSpan(
 983                            bubbleToOnSurfaceVariant(viewHolder.messageBody, bubbleColor)),
 984                    0,
 985                    privateMarker.length(),
 986                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 987            body.setSpan(
 988                    new StyleSpan(Typeface.BOLD),
 989                    0,
 990                    privateMarker.length(),
 991                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 992            viewHolder.messageBody.setText(body);
 993            viewHolder.messageBody.setVisibility(View.VISIBLE);
 994        } else {
 995            viewHolder.messageBody.setVisibility(View.GONE);
 996        }
 997    }
 998
 999    private void loadMoreMessages(Conversation conversation) {
1000        conversation.setLastClearHistory(0, null);
1001        activity.xmppConnectionService.updateConversation(conversation);
1002        conversation.setHasMessagesLeftOnServer(true);
1003        conversation.setFirstMamReference(null);
1004        long timestamp = conversation.getLastMessageTransmitted().getTimestamp();
1005        if (timestamp == 0) {
1006            timestamp = System.currentTimeMillis();
1007        }
1008        conversation.messagesLoaded.set(true);
1009        MessageArchiveService.Query query =
1010                activity.xmppConnectionService
1011                        .getMessageArchiveService()
1012                        .query(conversation, new MamReference(0), timestamp, false);
1013        if (query != null) {
1014            Toast.makeText(activity, R.string.fetching_history_from_server, Toast.LENGTH_LONG)
1015                    .show();
1016        } else {
1017            Toast.makeText(
1018                            activity,
1019                            R.string.not_fetching_history_retention_period,
1020                            Toast.LENGTH_SHORT)
1021                    .show();
1022        }
1023    }
1024
1025    @Override
1026    public View getView(final int position, View view, final @NonNull ViewGroup parent) {
1027        final Message message = getItem(position);
1028        final boolean omemoEncryption = message.getEncryption() == Message.ENCRYPTION_AXOLOTL;
1029        final boolean isInValidSession =
1030                message.isValidInSession() && (!omemoEncryption || message.isTrusted());
1031        final Conversational conversation = message.getConversation();
1032        final Account account = conversation.getAccount();
1033        final List<Element> commands = message.getCommands();
1034        final int type = getItemViewType(position);
1035        ViewHolder viewHolder;
1036        if (view == null) {
1037            viewHolder = new ViewHolder();
1038            switch (type) {
1039                case DATE_SEPARATOR:
1040                    view =
1041                            activity.getLayoutInflater()
1042                                    .inflate(R.layout.item_message_date_bubble, parent, false);
1043                    viewHolder.status_message = view.findViewById(R.id.message_body);
1044                    viewHolder.message_box = view.findViewById(R.id.message_box);
1045                    break;
1046                case RTP_SESSION:
1047                    view =
1048                            activity.getLayoutInflater()
1049                                    .inflate(R.layout.item_message_rtp_session, parent, false);
1050                    viewHolder.status_message = view.findViewById(R.id.message_body);
1051                    viewHolder.message_box = view.findViewById(R.id.message_box);
1052                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1053                    break;
1054                case SENT:
1055                    view = activity.getLayoutInflater().inflate(R.layout.item_message_sent, parent, false);
1056                    viewHolder.status_line = view.findViewById(R.id.status_line);
1057                    viewHolder.message_box_inner = view.findViewById(R.id.message_box_inner);
1058                    viewHolder.message_box = view.findViewById(R.id.message_box);
1059                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1060                    viewHolder.download_button = view.findViewById(R.id.download_button);
1061                    viewHolder.indicator = view.findViewById(R.id.security_indicator);
1062                    viewHolder.edit_indicator = view.findViewById(R.id.edit_indicator);
1063                    viewHolder.image = view.findViewById(R.id.message_image);
1064                    viewHolder.messageBody = view.findViewById(R.id.message_body);
1065                    viewHolder.time = view.findViewById(R.id.message_time);
1066                    viewHolder.subject = view.findViewById(R.id.message_subject);
1067                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1068                    viewHolder.audioPlayer = view.findViewById(R.id.audio_player);
1069                    viewHolder.thread_identicon = view.findViewById(R.id.thread_identicon);
1070                    break;
1071                case RECEIVED:
1072                    view = activity.getLayoutInflater().inflate(R.layout.item_message_received, parent, false);
1073                    viewHolder.status_line = view.findViewById(R.id.status_line);
1074                    viewHolder.message_box_inner = view.findViewById(R.id.message_box_inner);
1075                    viewHolder.message_box = view.findViewById(R.id.message_box);
1076                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1077                    viewHolder.download_button = view.findViewById(R.id.download_button);
1078                    viewHolder.indicator = view.findViewById(R.id.security_indicator);
1079                    viewHolder.edit_indicator = view.findViewById(R.id.edit_indicator);
1080                    viewHolder.image = view.findViewById(R.id.message_image);
1081                    viewHolder.messageBody = view.findViewById(R.id.message_body);
1082                    viewHolder.time = view.findViewById(R.id.message_time);
1083                    viewHolder.subject = view.findViewById(R.id.message_subject);
1084                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1085                    viewHolder.encryption = view.findViewById(R.id.message_encryption);
1086                    viewHolder.audioPlayer = view.findViewById(R.id.audio_player);
1087                    viewHolder.commands_list = view.findViewById(R.id.commands_list);
1088                    viewHolder.thread_identicon = view.findViewById(R.id.thread_identicon);
1089                    break;
1090                case STATUS:
1091                    view =
1092                            activity.getLayoutInflater()
1093                                    .inflate(R.layout.item_message_status, parent, false);
1094                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1095                    viewHolder.status_message = view.findViewById(R.id.status_message);
1096                    viewHolder.load_more_messages = view.findViewById(R.id.load_more_messages);
1097                    break;
1098                default:
1099                    throw new AssertionError("Unknown view type");
1100            }
1101            view.setTag(viewHolder);
1102        } else {
1103            viewHolder = (ViewHolder) view.getTag();
1104            if (viewHolder == null) {
1105                return view;
1106            }
1107        }
1108
1109        if (viewHolder.messageBody != null) {
1110            viewHolder.messageBody.setCustomSelectionActionModeCallback(new MessageTextActionModeCallback(this, viewHolder.messageBody));
1111        }
1112
1113        if (viewHolder.thread_identicon != null) {
1114            viewHolder.thread_identicon.setVisibility(View.GONE);
1115            final Element thread = message.getThread();
1116            if (thread != null) {
1117                final String threadId = thread.getContent();
1118                if (threadId != null) {
1119                    viewHolder.thread_identicon.setVisibility(View.VISIBLE);
1120                    viewHolder.thread_identicon.setColor(UIHelper.getColorForName(threadId));
1121                    viewHolder.thread_identicon.setHash(UIHelper.identiconHash(threadId));
1122                }
1123            }
1124        }
1125
1126        final var black = MaterialColors.getColor(view, com.google.android.material.R.attr.colorSecondaryContainer) == view.getContext().getColor(android.R.color.black);
1127        final boolean colorfulBackground = this.bubbleDesign.colorfulChatBubbles;
1128        final BubbleColor bubbleColor;
1129        if (type == RECEIVED) {
1130            if (isInValidSession) {
1131                bubbleColor = colorfulBackground  || black ? BubbleColor.SECONDARY : BubbleColor.SURFACE;
1132            } else {
1133                bubbleColor = BubbleColor.WARNING;
1134            }
1135        } else {
1136            if (!colorfulBackground && black) {
1137                bubbleColor = BubbleColor.SECONDARY;
1138            } else {
1139                bubbleColor = colorfulBackground ? BubbleColor.TERTIARY : BubbleColor.SURFACE_HIGH;
1140            }
1141        }
1142
1143        if (type == DATE_SEPARATOR) {
1144            if (UIHelper.today(message.getTimeSent())) {
1145                viewHolder.status_message.setText(R.string.today);
1146            } else if (UIHelper.yesterday(message.getTimeSent())) {
1147                viewHolder.status_message.setText(R.string.yesterday);
1148            } else {
1149                viewHolder.status_message.setText(
1150                        DateUtils.formatDateTime(
1151                                activity,
1152                                message.getTimeSent(),
1153                                DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR));
1154            }
1155            if (colorfulBackground) {
1156                setBackgroundTint(viewHolder.message_box, BubbleColor.PRIMARY);
1157                setTextColor(viewHolder.status_message, BubbleColor.PRIMARY);
1158            } else {
1159                setBackgroundTint(viewHolder.message_box, BubbleColor.SURFACE_HIGH);
1160                setTextColor(viewHolder.status_message, BubbleColor.SURFACE_HIGH);
1161            }
1162            return view;
1163        } else if (type == RTP_SESSION) {
1164            final boolean received = message.getStatus() <= Message.STATUS_RECEIVED;
1165            final RtpSessionStatus rtpSessionStatus = RtpSessionStatus.of(message.getBody());
1166            final long duration = rtpSessionStatus.duration;
1167            final String callTime = UIHelper.readableTimeDifferenceFull(activity, message.getTimeSent());
1168            if (received) {
1169                if (duration > 0) {
1170                    viewHolder.status_message.setText(
1171                            activity.getString(
1172                                    R.string.incoming_call_duration_timestamp,
1173                                    TimeFrameUtils.resolve(activity, duration),
1174                                    UIHelper.readableTimeDifferenceFull(
1175                                            activity, message.getTimeSent())));
1176                } else if (rtpSessionStatus.successful) {
1177                    viewHolder.status_message.setText(activity.getString(R.string.incoming_call_timestamp, callTime));
1178                } else {
1179                    viewHolder.status_message.setText(
1180                            activity.getString(
1181                                    R.string.missed_call_timestamp,
1182                                    UIHelper.readableTimeDifferenceFull(
1183                                            activity, message.getTimeSent())));
1184                }
1185            } else {
1186                if (duration > 0) {
1187                    viewHolder.status_message.setText(
1188                            activity.getString(
1189                                    R.string.outgoing_call_duration_timestamp,
1190                                    TimeFrameUtils.resolve(activity, duration),
1191                                    UIHelper.readableTimeDifferenceFull(
1192                                            activity, message.getTimeSent())));
1193                } else {
1194                    viewHolder.status_message.setText(
1195                            activity.getString(
1196                                    R.string.outgoing_call_timestamp,
1197                                    UIHelper.readableTimeDifferenceFull(
1198                                            activity, message.getTimeSent())));
1199                }
1200            }
1201            if (colorfulBackground) {
1202                setBackgroundTint(viewHolder.message_box, BubbleColor.SECONDARY);
1203                setTextColor(viewHolder.status_message, BubbleColor.SECONDARY);
1204                setImageTint(viewHolder.indicatorReceived, BubbleColor.SECONDARY);
1205            } else {
1206                setBackgroundTint(viewHolder.message_box, BubbleColor.SURFACE_HIGH);
1207                setTextColor(viewHolder.status_message, BubbleColor.SURFACE_HIGH);
1208                setImageTint(viewHolder.indicatorReceived, BubbleColor.SURFACE_HIGH);
1209            }
1210            viewHolder.indicatorReceived.setImageResource(
1211                    RtpSessionStatus.getDrawable(received, rtpSessionStatus.successful));
1212            return view;
1213        } else if (type == STATUS) {
1214            if ("LOAD_MORE".equals(message.getBody())) {
1215                viewHolder.status_message.setVisibility(View.GONE);
1216                viewHolder.contact_picture.setVisibility(View.GONE);
1217                viewHolder.load_more_messages.setVisibility(View.VISIBLE);
1218                viewHolder.load_more_messages.setOnClickListener(
1219                        v -> loadMoreMessages((Conversation) message.getConversation()));
1220            } else {
1221                viewHolder.status_message.setVisibility(View.VISIBLE);
1222                viewHolder.load_more_messages.setVisibility(View.GONE);
1223                viewHolder.status_message.setText(message.getBody());
1224                boolean showAvatar;
1225                if (conversation.getMode() == Conversation.MODE_SINGLE) {
1226                    showAvatar = true;
1227                    AvatarWorkerTask.loadAvatar(
1228                            message, viewHolder.contact_picture, R.dimen.avatar_on_status_message);
1229                } else if (message.getCounterpart() != null
1230                        || message.getTrueCounterpart() != null
1231                        || (message.getCounterparts() != null
1232                                && message.getCounterparts().size() > 0)) {
1233                    showAvatar = true;
1234                    AvatarWorkerTask.loadAvatar(
1235                            message, viewHolder.contact_picture, R.dimen.avatar_on_status_message);
1236                } else {
1237                    showAvatar = false;
1238                }
1239                if (showAvatar) {
1240                    viewHolder.contact_picture.setAlpha(0.5f);
1241                    viewHolder.contact_picture.setVisibility(View.VISIBLE);
1242                } else {
1243                    viewHolder.contact_picture.setVisibility(View.GONE);
1244                }
1245            }
1246            return view;
1247        } else {
1248            // viewHolder.message_box.setClipToOutline(true); This eats the bubble tails on A14 for some reason
1249            AvatarWorkerTask.loadAvatar(message, viewHolder.contact_picture, R.dimen.avatar);
1250        }
1251
1252        resetClickListener(viewHolder.message_box, viewHolder.messageBody);
1253
1254        viewHolder.message_box.setOnClickListener(v -> {
1255            if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1256                MessageAdapter.this.mOnMessageBoxClickedListener
1257                        .onContactPictureClicked(message);
1258            }
1259        });
1260        SwipeDetector swipeDetector = new SwipeDetector((action) -> {
1261            if (action == SwipeDetector.Action.LR && MessageAdapter.this.mOnMessageBoxSwipedListener != null) {
1262                MessageAdapter.this.mOnMessageBoxSwipedListener.onContactPictureClicked(message);
1263            }
1264        });
1265        viewHolder.message_box.setOnTouchListener(swipeDetector);
1266        viewHolder.image.setOnTouchListener(swipeDetector);
1267        viewHolder.time.setOnTouchListener(swipeDetector);
1268
1269        // Treat touch-up as click so we don't have to touch twice
1270        // (touch twice is because it's waiting to see if you double-touch for text selection)
1271        viewHolder.messageBody.setOnTouchListener((v, event) -> {
1272            if (event.getAction() == MotionEvent.ACTION_UP) {
1273                if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1274                    MessageAdapter.this.mOnMessageBoxClickedListener
1275                        .onContactPictureClicked(message);
1276                }
1277            }
1278
1279            swipeDetector.onTouch(v, event);
1280
1281            return false;
1282        });
1283        viewHolder.messageBody.setOnClickListener(v -> {
1284            if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1285                MessageAdapter.this.mOnMessageBoxClickedListener
1286                        .onContactPictureClicked(message);
1287            }
1288        });
1289        viewHolder.contact_picture.setOnClickListener(v -> {
1290            if (MessageAdapter.this.mOnContactPictureClickedListener != null) {
1291                MessageAdapter.this.mOnContactPictureClickedListener
1292                        .onContactPictureClicked(message);
1293            }
1294
1295        });
1296        viewHolder.contact_picture.setOnLongClickListener(v -> {
1297            if (MessageAdapter.this.mOnContactPictureLongClickedListener != null) {
1298                MessageAdapter.this.mOnContactPictureLongClickedListener
1299                        .onContactPictureLongClicked(v, message);
1300                return true;
1301            } else {
1302                return false;
1303            }
1304        });
1305        viewHolder.messageBody.setAccessibilityDelegate(null);
1306
1307        boolean footerWrap = false;
1308
1309        final Transferable transferable = message.getTransferable();
1310        final boolean unInitiatedButKnownSize = MessageUtils.unInitiatedButKnownSize(message);
1311
1312        final boolean muted = message.getStatus() == Message.STATUS_RECEIVED && conversation.getMode() == Conversation.MODE_MULTI && activity.xmppConnectionService.isMucUserMuted(new MucOptions.User(null, conversation.getJid(), message.getOccupantId(), null, null));
1313        if (muted) {
1314            // Muted MUC participant
1315            displayInfoMessage(viewHolder, "Muted", bubbleColor);
1316        } else if (unInitiatedButKnownSize || message.isDeleted() || (transferable != null && transferable.getStatus() != Transferable.STATUS_UPLOADING)) {
1317            if (unInitiatedButKnownSize || (message.isDeleted() && message.getModerated() == null) || transferable != null && transferable.getStatus() == Transferable.STATUS_OFFER) {
1318                displayDownloadableMessage(viewHolder, message, activity.getString(R.string.download_x_file, UIHelper.getFileDescriptionString(activity, message)), bubbleColor, type);
1319            } else if (transferable != null && transferable.getStatus() == Transferable.STATUS_OFFER_CHECK_FILESIZE) {
1320                displayDownloadableMessage(viewHolder, message, activity.getString(R.string.check_x_filesize, UIHelper.getFileDescriptionString(activity, message)), bubbleColor, type);
1321            } else {
1322                displayInfoMessage(viewHolder, UIHelper.getMessagePreview(activity.xmppConnectionService, message).first, bubbleColor);
1323            }
1324        } else if (message.isFileOrImage()
1325                && message.getEncryption() != Message.ENCRYPTION_PGP
1326                && message.getEncryption() != Message.ENCRYPTION_DECRYPTION_FAILED) {
1327            if (message.getFileParams().width > 0 && message.getFileParams().height > 0) {
1328                displayMediaPreviewMessage(viewHolder, message, bubbleColor, type);
1329                if (!black && viewHolder.image.getLayoutParams().width > metrics.density * 110) {
1330                    footerWrap = true;
1331                }
1332            } else if (message.getFileParams().runtime > 0) {
1333                displayAudioMessage(viewHolder, message, bubbleColor, type);
1334            } else if ("application/xdc+zip".equals(message.getFileParams().getMediaType()) && message.getConversation() instanceof Conversation && message.getThread() != null && !message.getFileParams().getCids().isEmpty()) {
1335                displayWebxdcMessage(viewHolder, message, bubbleColor, type);
1336            } else {
1337                displayOpenableMessage(viewHolder, message, bubbleColor, type);
1338            }
1339        } else if (message.getEncryption() == Message.ENCRYPTION_PGP) {
1340            if (account.isPgpDecryptionServiceConnected()) {
1341                if (conversation instanceof Conversation
1342                        && !account.hasPendingPgpIntent((Conversation) conversation)) {
1343                    displayInfoMessage(
1344                            viewHolder,
1345                            activity.getString(R.string.message_decrypting),
1346                            bubbleColor);
1347                } else {
1348                    displayInfoMessage(
1349                            viewHolder, activity.getString(R.string.pgp_message), bubbleColor);
1350                }
1351            } else {
1352                displayInfoMessage(
1353                        viewHolder, activity.getString(R.string.install_openkeychain), bubbleColor);
1354                viewHolder.message_box.setOnClickListener(this::promptOpenKeychainInstall);
1355                viewHolder.messageBody.setOnClickListener(this::promptOpenKeychainInstall);
1356            }
1357        } else if (message.getEncryption() == Message.ENCRYPTION_DECRYPTION_FAILED) {
1358            displayInfoMessage(
1359                    viewHolder, activity.getString(R.string.decryption_failed), bubbleColor);
1360        } else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL_NOT_FOR_THIS_DEVICE) {
1361            displayInfoMessage(
1362                    viewHolder,
1363                    activity.getString(R.string.not_encrypted_for_this_device),
1364                    bubbleColor);
1365        } else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL_FAILED) {
1366            displayInfoMessage(
1367                    viewHolder, activity.getString(R.string.omemo_decryption_failed), bubbleColor);
1368        } else {
1369            if (message.isGeoUri()) {
1370                displayLocationMessage(viewHolder, message, bubbleColor, type);
1371            } else if (message.treatAsDownloadable()) {
1372                try {
1373                    final URI uri = message.getOob();
1374                    displayDownloadableMessage(viewHolder,
1375                            message,
1376                            activity.getString(
1377                                    R.string.check_x_filesize_on_host,
1378                                    UIHelper.getFileDescriptionString(activity, message),
1379                                    uri.getHost()),
1380                            bubbleColor, type);
1381                } catch (Exception e) {
1382                    displayDownloadableMessage(
1383                            viewHolder,
1384                            message,
1385                            activity.getString(
1386                                    R.string.check_x_filesize,
1387                                    UIHelper.getFileDescriptionString(activity, message)),
1388                            bubbleColor, type);
1389                }
1390            } else if (message.bodyIsOnlyEmojis() && message.getType() != Message.TYPE_PRIVATE) {
1391                displayEmojiMessage(viewHolder, message, bubbleColor, type);
1392            } else {
1393                displayTextMessage(viewHolder, message, bubbleColor, message.getType());
1394            }
1395        }
1396
1397        viewHolder.message_box_inner.setMinimumWidth(footerWrap ? (int) (110 * metrics.density) : 0);
1398        LinearLayout.LayoutParams statusParams = (LinearLayout.LayoutParams) viewHolder.status_line.getLayoutParams();
1399        statusParams.width = footerWrap ? ViewGroup.LayoutParams.MATCH_PARENT : ViewGroup.LayoutParams.WRAP_CONTENT;
1400        viewHolder.status_line.setLayoutParams(statusParams);
1401
1402        setBackgroundTint(viewHolder.message_box, bubbleColor);
1403        setTextColor(viewHolder.messageBody, bubbleColor);
1404        viewHolder.messageBody.setLinkTextColor(bubbleToOnSurfaceColor(viewHolder.messageBody, bubbleColor));
1405
1406        if (type == RECEIVED) {
1407            if (!muted && commands != null && conversation instanceof Conversation) {
1408                CommandButtonAdapter adapter = new CommandButtonAdapter(activity);
1409                adapter.addAll(commands);
1410                viewHolder.commands_list.setAdapter(adapter);
1411                viewHolder.commands_list.setVisibility(View.VISIBLE);
1412                viewHolder.commands_list.setOnItemClickListener((p, v, pos, id) -> {
1413                    final Element command = adapter.getItem(pos);
1414                    activity.startCommand(conversation.getAccount(), command.getAttributeAsJid("jid"), command.getAttribute("node"));
1415                });
1416            } else {
1417                // It's unclear if we can set this to null...
1418                ListAdapter adapter = viewHolder.commands_list.getAdapter();
1419                if (adapter instanceof ArrayAdapter) {
1420                    ((ArrayAdapter<?>) adapter).clear();
1421                }
1422                viewHolder.commands_list.setVisibility(View.GONE);
1423                viewHolder.commands_list.setOnItemClickListener(null);
1424            }
1425
1426            setTextColor(viewHolder.encryption, bubbleColor);
1427
1428            if (isInValidSession) {
1429                viewHolder.encryption.setVisibility(View.GONE);
1430            } else {
1431                viewHolder.encryption.setVisibility(View.VISIBLE);
1432                if (omemoEncryption && !message.isTrusted()) {
1433                    viewHolder.encryption.setText(R.string.not_trusted);
1434                } else {
1435                    viewHolder.encryption.setText(
1436                            CryptoHelper.encryptionTypeToText(message.getEncryption()));
1437                }
1438            }
1439        }
1440
1441        if (type == RECEIVED || type == SENT) {
1442            String subject = message.getSubject();
1443            if (subject == null && message.getThread() != null) {
1444                final var thread = ((Conversation) message.getConversation()).getThread(message.getThread().getContent());
1445                if (thread != null) subject = thread.getSubject();
1446            }
1447            if (muted || subject == null) {
1448                viewHolder.subject.setVisibility(View.GONE);
1449            } else {
1450                viewHolder.subject.setVisibility(View.VISIBLE);
1451                viewHolder.subject.setText(subject);
1452            }
1453        }
1454
1455        displayStatus(viewHolder, message, type, bubbleColor);
1456
1457        viewHolder.messageBody.setAccessibilityDelegate(new View.AccessibilityDelegate() {
1458            @Override
1459            public void sendAccessibilityEvent(View host, int eventType) {
1460                super.sendAccessibilityEvent(host, eventType);
1461                if (eventType == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED) {
1462                    if (viewHolder.messageBody.hasSelection()) {
1463                        selectionUuid = message.getUuid();
1464                    } else if (message.getUuid() != null && message.getUuid().equals(selectionUuid)) {
1465                        selectionUuid = null;
1466                    }
1467                }
1468            }
1469        });
1470
1471        return view;
1472    }
1473
1474    private void promptOpenKeychainInstall(View view) {
1475        activity.showInstallPgpDialog();
1476    }
1477
1478    public FileBackend getFileBackend() {
1479        return activity.xmppConnectionService.getFileBackend();
1480    }
1481
1482    public void stopAudioPlayer() {
1483        audioPlayer.stop();
1484    }
1485
1486    public void unregisterListenerInAudioPlayer() {
1487        audioPlayer.unregisterListener();
1488    }
1489
1490    public void startStopPending() {
1491        audioPlayer.startStopPending();
1492    }
1493
1494    public void openDownloadable(Message message) {
1495        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU
1496                && ContextCompat.checkSelfPermission(
1497                                activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)
1498                        != PackageManager.PERMISSION_GRANTED) {
1499            ConversationFragment.registerPendingMessage(activity, message);
1500            ActivityCompat.requestPermissions(
1501                    activity,
1502                    new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
1503                    ConversationsActivity.REQUEST_OPEN_MESSAGE);
1504            return;
1505        }
1506        final DownloadableFile file =
1507                activity.xmppConnectionService.getFileBackend().getFile(message);
1508        ViewUtil.view(activity, file);
1509    }
1510
1511    private void showLocation(Message message) {
1512        for (Intent intent : GeoHelper.createGeoIntentsFromMessage(activity, message)) {
1513            if (intent.resolveActivity(getContext().getPackageManager()) != null) {
1514                getContext().startActivity(intent);
1515                return;
1516            }
1517        }
1518        Toast.makeText(
1519                        activity,
1520                        R.string.no_application_found_to_display_location,
1521                        Toast.LENGTH_SHORT)
1522                .show();
1523    }
1524
1525    public void updatePreferences() {
1526        final AppSettings appSettings = new AppSettings(activity);
1527        this.bubbleDesign =
1528                new BubbleDesign(appSettings.isColorfulChatBubbles(), appSettings.isLargeFont());
1529    }
1530
1531    public void setHighlightedTerm(List<String> terms) {
1532        this.highlightedTerm = terms == null ? null : StylingHelper.filterHighlightedWords(terms);
1533    }
1534
1535    public interface OnContactPictureClicked {
1536        void onContactPictureClicked(Message message);
1537    }
1538
1539    public interface OnContactPictureLongClicked {
1540        void onContactPictureLongClicked(View v, Message message);
1541    }
1542
1543    public interface OnInlineImageLongClicked {
1544        boolean onInlineImageLongClicked(Cid cid);
1545    }
1546
1547    private static void setBackgroundTint(final View view, final BubbleColor bubbleColor) {
1548        view.setBackgroundTintList(bubbleToColorStateList(view, bubbleColor));
1549    }
1550
1551    private static ColorStateList bubbleToColorStateList(
1552            final View view, final BubbleColor bubbleColor) {
1553        final @AttrRes int colorAttributeResId =
1554                switch (bubbleColor) {
1555                    case SURFACE -> Activities.isNightMode(view.getContext())
1556                            ? com.google.android.material.R.attr.colorSurfaceContainerHigh
1557                            : com.google.android.material.R.attr.colorSurfaceContainerLow;
1558                    case SURFACE_HIGH -> Activities.isNightMode(view.getContext())
1559                            ? com.google.android.material.R.attr.colorSurfaceContainerHighest
1560                            : com.google.android.material.R.attr.colorSurfaceContainerHigh;
1561                    case PRIMARY -> com.google.android.material.R.attr.colorPrimaryContainer;
1562                    case SECONDARY -> com.google.android.material.R.attr.colorSecondaryContainer;
1563                    case TERTIARY -> com.google.android.material.R.attr.colorTertiaryContainer;
1564                    case WARNING -> com.google.android.material.R.attr.colorErrorContainer;
1565                };
1566        return ColorStateList.valueOf(MaterialColors.getColor(view, colorAttributeResId));
1567    }
1568
1569    public static void setImageTint(final ImageView imageView, final BubbleColor bubbleColor) {
1570        ImageViewCompat.setImageTintList(
1571                imageView, bubbleToOnSurfaceColorStateList(imageView, bubbleColor));
1572    }
1573
1574    public static void setImageTintError(final ImageView imageView) {
1575        ImageViewCompat.setImageTintList(
1576                imageView,
1577                ColorStateList.valueOf(
1578                        MaterialColors.getColor(
1579                                imageView, com.google.android.material.R.attr.colorError)));
1580    }
1581
1582    public static void setTextColor(final TextView textView, final BubbleColor bubbleColor) {
1583        final var color = bubbleToOnSurfaceColor(textView, bubbleColor);
1584        textView.setTextColor(color);
1585        if (BubbleColor.SURFACES.contains(bubbleColor)) {
1586            textView.setLinkTextColor(
1587                    MaterialColors.getColor(
1588                            textView, com.google.android.material.R.attr.colorPrimary));
1589        } else {
1590            textView.setLinkTextColor(color);
1591        }
1592    }
1593
1594    private static void setTextSize(final TextView textView, final boolean largeFont) {
1595        if (largeFont) {
1596            textView.setTextAppearance(
1597                    com.google.android.material.R.style.TextAppearance_Material3_BodyLarge);
1598            textView.setTextSize(android.util.TypedValue.COMPLEX_UNIT_SP, 18);
1599        } else {
1600            textView.setTextAppearance(
1601                    com.google.android.material.R.style.TextAppearance_Material3_BodyMedium);
1602        }
1603    }
1604
1605    private static @ColorInt int bubbleToOnSurfaceVariant(
1606            final View view, final BubbleColor bubbleColor) {
1607        final @AttrRes int colorAttributeResId;
1608        if (BubbleColor.SURFACES.contains(bubbleColor)) {
1609            colorAttributeResId = com.google.android.material.R.attr.colorOnSurfaceVariant;
1610        } else {
1611            colorAttributeResId = bubbleToOnSurface(bubbleColor);
1612        }
1613        return MaterialColors.getColor(view, colorAttributeResId);
1614    }
1615
1616    private static @ColorInt int bubbleToOnSurfaceColor(
1617            final View view, final BubbleColor bubbleColor) {
1618        return MaterialColors.getColor(view, bubbleToOnSurface(bubbleColor));
1619    }
1620
1621    public static ColorStateList bubbleToOnSurfaceColorStateList(
1622            final View view, final BubbleColor bubbleColor) {
1623        return ColorStateList.valueOf(bubbleToOnSurfaceColor(view, bubbleColor));
1624    }
1625
1626    private static @AttrRes int bubbleToOnSurface(final BubbleColor bubbleColor) {
1627        return switch (bubbleColor) {
1628            case SURFACE, SURFACE_HIGH -> com.google.android.material.R.attr.colorOnSurface;
1629            case PRIMARY -> com.google.android.material.R.attr.colorOnPrimaryContainer;
1630            case SECONDARY -> com.google.android.material.R.attr.colorOnSecondaryContainer;
1631            case TERTIARY -> com.google.android.material.R.attr.colorOnTertiaryContainer;
1632            case WARNING -> com.google.android.material.R.attr.colorOnErrorContainer;
1633        };
1634    }
1635
1636    public enum BubbleColor {
1637        SURFACE,
1638        SURFACE_HIGH,
1639        PRIMARY,
1640        SECONDARY,
1641        TERTIARY,
1642        WARNING;
1643
1644        private static final Collection<BubbleColor> SURFACES =
1645                Arrays.asList(BubbleColor.SURFACE, BubbleColor.SURFACE_HIGH);
1646    }
1647
1648    private static class BubbleDesign {
1649        public final boolean colorfulChatBubbles;
1650        public final boolean largeFont;
1651
1652        private BubbleDesign(final boolean colorfulChatBubbles, final boolean largeFont) {
1653            this.colorfulChatBubbles = colorfulChatBubbles;
1654            this.largeFont = largeFont;
1655        }
1656    }
1657
1658    private static class ViewHolder {
1659
1660        public MaterialButton load_more_messages;
1661        public ImageView edit_indicator;
1662        public RelativeLayout audioPlayer;
1663        protected View status_line;
1664        protected LinearLayout message_box;
1665        protected View message_box_inner;
1666        protected MaterialButton download_button;
1667        protected ShapeableImageView image;
1668        protected ImageView indicator;
1669        protected ImageView indicatorReceived;
1670        protected TextView time;
1671        protected TextView subject;
1672        protected TextView messageBody;
1673        protected ImageView contact_picture;
1674        protected TextView status_message;
1675        protected TextView encryption;
1676        protected ListView commands_list;
1677        protected GithubIdenticonView thread_identicon;
1678    }
1679
1680    class ThumbnailTask extends AsyncTask<DownloadableFile, Void, Drawable[]> {
1681        @Override
1682        protected Drawable[] doInBackground(DownloadableFile... params) {
1683            if (isCancelled()) return null;
1684
1685            Drawable[] d = new Drawable[params.length];
1686            for (int i = 0; i < params.length; i++) {
1687                try {
1688                    d[i] = activity.xmppConnectionService.getFileBackend().getThumbnail(params[i], activity.getResources(), (int) (metrics.density * 288), false);
1689                } catch (final IOException e) {
1690                    d[i] = null;
1691                }
1692            }
1693
1694            return d;
1695        }
1696
1697        @Override
1698        protected void onPostExecute(final Drawable[] d) {
1699            if (isCancelled()) return;
1700            activity.xmppConnectionService.updateConversationUi();
1701        }
1702    }
1703}