refactor(reactions): shrink reaction SMS payload and dedupe swipe code

Prepares the send-reactions feature for public release by cutting the
per-reaction SMS size and removing duplicated swipe-action code.

Payload (EmojiReactionRepositoryImpl):
- Stop re-embedding the replied-to text in the hidden payload; it already
  shows in the visible fallback line. The reaction target is resolved by
  sender address + timestamp, and the text-fallback matcher now recovers
  the quote from the visible line.
- Encode the payload at 3 bits per invisible char (8-symbol alphabet)
  instead of 1, and word-cap the visible quote. A reaction's invisible run
  drops from ~1,200 chars (~10-20 SMS segments) to ~83 (1-2 segments).

Deduplication:
- Extract SwipeItemTouchCallback base; ConversationItemTouchCallback and
  MessageItemTouchCallback become thin subclasses (removes dead fields).
- Extract BaseSwipeActionsPresenter and share SwipeActionsView/State;
  delete the cloned MessageSwipeActions View/State. Centralize the message
  swipe-action icon map.
- Merge the two near-identical reaction-send streams in ComposeViewModel.

Minor: enumerate the full emoji set off the main thread in EmojiPicker;
reuse a single Handler for the reaction pulse in MessagesAdapter.

Co-Authored-By: Claude Opus 4.8 <noreply@anthropic.com>
This commit is contained in:
octoshrimpy
2026-06-14 20:26:05 -04:00
parent 2ca015a0ae
commit 1c08c0dc20
13 changed files with 429 additions and 461 deletions
@@ -28,6 +28,7 @@ import dev.octoshrimpy.quik.util.EmojiPatternStrings
import io.realm.Realm import io.realm.Realm
import io.realm.Sort import io.realm.Sort
import timber.log.Timber import timber.log.Timber
import java.io.ByteArrayOutputStream
import javax.inject.Inject import javax.inject.Inject
class EmojiReactionRepositoryImpl @Inject constructor( class EmojiReactionRepositoryImpl @Inject constructor(
@@ -42,11 +43,30 @@ class EmojiReactionRepositoryImpl @Inject constructor(
// by the iOS/Google tapback patterns, and won't appear in normal message text. // by the iOS/Google tapback patterns, and won't appear in normal message text.
private const val ZW_START = '\u2061' // function application private const val ZW_START = '\u2061' // function application
private const val ZW_END = '\u2064' // invisible plus private const val ZW_END = '\u2064' // invisible plus
private const val ZW_ZERO = '\u2062' // invisible times // Alphabet for the payload: 8 distinct BMP default-ignorable code points, so each char
private const val ZW_ONE = '\u2063' // invisible separator // carries 3 bits (vs 1 bit for a two-symbol scheme) and the invisible run is ~1/3 as long.
// All are non-combining, non-bidi, render nothing, survive SMS UCS-2 transport verbatim,
// and are distinct from the sentinels and the U+200A..U+200D pattern chars. (16 symbols /
// 4 bits would need code points that risk a visible glyph or U+FFFD substitution on the
// receiver, so 8 symbols / 3 bits is the densest safe choice.)
private val ZW_ALPHABET = charArrayOf(
'\u2060', // word joiner
'\u2062', // invisible times
'\u2063', // invisible separator
'\u206a', // inhibit symmetric swapping (deprecated format)
'\u206b', // activate symmetric swapping
'\u206c', // inhibit arabic form shaping
'\u206d', // activate arabic form shaping
'\u206e', // national digit shapes
)
private const val ZW_BITS_PER_CHAR = 3
private val ZW_INDEX: Map<Char, Int> =
ZW_ALPHABET.withIndex().associate { (i, c) -> c to i }
private const val PAYLOAD_FIELD_SEPARATOR = '\u001f' // unit separator private const val PAYLOAD_FIELD_SEPARATOR = '\u001f' // unit separator
private const val MAX_PAYLOAD_TEXT = 120 // The replied-to text is shown only in the visible fallback line (not duplicated into the
// payload); cap it so reactions to long messages stay within a couple of SMS segments.
private const val MAX_VISIBLE_WORDS = 20
} }
// We use an ordered map to make sure we can test tapback regexes before generic ones // We use an ordered map to make sure we can test tapback regexes before generic ones
@@ -171,38 +191,53 @@ class EmojiReactionRepositoryImpl @Inject constructor(
override fun buildReactionBody(emoji: String, targetMessage: Message): String { override fun buildReactionBody(emoji: String, targetMessage: Message): String {
val senderAddress = targetMessage.address val senderAddress = targetMessage.address
val timestampMs = targetMessage.date val timestampMs = targetMessage.date
val originalText = targetMessage.getText(false).trim() val originalText = capWords(targetMessage.getText(false).trim())
// Visible, iOS-style fallback so non-quik clients see a clean, readable line. // Visible, iOS-style fallback so non-quik clients see a clean, readable line.
val human = if (originalText.isEmpty()) "Reacted $emoji to a message" val human = if (originalText.isEmpty()) "Reacted $emoji to a message"
else "Reacted $emoji to \"$originalText\"" else "Reacted $emoji to \"$originalText\""
// Machine-readable payload, hidden in zero-width characters and parsed only by quik. // Hidden machine payload, parsed only by quik. The target is resolved by sender address +
// originalText is capped to keep the invisible payload (and thus the SMS) reasonably small. // timestamp, so the body text is NOT duplicated here (it stays only in the visible line
val payload = listOf(emoji, senderAddress, timestampMs.toString(), originalText.take(MAX_PAYLOAD_TEXT)) // above) to keep the SMS short.
val payload = listOf(emoji, senderAddress, timestampMs.toString())
.joinToString(PAYLOAD_FIELD_SEPARATOR.toString()) .joinToString(PAYLOAD_FIELD_SEPARATOR.toString())
return human + encodeQuikPayload(payload) return human + encodeQuikPayload(payload)
} }
/** Cap [text] to [MAX_VISIBLE_WORDS] words, appending an ellipsis when truncated. */
private fun capWords(text: String): String {
val words = text.split(Regex("\\s+")).filter { it.isNotEmpty() }
return if (words.size <= MAX_VISIBLE_WORDS) text.trim()
else words.take(MAX_VISIBLE_WORDS).joinToString(" ") + "…"
}
/** /**
* Encode a UTF-8 string into an invisible run of zero-width characters, wrapped in sentinels. * Encode a UTF-8 string into an invisible run wrapped in sentinels. The byte stream is emitted
* Each byte becomes 8 zero-width bits ([ZW_ZERO]/[ZW_ONE]). * [ZW_BITS_PER_CHAR] bits at a time, each group mapped to one [ZW_ALPHABET] char.
*/ */
private fun encodeQuikPayload(payload: String): String { private fun encodeQuikPayload(payload: String): String {
val sb = StringBuilder() val sb = StringBuilder()
sb.append(ZW_START) sb.append(ZW_START)
var buffer = 0
var bits = 0
for (byte in payload.toByteArray(Charsets.UTF_8)) { for (byte in payload.toByteArray(Charsets.UTF_8)) {
val value = byte.toInt() and 0xFF buffer = (buffer shl 8) or (byte.toInt() and 0xFF)
for (bit in 7 downTo 0) bits += 8
sb.append(if ((value shr bit) and 1 == 1) ZW_ONE else ZW_ZERO) while (bits >= ZW_BITS_PER_CHAR) {
bits -= ZW_BITS_PER_CHAR
sb.append(ZW_ALPHABET[(buffer shr bits) and 0x7])
}
} }
if (bits > 0) // flush the final partial group, zero-padded on the right
sb.append(ZW_ALPHABET[(buffer shl (ZW_BITS_PER_CHAR - bits)) and 0x7])
sb.append(ZW_END) sb.append(ZW_END)
return sb.toString() return sb.toString()
} }
/** /**
* Extract and decode a quik zero-width payload from a message body, or null if absent/invalid. * Extract and decode a quik invisible payload from a message body, or null if absent/invalid.
*/ */
private fun decodeQuikPayload(body: String): String? { private fun decodeQuikPayload(body: String): String? {
val start = body.indexOf(ZW_START) val start = body.indexOf(ZW_START)
@@ -210,17 +245,20 @@ class EmojiReactionRepositoryImpl @Inject constructor(
val end = body.indexOf(ZW_END, start + 1) val end = body.indexOf(ZW_END, start + 1)
if (end == -1) return null if (end == -1) return null
val bits = body.substring(start + 1, end).filter { it == ZW_ZERO || it == ZW_ONE } var buffer = 0
if (bits.isEmpty() || bits.length % 8 != 0) return null var bits = 0
val bytes = ByteArrayOutputStream()
val bytes = ByteArray(bits.length / 8) for (i in start + 1 until end) {
for (i in bytes.indices) { val symbol = ZW_INDEX[body[i]] ?: continue // ignore any stray non-alphabet chars
var value = 0 buffer = (buffer shl ZW_BITS_PER_CHAR) or symbol
for (bit in 0 until 8) bits += ZW_BITS_PER_CHAR
value = (value shl 1) or (if (bits[i * 8 + bit] == ZW_ONE) 1 else 0) if (bits >= 8) {
bytes[i] = value.toByte() bits -= 8
bytes.write((buffer shr bits) and 0xFF)
}
} }
return String(bytes, Charsets.UTF_8) // trailing < 8 bits are zero padding from the encoder and are dropped
return bytes.toByteArray().takeIf { it.isNotEmpty() }?.let { String(it, Charsets.UTF_8) }
} }
private fun parseQuikReaction(body: String): ParsedEmojiReaction? { private fun parseQuikReaction(body: String): ParsedEmojiReaction? {
@@ -229,12 +267,22 @@ class EmojiReactionRepositoryImpl @Inject constructor(
if (parts.size < 3) return null if (parts.size < 3) return null
return ParsedEmojiReaction( return ParsedEmojiReaction(
emoji = parts[0], emoji = parts[0],
originalMessage = parts.getOrElse(3) { "" }, // original text now lives only in the visible line; recover it for the text-fallback
// matcher (the address + timestamp fast path handles the common case)
originalMessage = extractVisibleQuotedText(body),
quikSenderAddress = parts[1].ifEmpty { null }, quikSenderAddress = parts[1].ifEmpty { null },
quikTimestamp = parts[2].toLongOrNull(), quikTimestamp = parts[2].toLongOrNull(),
) )
} }
/** Pull the quoted text out of the visible `Reacted <emoji> to "<text>"` fallback line. */
private fun extractVisibleQuotedText(body: String): String {
val visible = body.substringBefore(ZW_START)
val open = visible.indexOf('"')
val close = visible.lastIndexOf('"')
return if (open != -1 && close > open) visible.substring(open + 1, close) else ""
}
private fun parseRemoval(body: String): ParsedEmojiReaction? { private fun parseRemoval(body: String): ParsedEmojiReaction? {
for ((pattern, parser) in removalPatterns) { for ((pattern, parser) in removalPatterns) {
val match = pattern.find(body) ?: continue val match = pattern.find(body) ?: continue
@@ -29,6 +29,9 @@ import com.google.android.material.bottomsheet.BottomSheetDialog
import dev.octoshrimpy.quik.R import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.common.util.extensions.dpToPx import dev.octoshrimpy.quik.common.util.extensions.dpToPx
import dev.octoshrimpy.quik.common.util.extensions.resolveThemeColor import dev.octoshrimpy.quik.common.util.extensions.resolveThemeColor
import io.reactivex.Single
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
/** /**
* A lightweight, dependency-free emoji picker. Renders a themed, scrollable grid of emoji in a * A lightweight, dependency-free emoji picker. Renders a themed, scrollable grid of emoji in a
@@ -80,6 +83,36 @@ object EmojiPicker {
val sheet = BottomSheetDialog(context) val sheet = BottomSheetDialog(context)
// Show the common emoji immediately; the full set probes thousands of code points for
// glyphs, so it's enumerated off the main thread and appended when ready — opening the
// sheet never blocks the UI thread.
val items = ArrayList(commonEmojis)
val gridAdapter = object : RecyclerView.Adapter<RecyclerView.ViewHolder>() {
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) =
object : RecyclerView.ViewHolder(TextView(context).apply {
textSize = 22f
gravity = Gravity.CENTER
includeFontPadding = false
setTextColor(textColor)
setBackgroundResource(R.drawable.ripple)
layoutParams = RecyclerView.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, cell
)
}) {}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
val emoji = items[position]
(holder.itemView as TextView).text = emoji
holder.itemView.setOnClickListener {
onPicked(emoji)
sheet.dismiss()
}
}
override fun getItemCount() = items.size
}
val recycler = RecyclerView(context).apply { val recycler = RecyclerView(context).apply {
setBackgroundColor(backgroundColor) setBackgroundColor(backgroundColor)
layoutManager = GridLayoutManager(context, span) layoutManager = GridLayoutManager(context, span)
@@ -87,32 +120,23 @@ object EmojiPicker {
ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT,
(context.resources.displayMetrics.heightPixels * 0.5f).toInt() (context.resources.displayMetrics.heightPixels * 0.5f).toInt()
) )
adapter = object : RecyclerView.Adapter<RecyclerView.ViewHolder>() { adapter = gridAdapter
override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) =
object : RecyclerView.ViewHolder(TextView(context).apply {
textSize = 22f
gravity = Gravity.CENTER
includeFontPadding = false
setTextColor(textColor)
setBackgroundResource(R.drawable.ripple)
layoutParams = RecyclerView.LayoutParams(
ViewGroup.LayoutParams.MATCH_PARENT, cell
)
}) {}
override fun onBindViewHolder(holder: RecyclerView.ViewHolder, position: Int) {
val emoji = emojis[position]
(holder.itemView as TextView).text = emoji
holder.itemView.setOnClickListener {
onPicked(emoji)
sheet.dismiss()
}
}
override fun getItemCount() = emojis.size
}
} }
// emojis starts with commonEmojis (distinct), so only the generated tail is appended
val load = Single.fromCallable { emojis }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
.subscribe { full ->
val tail = full.drop(items.size)
if (tail.isNotEmpty()) {
val start = items.size
items.addAll(tail)
gridAdapter.notifyItemRangeInserted(start, tail.size)
}
}
sheet.setOnDismissListener { load.dispose() }
sheet.setContentView(recycler) sheet.setContentView(recycler)
sheet.show() sheet.show()
} }
@@ -0,0 +1,160 @@
/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package dev.octoshrimpy.quik.common.util
import android.content.Context
import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Rect
import androidx.core.graphics.drawable.toBitmap
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
import dev.octoshrimpy.quik.common.util.extensions.dpToPx
import io.reactivex.Observable
import io.reactivex.disposables.CompositeDisposable
import io.reactivex.rxkotlin.Observables
import io.reactivex.rxkotlin.plusAssign
import io.reactivex.schedulers.Schedulers
import io.reactivex.subjects.PublishSubject
import io.reactivex.subjects.Subject
import kotlin.math.max
import kotlin.math.min
/**
* Shared swipe-to-action behaviour for the conversations list and the messages list: draws the
* themed background and action icon while a row is swiped, and emits `(itemId, direction)` on
* release. Subclasses supply which prefs drive the left/right actions, how an action maps to an
* icon, and (optionally) what to do after a swipe completes.
*/
abstract class SwipeItemTouchCallback(
colors: Colors,
disposables: CompositeDisposable,
private val context: Context
) : ItemTouchHelper.SimpleCallback(0, 0) {
val swipes: Subject<Pair<Long, Int>> = PublishSubject.create()
/**
* Setting the adapter allows us to animate back to the original position
*/
var adapter: RecyclerView.Adapter<*>? = null
private val backgroundPaint = Paint()
protected var rightAction = 0
protected var leftAction = 0
private var swipeRightIcon: Bitmap? = null
private var swipeLeftIcon: Bitmap? = null
private val iconLength = 24.dpToPx(context)
/** Action value that means "no swipe action" (0 for both lists). */
protected abstract val noneAction: Int
protected abstract fun rightActionObservable(): Observable<Int>
protected abstract fun leftActionObservable(): Observable<Int>
protected abstract fun iconForAction(action: Int, tint: Int): Bitmap?
init {
disposables += colors.themeObservable()
.doOnNext { theme -> backgroundPaint.color = theme.theme }
.subscribeOn(Schedulers.io())
.subscribe()
disposables += Observables
.combineLatest(rightActionObservable(), leftActionObservable(), colors.themeObservable()
) { right, left, theme ->
rightAction = right
swipeRightIcon = iconForAction(right, theme.textPrimary)
leftAction = left
swipeLeftIcon = iconForAction(left, theme.textPrimary)
setDefaultSwipeDirs((if (right == noneAction) 0 else ItemTouchHelper.RIGHT)
or (if (left == noneAction) 0 else ItemTouchHelper.LEFT))
}
.subscribeOn(Schedulers.io())
.subscribe()
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder
): Boolean {
return false
}
override fun onChildDraw(
c: Canvas,
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
dX: Float,
dY: Float,
actionState: Int,
isCurrentlyActive: Boolean
) {
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
val itemView = viewHolder.itemView
if (dX > 0) {
c.drawRect(itemView.left.toFloat(), itemView.top.toFloat(),
dX, itemView.bottom.toFloat(), backgroundPaint)
swipeRightIcon?.let { icon ->
val availablePx = dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(0, 0, min(availablePx, icon.width), icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(iconLength, dstTop, iconLength + src.width(), dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
} else if (dX < 0) {
c.drawRect(itemView.right.toFloat() + dX, itemView.top.toFloat(),
itemView.right.toFloat(), itemView.bottom.toFloat(), backgroundPaint)
swipeLeftIcon?.let { icon ->
val availablePx = -dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(max(0, icon.width - availablePx), 0, icon.width, icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(itemView.right - iconLength - src.width(), dstTop,
itemView.right - iconLength, dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
}
super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
}
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
swipes.onNext(Pair(viewHolder.itemId, direction))
// Default: nothing is removed by a swipe, so always animate back to neutral
adapter?.notifyItemChanged(viewHolder.adapterPosition)
}
/** Convert a drawable resource into a tinted, icon-sized bitmap. */
protected fun actionBitmap(@androidx.annotation.DrawableRes res: Int?, tint: Int): Bitmap? =
res?.let(context.resources::getDrawable)
?.apply { setTint(tint) }
?.toBitmap(iconLength, iconLength)
}
@@ -789,10 +789,13 @@ class ComposeViewModel @Inject constructor(
.autoDisposable(view.scope()) .autoDisposable(view.scope())
.subscribe { messageId -> view.showReactionPicker(messageId) } .subscribe { messageId -> view.showReactionPicker(messageId) }
// Send a reaction: build a quik-encoded body and send it as a normal message. The sent // Send a reaction — from the picker (sendReactionIntent) or the configured default reaction
// message comes back to this device and is parsed as a reaction (isEmojiReaction = true), // on double-tap. Build a quik-encoded body and send it as a normal message; the sent
// so it is hidden from the conversation automatically. // message comes back to this device, is parsed as a reaction (isEmojiReaction = true), and
view.sendReactionIntent // is hidden from the conversation automatically.
Observable.merge(
view.sendReactionIntent,
view.doubleTapMessageIntent.map { messageId -> Pair(messageId, prefs.defaultReactionEmoji.get()) })
// permission checks touch the UI, so keep them on the main thread // permission checks touch the UI, so keep them on the main thread
.observeOn(AndroidSchedulers.mainThread()) .observeOn(AndroidSchedulers.mainThread())
.filter { .filter {
@@ -822,34 +825,6 @@ class ComposeViewModel @Inject constructor(
messageRepo.sendNewMessages(subId, addresses, body, emptyList(), sendAsGroup) messageRepo.sendNewMessages(subId, addresses, body, emptyList(), sendAsGroup)
} }
// Double-tap a message sends the configured default reaction
view.doubleTapMessageIntent
.observeOn(AndroidSchedulers.mainThread())
.filter {
when {
!permissionManager.isDefaultSms() -> { view.requestDefaultSms(); false }
!permissionManager.hasSendSms() -> { view.requestSmsPermission(); false }
else -> true
}
}
.observeOn(Schedulers.io())
.withLatestFrom(state, conversation) { messageId, state, conversation ->
Triple(messageId, state, conversation)
}
.autoDisposable(view.scope())
.subscribe { (messageId, state, conversation) ->
val targetMessage = messageRepo.getMessage(messageId) ?: return@subscribe
val addresses = conversation.recipients.map { it.address }
if (addresses.isEmpty()) return@subscribe
val subId = state.subscription?.subscriptionId ?: -1
val sendAsGroup = addresses.size > 1
val emoji = prefs.defaultReactionEmoji.get()
val body = reactions.buildReactionBody(emoji, targetMessage)
messageRepo.sendNewMessages(subId, addresses, body, emptyList(), sendAsGroup)
}
// Configurable message swipe actions // Configurable message swipe actions
view.swipeMessageIntent view.swipeMessageIntent
.observeOn(AndroidSchedulers.mainThread()) .observeOn(AndroidSchedulers.mainThread())
@@ -20,141 +20,29 @@ package dev.octoshrimpy.quik.feature.compose
import android.content.Context import android.content.Context
import android.graphics.Bitmap import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Rect
import androidx.core.graphics.drawable.toBitmap
import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView
import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.common.util.Colors import dev.octoshrimpy.quik.common.util.Colors
import dev.octoshrimpy.quik.common.util.extensions.dpToPx import dev.octoshrimpy.quik.common.util.SwipeItemTouchCallback
import dev.octoshrimpy.quik.feature.settings.swipe.messageSwipeActionIcon
import dev.octoshrimpy.quik.util.Preferences import dev.octoshrimpy.quik.util.Preferences
import io.reactivex.Observable
import io.reactivex.disposables.CompositeDisposable import io.reactivex.disposables.CompositeDisposable
import io.reactivex.rxkotlin.Observables
import io.reactivex.rxkotlin.plusAssign
import io.reactivex.schedulers.Schedulers
import io.reactivex.subjects.PublishSubject
import io.reactivex.subjects.Subject
import javax.inject.Inject import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min
class MessageItemTouchCallback @Inject constructor( class MessageItemTouchCallback @Inject constructor(
colors: Colors, colors: Colors,
disposables: CompositeDisposable, disposables: CompositeDisposable,
prefs: Preferences, private val prefs: Preferences,
private val context: Context context: Context
) : ItemTouchHelper.SimpleCallback(0, 0) { ) : SwipeItemTouchCallback(colors, disposables, context) {
val swipes: Subject<Pair<Long, Int>> = PublishSubject.create() override val noneAction = Preferences.MESSAGE_SWIPE_ACTION_NONE
/** override fun rightActionObservable(): Observable<Int> = prefs.messageSwipeRight.asObservable()
* Setting the adapter allows us to animate back to the original position override fun leftActionObservable(): Observable<Int> = prefs.messageSwipeLeft.asObservable()
*/
var adapter: RecyclerView.Adapter<*>? = null
private val backgroundPaint = Paint() override fun iconForAction(action: Int, tint: Int): Bitmap? =
private var rightAction = 0 actionBitmap(messageSwipeActionIcon(action).takeIf { it != 0 }, tint)
private var swipeRightIcon: Bitmap? = null
private var leftAction = 0
private var swipeLeftIcon: Bitmap? = null
private val iconLength = 24.dpToPx(context)
init {
disposables += colors.themeObservable()
.doOnNext { theme -> backgroundPaint.color = theme.theme }
.subscribeOn(Schedulers.io())
.subscribe()
disposables += Observables
.combineLatest(prefs.messageSwipeRight.asObservable(), prefs.messageSwipeLeft.asObservable(), colors.themeObservable()
) { right, left, theme ->
rightAction = right
swipeRightIcon = iconForAction(right, theme.textPrimary)
leftAction = left
swipeLeftIcon = iconForAction(left, theme.textPrimary)
setDefaultSwipeDirs((if (right == Preferences.MESSAGE_SWIPE_ACTION_NONE) 0 else ItemTouchHelper.RIGHT)
or (if (left == Preferences.MESSAGE_SWIPE_ACTION_NONE) 0 else ItemTouchHelper.LEFT))
}
.subscribeOn(Schedulers.io())
.subscribe()
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder
): Boolean {
return false
}
override fun onChildDraw(
c: Canvas,
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
dX: Float,
dY: Float,
actionState: Int,
isCurrentlyActive: Boolean
) {
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
val itemView = viewHolder.itemView
if (dX > 0) {
c.drawRect(itemView.left.toFloat(), itemView.top.toFloat(),
dX, itemView.bottom.toFloat(), backgroundPaint)
swipeRightIcon?.let { icon ->
val availablePx = dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(0, 0, min(availablePx, icon.width), icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(iconLength, dstTop, iconLength + src.width(), dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
} else if (dX < 0) {
c.drawRect(itemView.right.toFloat() + dX, itemView.top.toFloat(),
itemView.right.toFloat(), itemView.bottom.toFloat(), backgroundPaint)
swipeLeftIcon?.let { icon ->
val availablePx = -dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(max(0, icon.width - availablePx), 0, icon.width, icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(itemView.right - iconLength - src.width(), dstTop,
itemView.right - iconLength, dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
}
super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
}
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
swipes.onNext(Pair(viewHolder.itemId, direction))
// Messages are never archived/removed by a swipe, so always snap back to neutral
adapter?.notifyItemChanged(viewHolder.adapterPosition)
}
private fun iconForAction(action: Int, tint: Int): Bitmap? {
val res = when (action) {
Preferences.MESSAGE_SWIPE_ACTION_REACT -> R.drawable.ic_favorite_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_REPLY -> R.drawable.ic_reply_white_24dp
Preferences.MESSAGE_SWIPE_ACTION_COPY -> R.drawable.ic_content_copy_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_FORWARD -> R.drawable.ic_forward_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
else -> null
}
return res?.let(context.resources::getDrawable)
?.apply { setTint(tint) }
?.toBitmap(iconLength, iconLength)
}
// Messages are never archived/removed by a swipe, so the base onSwiped (always snap back to
// neutral) is exactly what we want.
} }
@@ -123,6 +123,8 @@ class MessagesAdapter @Inject constructor(
private var pendingReactionPulse = false private var pendingReactionPulse = false
private var reactionPulseOrder = 0 private var reactionPulseOrder = 0
private val pulsedReactionIds = mutableSetOf<Long>() private val pulsedReactionIds = mutableSetOf<Long>()
private val mainHandler = Handler(Looper.getMainLooper())
private val clearReactionPulse = Runnable { pendingReactionPulse = false }
// click events passed back to compose view model // click events passed back to compose view model
val partClicks: Subject<Long> = PublishSubject.create() val partClicks: Subject<Long> = PublishSubject.create()
@@ -148,7 +150,8 @@ class MessagesAdapter @Inject constructor(
if (value?.first?.lastMessage?.isEmojiReaction == true && !pendingReactionPulse) { if (value?.first?.lastMessage?.isEmojiReaction == true && !pendingReactionPulse) {
pendingReactionPulse = true pendingReactionPulse = true
reactionPulseOrder = 0 reactionPulseOrder = 0
Handler(Looper.getMainLooper()).postDelayed({ pendingReactionPulse = false }, 1500) mainHandler.removeCallbacks(clearReactionPulse)
mainHandler.postDelayed(clearReactionPulse, 1500)
} }
updateData(value?.second) updateData(value?.second)
@@ -20,146 +20,47 @@ package dev.octoshrimpy.quik.feature.conversations
import android.content.Context import android.content.Context
import android.graphics.Bitmap import android.graphics.Bitmap
import android.graphics.Canvas
import android.graphics.Paint
import android.graphics.Rect
import androidx.core.graphics.drawable.toBitmap
import androidx.recyclerview.widget.ItemTouchHelper import androidx.recyclerview.widget.ItemTouchHelper
import androidx.recyclerview.widget.RecyclerView import androidx.recyclerview.widget.RecyclerView
import dev.octoshrimpy.quik.R import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.common.util.Colors import dev.octoshrimpy.quik.common.util.Colors
import dev.octoshrimpy.quik.common.util.extensions.dpToPx import dev.octoshrimpy.quik.common.util.SwipeItemTouchCallback
import dev.octoshrimpy.quik.util.Preferences import dev.octoshrimpy.quik.util.Preferences
import io.reactivex.Observable
import io.reactivex.disposables.CompositeDisposable import io.reactivex.disposables.CompositeDisposable
import io.reactivex.rxkotlin.Observables
import io.reactivex.rxkotlin.plusAssign
import io.reactivex.schedulers.Schedulers
import io.reactivex.subjects.PublishSubject
import io.reactivex.subjects.Subject
import javax.inject.Inject import javax.inject.Inject
import kotlin.math.max
import kotlin.math.min
class ConversationItemTouchCallback @Inject constructor( class ConversationItemTouchCallback @Inject constructor(
colors: Colors, colors: Colors,
disposables: CompositeDisposable, disposables: CompositeDisposable,
prefs: Preferences, private val prefs: Preferences,
private val context: Context context: Context
) : ItemTouchHelper.SimpleCallback(0, 0) { ) : SwipeItemTouchCallback(colors, disposables, context) {
val swipes: Subject<Pair<Long, Int>> = PublishSubject.create() override val noneAction = Preferences.SWIPE_ACTION_NONE
/** override fun rightActionObservable(): Observable<Int> = prefs.swipeRight.asObservable()
* Setting the adapter allows us to animate back to the original position override fun leftActionObservable(): Observable<Int> = prefs.swipeLeft.asObservable()
*/
var adapter: RecyclerView.Adapter<*>? = null
private val backgroundPaint = Paint() override fun iconForAction(action: Int, tint: Int): Bitmap? = actionBitmap(when (action) {
private var rightAction = 0 Preferences.SWIPE_ACTION_ARCHIVE -> R.drawable.ic_archive_white_24dp
private var swipeRightIcon: Bitmap? = null Preferences.SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
private var leftAction = 0 Preferences.SWIPE_ACTION_BLOCK -> R.drawable.ic_block_white_24dp
private var swipeLeftIcon: Bitmap? = null Preferences.SWIPE_ACTION_CALL -> R.drawable.ic_call_white_24dp
Preferences.SWIPE_ACTION_READ -> R.drawable.ic_check_white_24dp
private val iconLength = 24.dpToPx(context) Preferences.SWIPE_ACTION_UNREAD -> R.drawable.ic_markunread_black_24dp
Preferences.SWIPE_ACTION_SPEAK -> R.drawable.ic_speaker_black_24dp
init { else -> null
disposables += colors.themeObservable() }, tint)
.doOnNext { theme -> backgroundPaint.color = theme.theme }
.subscribeOn(Schedulers.io())
.subscribe()
disposables += Observables
.combineLatest(prefs.swipeRight.asObservable(), prefs.swipeLeft.asObservable(), colors.themeObservable()
) { right, left, theme ->
rightAction = right
swipeRightIcon = iconForAction(right, theme.textPrimary)
leftAction = left
swipeLeftIcon = iconForAction(left, theme.textPrimary)
setDefaultSwipeDirs((if (right == Preferences.SWIPE_ACTION_NONE) 0 else ItemTouchHelper.RIGHT)
or (if (left == Preferences.SWIPE_ACTION_NONE) 0 else ItemTouchHelper.LEFT))
}
.subscribeOn(Schedulers.io())
.subscribe()
}
override fun onMove(
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
target: RecyclerView.ViewHolder
): Boolean {
return false
}
override fun onChildDraw(
c: Canvas,
recyclerView: RecyclerView,
viewHolder: RecyclerView.ViewHolder,
dX: Float,
dY: Float,
actionState: Int,
isCurrentlyActive: Boolean
) {
if (actionState == ItemTouchHelper.ACTION_STATE_SWIPE) {
val itemView = viewHolder.itemView
if (dX > 0) {
c.drawRect(itemView.left.toFloat(), itemView.top.toFloat(),
dX, itemView.bottom.toFloat(), backgroundPaint)
swipeRightIcon?.let { icon ->
val availablePx = dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(0, 0, min(availablePx, icon.width), icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(iconLength, dstTop, iconLength + src.width(), dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
} else if (dX < 0) {
c.drawRect(itemView.right.toFloat() + dX, itemView.top.toFloat(),
itemView.right.toFloat(), itemView.bottom.toFloat(), backgroundPaint)
swipeLeftIcon?.let { icon ->
val availablePx = -dX.toInt() - iconLength
if (availablePx > 0) {
val src = Rect(max(0, icon.width - availablePx), 0, icon.width, icon.height)
val dstTop = itemView.top + (itemView.bottom - itemView.top - icon.height) / 2
val dst = Rect(itemView.right - iconLength - src.width(), dstTop,
itemView.right - iconLength, dstTop + src.height())
c.drawBitmap(icon, src, dst, null)
}
}
}
super.onChildDraw(c, recyclerView, viewHolder, dX, dY, actionState, isCurrentlyActive)
}
}
override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) { override fun onSwiped(viewHolder: RecyclerView.ViewHolder, direction: Int) {
swipes.onNext(Pair(viewHolder.itemId, direction)) swipes.onNext(Pair(viewHolder.itemId, direction))
// This will trigger the animation back to neutral state // Archive removes the row, so only animate back to neutral for the other actions
val action = if (direction == ItemTouchHelper.RIGHT) rightAction else leftAction val action = if (direction == ItemTouchHelper.RIGHT) rightAction else leftAction
if (action != Preferences.SWIPE_ACTION_ARCHIVE) { if (action != Preferences.SWIPE_ACTION_ARCHIVE) {
adapter?.notifyItemChanged(viewHolder.adapterPosition) adapter?.notifyItemChanged(viewHolder.adapterPosition)
} }
} }
private fun iconForAction(action: Int, tint: Int): Bitmap? { }
val res = when (action) {
Preferences.SWIPE_ACTION_ARCHIVE -> R.drawable.ic_archive_white_24dp
Preferences.SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
Preferences.SWIPE_ACTION_BLOCK -> R.drawable.ic_block_white_24dp
Preferences.SWIPE_ACTION_CALL -> R.drawable.ic_call_white_24dp
Preferences.SWIPE_ACTION_READ -> R.drawable.ic_check_white_24dp
Preferences.SWIPE_ACTION_UNREAD -> R.drawable.ic_markunread_black_24dp
Preferences.SWIPE_ACTION_SPEAK -> R.drawable.ic_speaker_black_24dp
else -> null
}
return res?.let(context.resources::getDrawable)
?.apply { setTint(tint) }
?.toBitmap(iconLength, iconLength)
}
}
@@ -0,0 +1,79 @@
/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package dev.octoshrimpy.quik.feature.settings.swipe
import android.content.Context
import androidx.annotation.ArrayRes
import androidx.annotation.DrawableRes
import com.f2prateek.rx.preferences2.Preference
import com.uber.autodispose.android.lifecycle.scope
import com.uber.autodispose.autoDisposable
import dev.octoshrimpy.quik.common.base.QkPresenter
import io.reactivex.rxkotlin.plusAssign
/**
* Shared presenter for the two "swipe actions" settings screens (conversations and messages). The
* screens are identical apart from which prefs back the left/right action, the labels array, and
* how an action maps to an icon, so subclasses supply only those.
*/
abstract class BaseSwipeActionsPresenter(
context: Context,
@ArrayRes labelsArrayRes: Int,
private val rightPref: Preference<Int>,
private val leftPref: Preference<Int>
) : QkPresenter<SwipeActionsView, SwipeActionsState>(SwipeActionsState()) {
private val actionLabels = context.resources.getStringArray(labelsArrayRes)
init {
disposables += rightPref.asObservable()
.subscribe { action -> newState { copy(rightLabel = actionLabels[action], rightIcon = iconForAction(action)) } }
disposables += leftPref.asObservable()
.subscribe { action -> newState { copy(leftLabel = actionLabels[action], leftIcon = iconForAction(action)) } }
}
override fun bindIntents(view: SwipeActionsView) {
super.bindIntents(view)
view.actionClicks()
.map { action ->
when (action) {
SwipeActionsView.Action.RIGHT -> rightPref.get()
SwipeActionsView.Action.LEFT -> leftPref.get()
}
}
.autoDisposable(view.scope())
.subscribe(view::showSwipeActions)
view.actionSelected()
.withLatestFrom(view.actionClicks()) { actionId, action ->
when (action) {
SwipeActionsView.Action.RIGHT -> rightPref.set(actionId)
SwipeActionsView.Action.LEFT -> leftPref.set(actionId)
}
}
.autoDisposable(view.scope())
.subscribe()
}
@DrawableRes
protected abstract fun iconForAction(action: Int): Int
}
@@ -20,11 +20,15 @@ package dev.octoshrimpy.quik.feature.settings.swipe
import androidx.annotation.DrawableRes import androidx.annotation.DrawableRes
import dev.octoshrimpy.quik.R import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.util.Preferences
data class MessageSwipeActionsState( /** Drawable shown for a message swipe [action], or 0 when there is no icon. */
@DrawableRes val rightIcon: Int = R.drawable.ic_favorite_black_24dp, @DrawableRes
val rightLabel: String = "", fun messageSwipeActionIcon(action: Int): Int = when (action) {
Preferences.MESSAGE_SWIPE_ACTION_REACT -> R.drawable.ic_favorite_black_24dp
@DrawableRes val leftIcon: Int = R.drawable.ic_reply_white_24dp, Preferences.MESSAGE_SWIPE_ACTION_REPLY -> R.drawable.ic_reply_white_24dp
val leftLabel: String = "" Preferences.MESSAGE_SWIPE_ACTION_COPY -> R.drawable.ic_content_copy_black_24dp
) Preferences.MESSAGE_SWIPE_ACTION_FORWARD -> R.drawable.ic_forward_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
else -> 0
}
@@ -39,7 +39,7 @@ import io.reactivex.subjects.PublishSubject
import io.reactivex.subjects.Subject import io.reactivex.subjects.Subject
import javax.inject.Inject import javax.inject.Inject
class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding, MessageSwipeActionsView, MessageSwipeActionsState, MessageSwipeActionsPresenter>(), MessageSwipeActionsView { class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding, SwipeActionsView, SwipeActionsState, MessageSwipeActionsPresenter>(), SwipeActionsView {
override fun inflateBinding(inflater: LayoutInflater, container: ViewGroup): SwipeActionsControllerBinding = override fun inflateBinding(inflater: LayoutInflater, container: ViewGroup): SwipeActionsControllerBinding =
SwipeActionsControllerBinding.inflate(inflater, container, false) SwipeActionsControllerBinding.inflate(inflater, container, false)
@@ -51,7 +51,7 @@ class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding
/** /**
* Allows us to subscribe to [actionClicks] more than once * Allows us to subscribe to [actionClicks] more than once
*/ */
private val actionClicks: Subject<MessageSwipeActionsView.Action> = PublishSubject.create() private val actionClicks: Subject<SwipeActionsView.Action> = PublishSubject.create()
init { init {
appComponent.inject(this) appComponent.inject(this)
@@ -71,8 +71,8 @@ class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding
binding.left.postDelayed({ binding.left.animateLayoutChanges = true }, 100) binding.left.postDelayed({ binding.left.animateLayoutChanges = true }, 100)
Observable.merge( Observable.merge(
binding.right.clicks().map { MessageSwipeActionsView.Action.RIGHT }, binding.right.clicks().map { SwipeActionsView.Action.RIGHT },
binding.left.clicks().map { MessageSwipeActionsView.Action.LEFT }) binding.left.clicks().map { SwipeActionsView.Action.LEFT })
.autoDisposable(scope()) .autoDisposable(scope())
.subscribe(actionClicks) .subscribe(actionClicks)
} }
@@ -84,7 +84,7 @@ class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding
showBackButton(true) showBackButton(true)
} }
override fun actionClicks(): Observable<MessageSwipeActionsView.Action> = actionClicks override fun actionClicks(): Observable<SwipeActionsView.Action> = actionClicks
override fun actionSelected(): Observable<Int> = actionsDialog.adapter.menuItemClicks override fun actionSelected(): Observable<Int> = actionsDialog.adapter.menuItemClicks
@@ -93,7 +93,7 @@ class MessageSwipeActionsController : QkController<SwipeActionsControllerBinding
activity?.let(actionsDialog::show) activity?.let(actionsDialog::show)
} }
override fun render(state: MessageSwipeActionsState) { override fun render(state: SwipeActionsState) {
binding.rightIcon.isVisible = state.rightIcon != 0 binding.rightIcon.isVisible = state.rightIcon != 0
binding.rightIcon.setImageResource(state.rightIcon) binding.rightIcon.setImageResource(state.rightIcon)
binding.rightLabel.text = state.rightLabel binding.rightLabel.text = state.rightLabel
@@ -20,61 +20,18 @@ package dev.octoshrimpy.quik.feature.settings.swipe
import android.content.Context import android.content.Context
import androidx.annotation.DrawableRes import androidx.annotation.DrawableRes
import com.uber.autodispose.android.lifecycle.scope
import com.uber.autodispose.autoDisposable
import dev.octoshrimpy.quik.R import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.common.base.QkPresenter
import dev.octoshrimpy.quik.util.Preferences import dev.octoshrimpy.quik.util.Preferences
import io.reactivex.rxkotlin.plusAssign
import javax.inject.Inject import javax.inject.Inject
class MessageSwipeActionsPresenter @Inject constructor( class MessageSwipeActionsPresenter @Inject constructor(
context: Context, context: Context,
private val prefs: Preferences prefs: Preferences
) : QkPresenter<MessageSwipeActionsView, MessageSwipeActionsState>(MessageSwipeActionsState()) { ) : BaseSwipeActionsPresenter(
context, R.array.settings_message_swipe_actions, prefs.messageSwipeRight, prefs.messageSwipeLeft
init { ) {
val actionLabels = context.resources.getStringArray(R.array.settings_message_swipe_actions)
disposables += prefs.messageSwipeRight.asObservable()
.subscribe { action -> newState { copy(rightLabel = actionLabels[action], rightIcon = iconForAction(action)) } }
disposables += prefs.messageSwipeLeft.asObservable()
.subscribe { action -> newState { copy(leftLabel = actionLabels[action], leftIcon = iconForAction(action)) } }
}
override fun bindIntents(view: MessageSwipeActionsView) {
super.bindIntents(view)
view.actionClicks()
.map { action ->
when (action) {
MessageSwipeActionsView.Action.RIGHT -> prefs.messageSwipeRight.get()
MessageSwipeActionsView.Action.LEFT -> prefs.messageSwipeLeft.get()
}
}
.autoDisposable(view.scope())
.subscribe(view::showSwipeActions)
view.actionSelected()
.withLatestFrom(view.actionClicks()) { actionId, action ->
when (action) {
MessageSwipeActionsView.Action.RIGHT -> prefs.messageSwipeRight.set(actionId)
MessageSwipeActionsView.Action.LEFT -> prefs.messageSwipeLeft.set(actionId)
}
}
.autoDisposable(view.scope())
.subscribe()
}
@DrawableRes @DrawableRes
private fun iconForAction(action: Int) = when (action) { override fun iconForAction(action: Int) = messageSwipeActionIcon(action)
Preferences.MESSAGE_SWIPE_ACTION_REACT -> R.drawable.ic_favorite_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_REPLY -> R.drawable.ic_reply_white_24dp
Preferences.MESSAGE_SWIPE_ACTION_COPY -> R.drawable.ic_content_copy_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_FORWARD -> R.drawable.ic_forward_black_24dp
Preferences.MESSAGE_SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
else -> 0
}
} }
@@ -1,33 +0,0 @@
/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package dev.octoshrimpy.quik.feature.settings.swipe
import dev.octoshrimpy.quik.common.base.QkViewContract
import io.reactivex.Observable
interface MessageSwipeActionsView : QkViewContract<MessageSwipeActionsState> {
enum class Action { LEFT, RIGHT }
fun actionClicks(): Observable<Action>
fun actionSelected(): Observable<Int>
fun showSwipeActions(selected: Int)
}
@@ -20,55 +20,17 @@ package dev.octoshrimpy.quik.feature.settings.swipe
import android.content.Context import android.content.Context
import androidx.annotation.DrawableRes import androidx.annotation.DrawableRes
import com.uber.autodispose.android.lifecycle.scope
import com.uber.autodispose.autoDisposable
import dev.octoshrimpy.quik.R import dev.octoshrimpy.quik.R
import dev.octoshrimpy.quik.common.base.QkPresenter
import dev.octoshrimpy.quik.util.Preferences import dev.octoshrimpy.quik.util.Preferences
import io.reactivex.rxkotlin.plusAssign
import javax.inject.Inject import javax.inject.Inject
class SwipeActionsPresenter @Inject constructor( class SwipeActionsPresenter @Inject constructor(
context: Context, context: Context,
private val prefs: Preferences prefs: Preferences
) : QkPresenter<SwipeActionsView, SwipeActionsState>(SwipeActionsState()) { ) : BaseSwipeActionsPresenter(context, R.array.settings_swipe_actions, prefs.swipeRight, prefs.swipeLeft) {
init {
val actionLabels = context.resources.getStringArray(R.array.settings_swipe_actions)
disposables += prefs.swipeRight.asObservable()
.subscribe { action -> newState { copy(rightLabel = actionLabels[action], rightIcon = iconForAction(action)) } }
disposables += prefs.swipeLeft.asObservable()
.subscribe { action -> newState { copy(leftLabel = actionLabels[action], leftIcon = iconForAction(action)) } }
}
override fun bindIntents(view: SwipeActionsView) {
super.bindIntents(view)
view.actionClicks()
.map { action ->
when (action) {
SwipeActionsView.Action.RIGHT -> prefs.swipeRight.get()
SwipeActionsView.Action.LEFT -> prefs.swipeLeft.get()
}
}
.autoDisposable(view.scope())
.subscribe(view::showSwipeActions)
view.actionSelected()
.withLatestFrom(view.actionClicks()) { actionId, action ->
when (action) {
SwipeActionsView.Action.RIGHT -> prefs.swipeRight.set(actionId)
SwipeActionsView.Action.LEFT -> prefs.swipeLeft.set(actionId)
}
}
.autoDisposable(view.scope())
.subscribe()
}
@DrawableRes @DrawableRes
private fun iconForAction(action: Int) = when (action) { override fun iconForAction(action: Int) = when (action) {
Preferences.SWIPE_ACTION_ARCHIVE -> R.drawable.ic_archive_white_24dp Preferences.SWIPE_ACTION_ARCHIVE -> R.drawable.ic_archive_white_24dp
Preferences.SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp Preferences.SWIPE_ACTION_DELETE -> R.drawable.ic_delete_white_24dp
Preferences.SWIPE_ACTION_BLOCK -> R.drawable.ic_block_white_24dp Preferences.SWIPE_ACTION_BLOCK -> R.drawable.ic_block_white_24dp
@@ -79,4 +41,4 @@ class SwipeActionsPresenter @Inject constructor(
else -> 0 else -> 0
} }
} }