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                var end = emoji.getCharIndex() + emoji.getEmoji().getEmoji().length();
 716                if (body.length() > end && body.charAt(end) == '\uFE0F') end++;
 717                body.setSpan(
 718                        new RelativeSizeSpan(1.2f),
 719                        emoji.getCharIndex(),
 720                        end,
 721                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 722            }
 723            // Make custom emoji bigger too, to match emoji
 724            for (final var span : body.getSpans(0, body.length(), com.cheogram.android.InlineImageSpan.class)) {
 725                body.setSpan(
 726                        new RelativeSizeSpan(1.2f),
 727                        body.getSpanStart(span),
 728                        body.getSpanEnd(span),
 729                        Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 730            }
 731
 732            if (processMarkup) StylingHelper.format(body, viewHolder.messageBody.getCurrentTextColor());
 733            MyLinkify.addLinks(body, message.getConversation().getAccount(), message.getConversation().getJid());
 734            if (highlightedTerm != null) {
 735                StylingHelper.highlight(viewHolder.messageBody, body, highlightedTerm);
 736            }
 737
 738            viewHolder.messageBody.setAutoLinkMask(0);
 739            viewHolder.messageBody.setText(body);
 740            BetterLinkMovementMethod method = new BetterLinkMovementMethod() {
 741                @Override
 742                protected void dispatchUrlLongClick(TextView tv, ClickableSpan span) {
 743                    if (span instanceof URLSpan || mOnInlineImageLongClickedListener == null) {
 744                        tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 745                        super.dispatchUrlLongClick(tv, span);
 746                        return;
 747                    }
 748
 749                    Spannable body = (Spannable) tv.getText();
 750                    ImageSpan[] imageSpans = body.getSpans(body.getSpanStart(span), body.getSpanEnd(span), ImageSpan.class);
 751                    if (imageSpans.length > 0) {
 752                        Uri uri = Uri.parse(imageSpans[0].getSource());
 753                        Cid cid = BobTransfer.cid(uri);
 754                        if (cid == null) return;
 755                        if (mOnInlineImageLongClickedListener.onInlineImageLongClicked(cid)) {
 756                            tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 757                        }
 758                    }
 759                }
 760            };
 761            method.setOnLinkLongClickListener((tv, url) -> {
 762                tv.dispatchTouchEvent(MotionEvent.obtain(0, 0, MotionEvent.ACTION_CANCEL, 0f, 0f, 0));
 763                ShareUtil.copyLinkToClipboard(activity, url);
 764                return true;
 765            });
 766            viewHolder.messageBody.setMovementMethod(method);
 767        } else {
 768            viewHolder.messageBody.setText("");
 769            viewHolder.messageBody.setTextIsSelectable(false);
 770            toggleWhisperInfo(viewHolder, message, bubbleColor);
 771        }
 772    }
 773
 774    private void displayDownloadableMessage(
 775            ViewHolder viewHolder,
 776            final Message message,
 777            String text,
 778            final BubbleColor bubbleColor, final int type) {
 779        displayTextMessage(viewHolder, message, bubbleColor, type);
 780        viewHolder.image.setVisibility(View.GONE);
 781        List<Element> thumbs = message.getFileParams() != null ? message.getFileParams().getThumbnails() : null;
 782        if (thumbs != null && !thumbs.isEmpty()) {
 783            for (Element thumb : thumbs) {
 784                Uri uri = Uri.parse(thumb.getAttribute("uri"));
 785                if (uri.getScheme().equals("data")) {
 786                    String[] parts = uri.getSchemeSpecificPart().split(",", 2);
 787                    parts = parts[0].split(";");
 788                    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;
 789                } else if (uri.getScheme().equals("cid")) {
 790                    Cid cid = BobTransfer.cid(uri);
 791                    if (cid == null) continue;
 792                    DownloadableFile f = activity.xmppConnectionService.getFileForCid(cid);
 793                    if (f == null || !f.canRead()) {
 794                        if (!message.trusted() && !message.getConversation().canInferPresence()) continue;
 795
 796                        try {
 797                            new BobTransfer(BobTransfer.uri(cid), message.getConversation().getAccount(), message.getCounterpart(), activity.xmppConnectionService).start();
 798                        } catch (final NoSuchAlgorithmException | URISyntaxException e) { }
 799                        continue;
 800                    }
 801                } else {
 802                    continue;
 803                }
 804
 805                int width = message.getFileParams().width;
 806                if (width < 1 && thumb.getAttribute("width") != null) width = Integer.parseInt(thumb.getAttribute("width"));
 807                if (width < 1) width = 1920;
 808
 809                int height = message.getFileParams().height;
 810                if (height < 1 && thumb.getAttribute("height") != null) height = Integer.parseInt(thumb.getAttribute("height"));
 811                if (height < 1) height = 1080;
 812
 813                viewHolder.image.setVisibility(View.VISIBLE);
 814                imagePreviewLayout(width, height, viewHolder.image, true, type, viewHolder);
 815                activity.loadBitmap(message, viewHolder.image);
 816                viewHolder.image.setOnClickListener(v -> ConversationFragment.downloadFile(activity, message));
 817
 818                break;
 819            }
 820        }
 821        viewHolder.audioPlayer.setVisibility(View.GONE);
 822        viewHolder.download_button.setVisibility(View.VISIBLE);
 823        viewHolder.download_button.setText(text);
 824        final var attachment = Attachment.of(message);
 825        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 826        viewHolder.download_button.setIconResource(imageResource);
 827        viewHolder.download_button.setOnClickListener(
 828                v -> ConversationFragment.downloadFile(activity, message));
 829    }
 830
 831    private void displayWebxdcMessage(ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 832        Cid webxdcCid = message.getFileParams().getCids().get(0);
 833        WebxdcPage webxdc = new WebxdcPage(activity, webxdcCid, message, activity.xmppConnectionService);
 834        displayTextMessage(viewHolder, message, bubbleColor, type);
 835        viewHolder.image.setVisibility(View.GONE);
 836        viewHolder.audioPlayer.setVisibility(View.GONE);
 837        viewHolder.download_button.setVisibility(View.VISIBLE);
 838        viewHolder.download_button.setText("Open " + webxdc.getName());
 839        viewHolder.download_button.setOnClickListener(v -> {
 840            Conversation conversation = (Conversation) message.getConversation();
 841            if (!conversation.switchToSession("webxdc\0" + message.getUuid())) {
 842                conversation.startWebxdc(webxdc);
 843            }
 844        });
 845
 846        final WebxdcUpdate lastUpdate;
 847        synchronized(lastWebxdcUpdate) { lastUpdate = lastWebxdcUpdate.get(message.getUuid()); }
 848        if (lastUpdate == null) {
 849            new Thread(() -> {
 850                final WebxdcUpdate update = activity.xmppConnectionService.findLastWebxdcUpdate(message);
 851                if (update != null) {
 852                    synchronized(lastWebxdcUpdate) { lastWebxdcUpdate.put(message.getUuid(), update); }
 853                    activity.xmppConnectionService.updateConversationUi();
 854                }
 855            }).start();
 856        } else {
 857            if (lastUpdate != null && (lastUpdate.getSummary() != null || lastUpdate.getDocument() != null)) {
 858                viewHolder.messageBody.setVisibility(View.VISIBLE);
 859                viewHolder.messageBody.setText(
 860                    (lastUpdate.getDocument() == null ? "" : lastUpdate.getDocument() + "\n") +
 861                    (lastUpdate.getSummary() == null ? "" : lastUpdate.getSummary())
 862                );
 863            }
 864        }
 865
 866        final LruCache<String, Drawable> cache = activity.xmppConnectionService.getDrawableCache();
 867        final Drawable d = cache.get("webxdc:icon:" + webxdcCid);
 868        if (d == null) {
 869            new Thread(() -> {
 870                Drawable icon = webxdc.getIcon();
 871                if (icon != null) {
 872                    cache.put("webxdc:icon:" + webxdcCid, icon);
 873                    activity.xmppConnectionService.updateConversationUi();
 874                }
 875            }).start();
 876        } else {
 877            viewHolder.image.setVisibility(View.VISIBLE);
 878            viewHolder.image.setImageDrawable(d);
 879        }
 880    }
 881
 882    private void displayOpenableMessage(
 883            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 884        displayTextMessage(viewHolder, message, bubbleColor, type);
 885        viewHolder.image.setVisibility(View.GONE);
 886        viewHolder.audioPlayer.setVisibility(View.GONE);
 887        viewHolder.download_button.setVisibility(View.VISIBLE);
 888        viewHolder.download_button.setText(
 889                activity.getString(
 890                        R.string.open_x_file,
 891                        UIHelper.getFileDescriptionString(activity, message)));
 892        final var attachment = Attachment.of(message);
 893        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 894        viewHolder.download_button.setIconResource(imageResource);
 895        viewHolder.download_button.setOnClickListener(v -> openDownloadable(message));
 896    }
 897
 898    private void displayLocationMessage(
 899            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 900        displayTextMessage(viewHolder, message, bubbleColor, type);
 901        viewHolder.image.setVisibility(View.GONE);
 902        viewHolder.audioPlayer.setVisibility(View.GONE);
 903        viewHolder.download_button.setVisibility(View.VISIBLE);
 904        viewHolder.download_button.setText(R.string.show_location);
 905        final var attachment = Attachment.of(message);
 906        final @DrawableRes int imageResource = MediaAdapter.getImageDrawable(attachment);
 907        viewHolder.download_button.setIconResource(imageResource);
 908        viewHolder.download_button.setOnClickListener(v -> showLocation(message));
 909    }
 910
 911    private void displayAudioMessage(
 912            ViewHolder viewHolder, Message message, final BubbleColor bubbleColor, final int type) {
 913        displayTextMessage(viewHolder, message, bubbleColor, type);
 914        viewHolder.image.setVisibility(View.GONE);
 915        viewHolder.download_button.setVisibility(View.GONE);
 916        final RelativeLayout audioPlayer = viewHolder.audioPlayer;
 917        audioPlayer.setVisibility(View.VISIBLE);
 918        AudioPlayer.ViewHolder.get(audioPlayer).setBubbleColor(bubbleColor);
 919        this.audioPlayer.init(audioPlayer, message);
 920    }
 921
 922    private void displayMediaPreviewMessage(
 923            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor, final int type) {
 924        displayTextMessage(viewHolder, message, bubbleColor, type);
 925        viewHolder.download_button.setVisibility(View.GONE);
 926        viewHolder.audioPlayer.setVisibility(View.GONE);
 927        viewHolder.image.setVisibility(View.VISIBLE);
 928        final FileParams params = message.getFileParams();
 929        imagePreviewLayout(params.width, params.height, viewHolder.image, viewHolder.messageBody.getVisibility() != View.GONE, type, viewHolder);
 930        activity.loadBitmap(message, viewHolder.image);
 931        viewHolder.image.setOnClickListener(v -> openDownloadable(message));
 932    }
 933
 934    private void imagePreviewLayout(int w, int h, ShapeableImageView image, boolean withOther, int type, ViewHolder viewHolder) {
 935        final float target = activity.getResources().getDimension(R.dimen.image_preview_width);
 936        final int scaledW;
 937        final int scaledH;
 938        if (Math.max(h, w) * metrics.density <= target) {
 939            scaledW = (int) (w * metrics.density);
 940            scaledH = (int) (h * metrics.density);
 941        } else if (Math.max(h, w) <= target) {
 942            scaledW = w;
 943            scaledH = h;
 944        } else if (w <= h) {
 945            scaledW = (int) (w / ((double) h / target));
 946            scaledH = (int) target;
 947        } else {
 948            scaledW = (int) target;
 949            scaledH = (int) (h / ((double) w / target));
 950        }
 951        final var small = withOther ? scaledW < target : scaledW < 110 * metrics.density;
 952        final LinearLayout.LayoutParams layoutParams =
 953                new LinearLayout.LayoutParams(scaledW, scaledH);
 954        image.setLayoutParams(layoutParams);
 955
 956        final var bubbleRadius = activity.getResources().getDimension(R.dimen.bubble_radius);
 957        var shape = new ShapeAppearanceModel.Builder().setTopRightCorner(CornerFamily.ROUNDED, bubbleRadius);
 958        if (type == SENT) {
 959            shape = shape.setTopLeftCorner(CornerFamily.ROUNDED, bubbleRadius);
 960        }
 961        if (small) {
 962            final var imageRadius = activity.getResources().getDimension(R.dimen.image_radius);
 963            shape = shape.setAllCorners(CornerFamily.ROUNDED, imageRadius);
 964            image.setPadding(0, (int)(8 * metrics.density), 0, 0);
 965        } else {
 966            image.setPadding(0, 0, 0, 0);
 967        }
 968        image.setShapeAppearanceModel(shape.build());
 969
 970        if (!small) {
 971            final ViewGroup.LayoutParams blayoutParams = viewHolder.messageBody.getLayoutParams();
 972            blayoutParams.width = (int) (target - (22 * metrics.density));
 973            viewHolder.messageBody.setLayoutParams(blayoutParams);
 974        }
 975    }
 976
 977    private void toggleWhisperInfo(
 978            ViewHolder viewHolder, final Message message, final BubbleColor bubbleColor) {
 979        if (message.isPrivateMessage()) {
 980            final String privateMarker;
 981            if (message.getStatus() <= Message.STATUS_RECEIVED) {
 982                privateMarker = activity.getString(R.string.private_message);
 983            } else {
 984                Jid cp = message.getCounterpart();
 985                privateMarker =
 986                        activity.getString(
 987                                R.string.private_message_to,
 988                                Strings.nullToEmpty(cp == null ? null : cp.getResource()));
 989            }
 990            final SpannableString body = new SpannableString(privateMarker);
 991            body.setSpan(
 992                    new ForegroundColorSpan(
 993                            bubbleToOnSurfaceVariant(viewHolder.messageBody, bubbleColor)),
 994                    0,
 995                    privateMarker.length(),
 996                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
 997            body.setSpan(
 998                    new StyleSpan(Typeface.BOLD),
 999                    0,
1000                    privateMarker.length(),
1001                    Spannable.SPAN_EXCLUSIVE_EXCLUSIVE);
1002            viewHolder.messageBody.setText(body);
1003            viewHolder.messageBody.setVisibility(View.VISIBLE);
1004        } else {
1005            viewHolder.messageBody.setVisibility(View.GONE);
1006        }
1007    }
1008
1009    private void loadMoreMessages(Conversation conversation) {
1010        conversation.setLastClearHistory(0, null);
1011        activity.xmppConnectionService.updateConversation(conversation);
1012        conversation.setHasMessagesLeftOnServer(true);
1013        conversation.setFirstMamReference(null);
1014        long timestamp = conversation.getLastMessageTransmitted().getTimestamp();
1015        if (timestamp == 0) {
1016            timestamp = System.currentTimeMillis();
1017        }
1018        conversation.messagesLoaded.set(true);
1019        MessageArchiveService.Query query =
1020                activity.xmppConnectionService
1021                        .getMessageArchiveService()
1022                        .query(conversation, new MamReference(0), timestamp, false);
1023        if (query != null) {
1024            Toast.makeText(activity, R.string.fetching_history_from_server, Toast.LENGTH_LONG)
1025                    .show();
1026        } else {
1027            Toast.makeText(
1028                            activity,
1029                            R.string.not_fetching_history_retention_period,
1030                            Toast.LENGTH_SHORT)
1031                    .show();
1032        }
1033    }
1034
1035    @Override
1036    public View getView(final int position, View view, final @NonNull ViewGroup parent) {
1037        final Message message = getItem(position);
1038        final boolean omemoEncryption = message.getEncryption() == Message.ENCRYPTION_AXOLOTL;
1039        final boolean isInValidSession =
1040                message.isValidInSession() && (!omemoEncryption || message.isTrusted());
1041        final Conversational conversation = message.getConversation();
1042        final Account account = conversation.getAccount();
1043        final List<Element> commands = message.getCommands();
1044        final int type = getItemViewType(position);
1045        ViewHolder viewHolder;
1046        if (view == null) {
1047            viewHolder = new ViewHolder();
1048            switch (type) {
1049                case DATE_SEPARATOR:
1050                    view =
1051                            activity.getLayoutInflater()
1052                                    .inflate(R.layout.item_message_date_bubble, parent, false);
1053                    viewHolder.status_message = view.findViewById(R.id.message_body);
1054                    viewHolder.message_box = view.findViewById(R.id.message_box);
1055                    break;
1056                case RTP_SESSION:
1057                    view =
1058                            activity.getLayoutInflater()
1059                                    .inflate(R.layout.item_message_rtp_session, parent, false);
1060                    viewHolder.status_message = view.findViewById(R.id.message_body);
1061                    viewHolder.message_box = view.findViewById(R.id.message_box);
1062                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1063                    break;
1064                case SENT:
1065                    view = activity.getLayoutInflater().inflate(R.layout.item_message_sent, parent, false);
1066                    viewHolder.status_line = view.findViewById(R.id.status_line);
1067                    viewHolder.message_box_inner = view.findViewById(R.id.message_box_inner);
1068                    viewHolder.message_box = view.findViewById(R.id.message_box);
1069                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1070                    viewHolder.download_button = view.findViewById(R.id.download_button);
1071                    viewHolder.indicator = view.findViewById(R.id.security_indicator);
1072                    viewHolder.edit_indicator = view.findViewById(R.id.edit_indicator);
1073                    viewHolder.image = view.findViewById(R.id.message_image);
1074                    viewHolder.messageBody = view.findViewById(R.id.message_body);
1075                    viewHolder.time = view.findViewById(R.id.message_time);
1076                    viewHolder.subject = view.findViewById(R.id.message_subject);
1077                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1078                    viewHolder.audioPlayer = view.findViewById(R.id.audio_player);
1079                    viewHolder.thread_identicon = view.findViewById(R.id.thread_identicon);
1080                    break;
1081                case RECEIVED:
1082                    view = activity.getLayoutInflater().inflate(R.layout.item_message_received, parent, false);
1083                    viewHolder.status_line = view.findViewById(R.id.status_line);
1084                    viewHolder.message_box_inner = view.findViewById(R.id.message_box_inner);
1085                    viewHolder.message_box = view.findViewById(R.id.message_box);
1086                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1087                    viewHolder.download_button = view.findViewById(R.id.download_button);
1088                    viewHolder.indicator = view.findViewById(R.id.security_indicator);
1089                    viewHolder.edit_indicator = view.findViewById(R.id.edit_indicator);
1090                    viewHolder.image = view.findViewById(R.id.message_image);
1091                    viewHolder.messageBody = view.findViewById(R.id.message_body);
1092                    viewHolder.time = view.findViewById(R.id.message_time);
1093                    viewHolder.subject = view.findViewById(R.id.message_subject);
1094                    viewHolder.indicatorReceived = view.findViewById(R.id.indicator_received);
1095                    viewHolder.encryption = view.findViewById(R.id.message_encryption);
1096                    viewHolder.audioPlayer = view.findViewById(R.id.audio_player);
1097                    viewHolder.commands_list = view.findViewById(R.id.commands_list);
1098                    viewHolder.thread_identicon = view.findViewById(R.id.thread_identicon);
1099                    break;
1100                case STATUS:
1101                    view =
1102                            activity.getLayoutInflater()
1103                                    .inflate(R.layout.item_message_status, parent, false);
1104                    viewHolder.contact_picture = view.findViewById(R.id.message_photo);
1105                    viewHolder.status_message = view.findViewById(R.id.status_message);
1106                    viewHolder.load_more_messages = view.findViewById(R.id.load_more_messages);
1107                    break;
1108                default:
1109                    throw new AssertionError("Unknown view type");
1110            }
1111            view.setTag(viewHolder);
1112        } else {
1113            viewHolder = (ViewHolder) view.getTag();
1114            if (viewHolder == null) {
1115                return view;
1116            }
1117        }
1118
1119        if (viewHolder.messageBody != null) {
1120            viewHolder.messageBody.setCustomSelectionActionModeCallback(new MessageTextActionModeCallback(this, viewHolder.messageBody));
1121        }
1122
1123        if (viewHolder.thread_identicon != null) {
1124            viewHolder.thread_identicon.setVisibility(View.GONE);
1125            final Element thread = message.getThread();
1126            if (thread != null) {
1127                final String threadId = thread.getContent();
1128                if (threadId != null) {
1129                    viewHolder.thread_identicon.setVisibility(View.VISIBLE);
1130                    viewHolder.thread_identicon.setColor(UIHelper.getColorForName(threadId));
1131                    viewHolder.thread_identicon.setHash(UIHelper.identiconHash(threadId));
1132                }
1133            }
1134        }
1135
1136        if (viewHolder.time != null) {
1137            if (message.isAttention()) {
1138                viewHolder.time.setTypeface(null, Typeface.BOLD);
1139            } else {
1140                viewHolder.time.setTypeface(null, Typeface.NORMAL);
1141            }
1142        }
1143
1144        final var black = MaterialColors.getColor(view, com.google.android.material.R.attr.colorSecondaryContainer) == view.getContext().getColor(android.R.color.black);
1145        final boolean colorfulBackground = this.bubbleDesign.colorfulChatBubbles;
1146        final BubbleColor bubbleColor;
1147        if (type == RECEIVED) {
1148            if (isInValidSession) {
1149                bubbleColor = colorfulBackground  || black ? BubbleColor.SECONDARY : BubbleColor.SURFACE;
1150            } else {
1151                bubbleColor = BubbleColor.WARNING;
1152            }
1153        } else {
1154            if (!colorfulBackground && black) {
1155                bubbleColor = BubbleColor.SECONDARY;
1156            } else {
1157                bubbleColor = colorfulBackground ? BubbleColor.TERTIARY : BubbleColor.SURFACE_HIGH;
1158            }
1159        }
1160
1161        if (type == DATE_SEPARATOR) {
1162            if (UIHelper.today(message.getTimeSent())) {
1163                viewHolder.status_message.setText(R.string.today);
1164            } else if (UIHelper.yesterday(message.getTimeSent())) {
1165                viewHolder.status_message.setText(R.string.yesterday);
1166            } else {
1167                viewHolder.status_message.setText(
1168                        DateUtils.formatDateTime(
1169                                activity,
1170                                message.getTimeSent(),
1171                                DateUtils.FORMAT_SHOW_DATE | DateUtils.FORMAT_SHOW_YEAR));
1172            }
1173            if (colorfulBackground) {
1174                setBackgroundTint(viewHolder.message_box, BubbleColor.PRIMARY);
1175                setTextColor(viewHolder.status_message, BubbleColor.PRIMARY);
1176            } else {
1177                setBackgroundTint(viewHolder.message_box, BubbleColor.SURFACE_HIGH);
1178                setTextColor(viewHolder.status_message, BubbleColor.SURFACE_HIGH);
1179            }
1180            return view;
1181        } else if (type == RTP_SESSION) {
1182            final boolean received = message.getStatus() <= Message.STATUS_RECEIVED;
1183            final RtpSessionStatus rtpSessionStatus = RtpSessionStatus.of(message.getBody());
1184            final long duration = rtpSessionStatus.duration;
1185            final String callTime = UIHelper.readableTimeDifferenceFull(activity, message.getTimeSent());
1186            if (received) {
1187                if (duration > 0) {
1188                    viewHolder.status_message.setText(
1189                            activity.getString(
1190                                    R.string.incoming_call_duration_timestamp,
1191                                    TimeFrameUtils.resolve(activity, duration),
1192                                    UIHelper.readableTimeDifferenceFull(
1193                                            activity, message.getTimeSent())));
1194                } else if (rtpSessionStatus.successful) {
1195                    viewHolder.status_message.setText(activity.getString(R.string.incoming_call_timestamp, callTime));
1196                } else {
1197                    viewHolder.status_message.setText(
1198                            activity.getString(
1199                                    R.string.missed_call_timestamp,
1200                                    UIHelper.readableTimeDifferenceFull(
1201                                            activity, message.getTimeSent())));
1202                }
1203            } else {
1204                if (duration > 0) {
1205                    viewHolder.status_message.setText(
1206                            activity.getString(
1207                                    R.string.outgoing_call_duration_timestamp,
1208                                    TimeFrameUtils.resolve(activity, duration),
1209                                    UIHelper.readableTimeDifferenceFull(
1210                                            activity, message.getTimeSent())));
1211                } else {
1212                    viewHolder.status_message.setText(
1213                            activity.getString(
1214                                    R.string.outgoing_call_timestamp,
1215                                    UIHelper.readableTimeDifferenceFull(
1216                                            activity, message.getTimeSent())));
1217                }
1218            }
1219            if (colorfulBackground) {
1220                setBackgroundTint(viewHolder.message_box, BubbleColor.SECONDARY);
1221                setTextColor(viewHolder.status_message, BubbleColor.SECONDARY);
1222                setImageTint(viewHolder.indicatorReceived, BubbleColor.SECONDARY);
1223            } else {
1224                setBackgroundTint(viewHolder.message_box, BubbleColor.SURFACE_HIGH);
1225                setTextColor(viewHolder.status_message, BubbleColor.SURFACE_HIGH);
1226                setImageTint(viewHolder.indicatorReceived, BubbleColor.SURFACE_HIGH);
1227            }
1228            viewHolder.indicatorReceived.setImageResource(
1229                    RtpSessionStatus.getDrawable(received, rtpSessionStatus.successful));
1230            return view;
1231        } else if (type == STATUS) {
1232            if ("LOAD_MORE".equals(message.getBody())) {
1233                viewHolder.status_message.setVisibility(View.GONE);
1234                viewHolder.contact_picture.setVisibility(View.GONE);
1235                viewHolder.load_more_messages.setVisibility(View.VISIBLE);
1236                viewHolder.load_more_messages.setOnClickListener(
1237                        v -> loadMoreMessages((Conversation) message.getConversation()));
1238            } else {
1239                viewHolder.status_message.setVisibility(View.VISIBLE);
1240                viewHolder.load_more_messages.setVisibility(View.GONE);
1241                viewHolder.status_message.setText(message.getBody());
1242                boolean showAvatar;
1243                if (conversation.getMode() == Conversation.MODE_SINGLE) {
1244                    showAvatar = true;
1245                    AvatarWorkerTask.loadAvatar(
1246                            message, viewHolder.contact_picture, R.dimen.avatar_on_status_message);
1247                } else if (message.getCounterpart() != null
1248                        || message.getTrueCounterpart() != null
1249                        || (message.getCounterparts() != null
1250                                && message.getCounterparts().size() > 0)) {
1251                    showAvatar = true;
1252                    AvatarWorkerTask.loadAvatar(
1253                            message, viewHolder.contact_picture, R.dimen.avatar_on_status_message);
1254                } else {
1255                    showAvatar = false;
1256                }
1257                if (showAvatar) {
1258                    viewHolder.contact_picture.setAlpha(0.5f);
1259                    viewHolder.contact_picture.setVisibility(View.VISIBLE);
1260                } else {
1261                    viewHolder.contact_picture.setVisibility(View.GONE);
1262                }
1263            }
1264            return view;
1265        } else {
1266            // viewHolder.message_box.setClipToOutline(true); This eats the bubble tails on A14 for some reason
1267            AvatarWorkerTask.loadAvatar(message, viewHolder.contact_picture, R.dimen.avatar);
1268        }
1269
1270        resetClickListener(viewHolder.message_box, viewHolder.messageBody);
1271
1272        viewHolder.message_box.setOnClickListener(v -> {
1273            if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1274                MessageAdapter.this.mOnMessageBoxClickedListener
1275                        .onContactPictureClicked(message);
1276            }
1277        });
1278        SwipeDetector swipeDetector = new SwipeDetector((action) -> {
1279            if (action == SwipeDetector.Action.LR && MessageAdapter.this.mOnMessageBoxSwipedListener != null) {
1280                MessageAdapter.this.mOnMessageBoxSwipedListener.onContactPictureClicked(message);
1281            }
1282        });
1283        viewHolder.message_box.setOnTouchListener(swipeDetector);
1284        viewHolder.image.setOnTouchListener(swipeDetector);
1285        viewHolder.time.setOnTouchListener(swipeDetector);
1286
1287        // Treat touch-up as click so we don't have to touch twice
1288        // (touch twice is because it's waiting to see if you double-touch for text selection)
1289        viewHolder.messageBody.setOnTouchListener((v, event) -> {
1290            if (event.getAction() == MotionEvent.ACTION_UP) {
1291                if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1292                    MessageAdapter.this.mOnMessageBoxClickedListener
1293                        .onContactPictureClicked(message);
1294                }
1295            }
1296
1297            swipeDetector.onTouch(v, event);
1298
1299            return false;
1300        });
1301        viewHolder.messageBody.setOnClickListener(v -> {
1302            if (MessageAdapter.this.mOnMessageBoxClickedListener != null) {
1303                MessageAdapter.this.mOnMessageBoxClickedListener
1304                        .onContactPictureClicked(message);
1305            }
1306        });
1307        viewHolder.contact_picture.setOnClickListener(v -> {
1308            if (MessageAdapter.this.mOnContactPictureClickedListener != null) {
1309                MessageAdapter.this.mOnContactPictureClickedListener
1310                        .onContactPictureClicked(message);
1311            }
1312
1313        });
1314        viewHolder.contact_picture.setOnLongClickListener(v -> {
1315            if (MessageAdapter.this.mOnContactPictureLongClickedListener != null) {
1316                MessageAdapter.this.mOnContactPictureLongClickedListener
1317                        .onContactPictureLongClicked(v, message);
1318                return true;
1319            } else {
1320                return false;
1321            }
1322        });
1323        viewHolder.messageBody.setAccessibilityDelegate(null);
1324
1325        boolean footerWrap = false;
1326
1327        final Transferable transferable = message.getTransferable();
1328        final boolean unInitiatedButKnownSize = MessageUtils.unInitiatedButKnownSize(message);
1329
1330        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));
1331        if (muted) {
1332            // Muted MUC participant
1333            displayInfoMessage(viewHolder, "Muted", bubbleColor);
1334        } else if (unInitiatedButKnownSize || message.isDeleted() || (transferable != null && transferable.getStatus() != Transferable.STATUS_UPLOADING)) {
1335            if (unInitiatedButKnownSize || (message.isDeleted() && message.getModerated() == null) || transferable != null && transferable.getStatus() == Transferable.STATUS_OFFER) {
1336                displayDownloadableMessage(viewHolder, message, activity.getString(R.string.download_x_file, UIHelper.getFileDescriptionString(activity, message)), bubbleColor, type);
1337            } else if (transferable != null && transferable.getStatus() == Transferable.STATUS_OFFER_CHECK_FILESIZE) {
1338                displayDownloadableMessage(viewHolder, message, activity.getString(R.string.check_x_filesize, UIHelper.getFileDescriptionString(activity, message)), bubbleColor, type);
1339            } else {
1340                displayInfoMessage(viewHolder, UIHelper.getMessagePreview(activity.xmppConnectionService, message).first, bubbleColor);
1341            }
1342        } else if (message.isFileOrImage()
1343                && message.getEncryption() != Message.ENCRYPTION_PGP
1344                && message.getEncryption() != Message.ENCRYPTION_DECRYPTION_FAILED) {
1345            if (message.getFileParams().width > 0 && message.getFileParams().height > 0) {
1346                displayMediaPreviewMessage(viewHolder, message, bubbleColor, type);
1347                if (!black && viewHolder.image.getLayoutParams().width > metrics.density * 110) {
1348                    footerWrap = true;
1349                }
1350            } else if (message.getFileParams().runtime > 0) {
1351                displayAudioMessage(viewHolder, message, bubbleColor, type);
1352            } else if ("application/xdc+zip".equals(message.getFileParams().getMediaType()) && message.getConversation() instanceof Conversation && message.getThread() != null && !message.getFileParams().getCids().isEmpty()) {
1353                displayWebxdcMessage(viewHolder, message, bubbleColor, type);
1354            } else {
1355                displayOpenableMessage(viewHolder, message, bubbleColor, type);
1356            }
1357        } else if (message.getEncryption() == Message.ENCRYPTION_PGP) {
1358            if (account.isPgpDecryptionServiceConnected()) {
1359                if (conversation instanceof Conversation
1360                        && !account.hasPendingPgpIntent((Conversation) conversation)) {
1361                    displayInfoMessage(
1362                            viewHolder,
1363                            activity.getString(R.string.message_decrypting),
1364                            bubbleColor);
1365                } else {
1366                    displayInfoMessage(
1367                            viewHolder, activity.getString(R.string.pgp_message), bubbleColor);
1368                }
1369            } else {
1370                displayInfoMessage(
1371                        viewHolder, activity.getString(R.string.install_openkeychain), bubbleColor);
1372                viewHolder.message_box.setOnClickListener(this::promptOpenKeychainInstall);
1373                viewHolder.messageBody.setOnClickListener(this::promptOpenKeychainInstall);
1374            }
1375        } else if (message.getEncryption() == Message.ENCRYPTION_DECRYPTION_FAILED) {
1376            displayInfoMessage(
1377                    viewHolder, activity.getString(R.string.decryption_failed), bubbleColor);
1378        } else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL_NOT_FOR_THIS_DEVICE) {
1379            displayInfoMessage(
1380                    viewHolder,
1381                    activity.getString(R.string.not_encrypted_for_this_device),
1382                    bubbleColor);
1383        } else if (message.getEncryption() == Message.ENCRYPTION_AXOLOTL_FAILED) {
1384            displayInfoMessage(
1385                    viewHolder, activity.getString(R.string.omemo_decryption_failed), bubbleColor);
1386        } else {
1387            if (message.isGeoUri()) {
1388                displayLocationMessage(viewHolder, message, bubbleColor, type);
1389            } else if (message.treatAsDownloadable()) {
1390                try {
1391                    final URI uri = message.getOob();
1392                    displayDownloadableMessage(viewHolder,
1393                            message,
1394                            activity.getString(
1395                                    R.string.check_x_filesize_on_host,
1396                                    UIHelper.getFileDescriptionString(activity, message),
1397                                    uri.getHost()),
1398                            bubbleColor, type);
1399                } catch (Exception e) {
1400                    displayDownloadableMessage(
1401                            viewHolder,
1402                            message,
1403                            activity.getString(
1404                                    R.string.check_x_filesize,
1405                                    UIHelper.getFileDescriptionString(activity, message)),
1406                            bubbleColor, type);
1407                }
1408            } else if (message.bodyIsOnlyEmojis() && message.getType() != Message.TYPE_PRIVATE) {
1409                displayEmojiMessage(viewHolder, message, bubbleColor, type);
1410            } else {
1411                displayTextMessage(viewHolder, message, bubbleColor, message.getType());
1412            }
1413        }
1414
1415        viewHolder.message_box_inner.setMinimumWidth(footerWrap ? (int) (110 * metrics.density) : 0);
1416        LinearLayout.LayoutParams statusParams = (LinearLayout.LayoutParams) viewHolder.status_line.getLayoutParams();
1417        statusParams.width = footerWrap ? ViewGroup.LayoutParams.MATCH_PARENT : ViewGroup.LayoutParams.WRAP_CONTENT;
1418        viewHolder.status_line.setLayoutParams(statusParams);
1419
1420        setBackgroundTint(viewHolder.message_box, bubbleColor);
1421        setTextColor(viewHolder.messageBody, bubbleColor);
1422        viewHolder.messageBody.setLinkTextColor(bubbleToOnSurfaceColor(viewHolder.messageBody, bubbleColor));
1423
1424        if (type == RECEIVED) {
1425            if (!muted && commands != null && conversation instanceof Conversation) {
1426                CommandButtonAdapter adapter = new CommandButtonAdapter(activity);
1427                adapter.addAll(commands);
1428                viewHolder.commands_list.setAdapter(adapter);
1429                viewHolder.commands_list.setVisibility(View.VISIBLE);
1430                viewHolder.commands_list.setOnItemClickListener((p, v, pos, id) -> {
1431                    final Element command = adapter.getItem(pos);
1432                    activity.startCommand(conversation.getAccount(), command.getAttributeAsJid("jid"), command.getAttribute("node"));
1433                });
1434            } else {
1435                // It's unclear if we can set this to null...
1436                ListAdapter adapter = viewHolder.commands_list.getAdapter();
1437                if (adapter instanceof ArrayAdapter) {
1438                    ((ArrayAdapter<?>) adapter).clear();
1439                }
1440                viewHolder.commands_list.setVisibility(View.GONE);
1441                viewHolder.commands_list.setOnItemClickListener(null);
1442            }
1443
1444            setTextColor(viewHolder.encryption, bubbleColor);
1445
1446            if (isInValidSession) {
1447                viewHolder.encryption.setVisibility(View.GONE);
1448            } else {
1449                viewHolder.encryption.setVisibility(View.VISIBLE);
1450                if (omemoEncryption && !message.isTrusted()) {
1451                    viewHolder.encryption.setText(R.string.not_trusted);
1452                } else {
1453                    viewHolder.encryption.setText(
1454                            CryptoHelper.encryptionTypeToText(message.getEncryption()));
1455                }
1456            }
1457        }
1458
1459        if (type == RECEIVED || type == SENT) {
1460            String subject = message.getSubject();
1461            if (subject == null && message.getThread() != null) {
1462                final var thread = ((Conversation) message.getConversation()).getThread(message.getThread().getContent());
1463                if (thread != null) subject = thread.getSubject();
1464            }
1465            if (muted || subject == null) {
1466                viewHolder.subject.setVisibility(View.GONE);
1467            } else {
1468                viewHolder.subject.setVisibility(View.VISIBLE);
1469                viewHolder.subject.setText(subject);
1470            }
1471        }
1472
1473        displayStatus(viewHolder, message, type, bubbleColor);
1474
1475        viewHolder.messageBody.setAccessibilityDelegate(new View.AccessibilityDelegate() {
1476            @Override
1477            public void sendAccessibilityEvent(View host, int eventType) {
1478                super.sendAccessibilityEvent(host, eventType);
1479                if (eventType == AccessibilityEvent.TYPE_VIEW_TEXT_SELECTION_CHANGED) {
1480                    if (viewHolder.messageBody.hasSelection()) {
1481                        selectionUuid = message.getUuid();
1482                    } else if (message.getUuid() != null && message.getUuid().equals(selectionUuid)) {
1483                        selectionUuid = null;
1484                    }
1485                }
1486            }
1487        });
1488
1489        return view;
1490    }
1491
1492    private void promptOpenKeychainInstall(View view) {
1493        activity.showInstallPgpDialog();
1494    }
1495
1496    public FileBackend getFileBackend() {
1497        return activity.xmppConnectionService.getFileBackend();
1498    }
1499
1500    public void stopAudioPlayer() {
1501        audioPlayer.stop();
1502    }
1503
1504    public void unregisterListenerInAudioPlayer() {
1505        audioPlayer.unregisterListener();
1506    }
1507
1508    public void startStopPending() {
1509        audioPlayer.startStopPending();
1510    }
1511
1512    public void openDownloadable(Message message) {
1513        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU
1514                && ContextCompat.checkSelfPermission(
1515                                activity, Manifest.permission.WRITE_EXTERNAL_STORAGE)
1516                        != PackageManager.PERMISSION_GRANTED) {
1517            ConversationFragment.registerPendingMessage(activity, message);
1518            ActivityCompat.requestPermissions(
1519                    activity,
1520                    new String[] {Manifest.permission.WRITE_EXTERNAL_STORAGE},
1521                    ConversationsActivity.REQUEST_OPEN_MESSAGE);
1522            return;
1523        }
1524        final DownloadableFile file =
1525                activity.xmppConnectionService.getFileBackend().getFile(message);
1526        ViewUtil.view(activity, file);
1527    }
1528
1529    private void showLocation(Message message) {
1530        for (Intent intent : GeoHelper.createGeoIntentsFromMessage(activity, message)) {
1531            if (intent.resolveActivity(getContext().getPackageManager()) != null) {
1532                getContext().startActivity(intent);
1533                return;
1534            }
1535        }
1536        Toast.makeText(
1537                        activity,
1538                        R.string.no_application_found_to_display_location,
1539                        Toast.LENGTH_SHORT)
1540                .show();
1541    }
1542
1543    public void updatePreferences() {
1544        final AppSettings appSettings = new AppSettings(activity);
1545        this.bubbleDesign =
1546                new BubbleDesign(appSettings.isColorfulChatBubbles(), appSettings.isLargeFont());
1547    }
1548
1549    public void setHighlightedTerm(List<String> terms) {
1550        this.highlightedTerm = terms == null ? null : StylingHelper.filterHighlightedWords(terms);
1551    }
1552
1553    public interface OnContactPictureClicked {
1554        void onContactPictureClicked(Message message);
1555    }
1556
1557    public interface OnContactPictureLongClicked {
1558        void onContactPictureLongClicked(View v, Message message);
1559    }
1560
1561    public interface OnInlineImageLongClicked {
1562        boolean onInlineImageLongClicked(Cid cid);
1563    }
1564
1565    private static void setBackgroundTint(final View view, final BubbleColor bubbleColor) {
1566        view.setBackgroundTintList(bubbleToColorStateList(view, bubbleColor));
1567    }
1568
1569    private static ColorStateList bubbleToColorStateList(
1570            final View view, final BubbleColor bubbleColor) {
1571        final @AttrRes int colorAttributeResId =
1572                switch (bubbleColor) {
1573                    case SURFACE -> Activities.isNightMode(view.getContext())
1574                            ? com.google.android.material.R.attr.colorSurfaceContainerHigh
1575                            : com.google.android.material.R.attr.colorSurfaceContainerLow;
1576                    case SURFACE_HIGH -> Activities.isNightMode(view.getContext())
1577                            ? com.google.android.material.R.attr.colorSurfaceContainerHighest
1578                            : com.google.android.material.R.attr.colorSurfaceContainerHigh;
1579                    case PRIMARY -> com.google.android.material.R.attr.colorPrimaryContainer;
1580                    case SECONDARY -> com.google.android.material.R.attr.colorSecondaryContainer;
1581                    case TERTIARY -> com.google.android.material.R.attr.colorTertiaryContainer;
1582                    case WARNING -> com.google.android.material.R.attr.colorErrorContainer;
1583                };
1584        return ColorStateList.valueOf(MaterialColors.getColor(view, colorAttributeResId));
1585    }
1586
1587    public static void setImageTint(final ImageView imageView, final BubbleColor bubbleColor) {
1588        ImageViewCompat.setImageTintList(
1589                imageView, bubbleToOnSurfaceColorStateList(imageView, bubbleColor));
1590    }
1591
1592    public static void setImageTintError(final ImageView imageView) {
1593        ImageViewCompat.setImageTintList(
1594                imageView,
1595                ColorStateList.valueOf(
1596                        MaterialColors.getColor(
1597                                imageView, com.google.android.material.R.attr.colorError)));
1598    }
1599
1600    public static void setTextColor(final TextView textView, final BubbleColor bubbleColor) {
1601        final var color = bubbleToOnSurfaceColor(textView, bubbleColor);
1602        textView.setTextColor(color);
1603        if (BubbleColor.SURFACES.contains(bubbleColor)) {
1604            textView.setLinkTextColor(
1605                    MaterialColors.getColor(
1606                            textView, com.google.android.material.R.attr.colorPrimary));
1607        } else {
1608            textView.setLinkTextColor(color);
1609        }
1610    }
1611
1612    private static void setTextSize(final TextView textView, final boolean largeFont) {
1613        if (largeFont) {
1614            textView.setTextAppearance(
1615                    com.google.android.material.R.style.TextAppearance_Material3_BodyLarge);
1616            textView.setTextSize(android.util.TypedValue.COMPLEX_UNIT_SP, 18);
1617        } else {
1618            textView.setTextAppearance(
1619                    com.google.android.material.R.style.TextAppearance_Material3_BodyMedium);
1620        }
1621    }
1622
1623    private static @ColorInt int bubbleToOnSurfaceVariant(
1624            final View view, final BubbleColor bubbleColor) {
1625        final @AttrRes int colorAttributeResId;
1626        if (BubbleColor.SURFACES.contains(bubbleColor)) {
1627            colorAttributeResId = com.google.android.material.R.attr.colorOnSurfaceVariant;
1628        } else {
1629            colorAttributeResId = bubbleToOnSurface(bubbleColor);
1630        }
1631        return MaterialColors.getColor(view, colorAttributeResId);
1632    }
1633
1634    private static @ColorInt int bubbleToOnSurfaceColor(
1635            final View view, final BubbleColor bubbleColor) {
1636        return MaterialColors.getColor(view, bubbleToOnSurface(bubbleColor));
1637    }
1638
1639    public static ColorStateList bubbleToOnSurfaceColorStateList(
1640            final View view, final BubbleColor bubbleColor) {
1641        return ColorStateList.valueOf(bubbleToOnSurfaceColor(view, bubbleColor));
1642    }
1643
1644    private static @AttrRes int bubbleToOnSurface(final BubbleColor bubbleColor) {
1645        return switch (bubbleColor) {
1646            case SURFACE, SURFACE_HIGH -> com.google.android.material.R.attr.colorOnSurface;
1647            case PRIMARY -> com.google.android.material.R.attr.colorOnPrimaryContainer;
1648            case SECONDARY -> com.google.android.material.R.attr.colorOnSecondaryContainer;
1649            case TERTIARY -> com.google.android.material.R.attr.colorOnTertiaryContainer;
1650            case WARNING -> com.google.android.material.R.attr.colorOnErrorContainer;
1651        };
1652    }
1653
1654    public enum BubbleColor {
1655        SURFACE,
1656        SURFACE_HIGH,
1657        PRIMARY,
1658        SECONDARY,
1659        TERTIARY,
1660        WARNING;
1661
1662        private static final Collection<BubbleColor> SURFACES =
1663                Arrays.asList(BubbleColor.SURFACE, BubbleColor.SURFACE_HIGH);
1664    }
1665
1666    private static class BubbleDesign {
1667        public final boolean colorfulChatBubbles;
1668        public final boolean largeFont;
1669
1670        private BubbleDesign(final boolean colorfulChatBubbles, final boolean largeFont) {
1671            this.colorfulChatBubbles = colorfulChatBubbles;
1672            this.largeFont = largeFont;
1673        }
1674    }
1675
1676    private static class ViewHolder {
1677
1678        public MaterialButton load_more_messages;
1679        public ImageView edit_indicator;
1680        public RelativeLayout audioPlayer;
1681        protected View status_line;
1682        protected LinearLayout message_box;
1683        protected View message_box_inner;
1684        protected MaterialButton download_button;
1685        protected ShapeableImageView image;
1686        protected ImageView indicator;
1687        protected ImageView indicatorReceived;
1688        protected TextView time;
1689        protected TextView subject;
1690        protected TextView messageBody;
1691        protected ImageView contact_picture;
1692        protected TextView status_message;
1693        protected TextView encryption;
1694        protected ListView commands_list;
1695        protected GithubIdenticonView thread_identicon;
1696    }
1697
1698    class ThumbnailTask extends AsyncTask<DownloadableFile, Void, Drawable[]> {
1699        @Override
1700        protected Drawable[] doInBackground(DownloadableFile... params) {
1701            if (isCancelled()) return null;
1702
1703            Drawable[] d = new Drawable[params.length];
1704            for (int i = 0; i < params.length; i++) {
1705                try {
1706                    d[i] = activity.xmppConnectionService.getFileBackend().getThumbnail(params[i], activity.getResources(), (int) (metrics.density * 288), false);
1707                } catch (final IOException e) {
1708                    d[i] = null;
1709                }
1710            }
1711
1712            return d;
1713        }
1714
1715        @Override
1716        protected void onPostExecute(final Drawable[] d) {
1717            if (isCancelled()) return;
1718            activity.xmppConnectionService.updateConversationUi();
1719        }
1720    }
1721}