change compose sendintent (sending sms/mms) and sendmessage interactor to ensure convos congruency

change compose selectedconversation (chips -> convo monitoring) to take advantage of changes in conversationrepo
conversationrepo change getthreadid to getconversation to avoid duplicate db access
some cleanups and refactoring in conversationrepo
This commit is contained in:
gavine99
2025-04-07 14:52:04 +10:00
parent 27a836324e
commit 821b02ad58
6 changed files with 402 additions and 471 deletions
@@ -19,17 +19,16 @@
package dev.octoshrimpy.quik.compat package dev.octoshrimpy.quik.compat
import android.content.Context import android.content.Context
import android.database.sqlite.SqliteWrapper
import android.net.Uri import android.net.Uri
import android.os.Build
import android.provider.BaseColumns import android.provider.BaseColumns
import android.provider.Telephony import android.provider.Telephony
import android.text.TextUtils import android.text.TextUtils
import android.util.Patterns import android.util.Patterns
import timber.log.Timber
import java.util.regex.Pattern import java.util.regex.Pattern
object TelephonyCompat { class TelephonyCompat {
companion object {
val THREADS_CONTENT_URI = Telephony.Threads.CONTENT_URI
private val ID_PROJECTION = arrayOf(BaseColumns._ID) private val ID_PROJECTION = arrayOf(BaseColumns._ID)
@@ -60,5 +59,6 @@ object TelephonyCompat {
val match = Patterns.EMAIL_ADDRESS.matcher(s) val match = Patterns.EMAIL_ADDRESS.matcher(s)
return match.matches() return match.matches()
} }
}
} }
@@ -20,8 +20,6 @@ package dev.octoshrimpy.quik.repository
import android.content.ContentUris import android.content.ContentUris
import android.content.Context import android.content.Context
import android.provider.Telephony
import android.view.View.OnLongClickListener
import dev.octoshrimpy.quik.compat.TelephonyCompat import dev.octoshrimpy.quik.compat.TelephonyCompat
import dev.octoshrimpy.quik.extensions.anyOf import dev.octoshrimpy.quik.extensions.anyOf
import dev.octoshrimpy.quik.extensions.asObservable import dev.octoshrimpy.quik.extensions.asObservable
@@ -94,7 +92,7 @@ class ConversationRepositoryImpl @Inject constructor(
return Realm.getDefaultInstance().use { realm -> return Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
realm.copyFromRealm(realm.where(Conversation::class.java) realm.where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
.equalTo("archived", false) .equalTo("archived", false)
.equalTo("blocked", false) .equalTo("blocked", false)
@@ -104,17 +102,15 @@ class ConversationRepositoryImpl @Inject constructor(
.or() .or()
.isNotEmpty("draft") .isNotEmpty("draft")
.endGroup() .endGroup()
.sort( .sort(sortOrder.toTypedArray(), sortDirections.toTypedArray())
sortOrder.toTypedArray(), .findAll()
sortDirections.toTypedArray() .let(realm::copyFromRealm)
)
.findAll())
} }
} }
override fun getTopConversations(): List<Conversation> { override fun getTopConversations() =
return Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.copyFromRealm(realm.where(Conversation::class.java) realm.where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
.isNotNull("lastMessage") .isNotNull("lastMessage")
.beginGroup() .beginGroup()
@@ -125,29 +121,20 @@ class ConversationRepositoryImpl @Inject constructor(
.equalTo("archived", false) .equalTo("archived", false)
.equalTo("blocked", false) .equalTo("blocked", false)
.isNotEmpty("recipients") .isNotEmpty("recipients")
.findAll()) .findAll()
.let(realm::copyFromRealm)
.sortedWith(compareByDescending<Conversation> { conversation -> conversation.pinned } .sortedWith(compareByDescending<Conversation> { conversation -> conversation.pinned }
.thenByDescending { conversation -> .thenByDescending { conversation ->
realm.where(Message::class.java) realm.where(Message::class.java)
.equalTo("threadId", conversation.id) .equalTo("threadId", conversation.id)
.greaterThan("date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7)) .greaterThan("date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7))
.count() .count()
})
} }
)
} }
// override fun setConversationName(id: Long, name: String) { override fun setConversationName(id: Long, name: String) =
// Realm.getDefaultInstance().use { realm -> Completable.fromAction {
// realm.executeTransaction {
// realm.where(Conversation::class.java)
// .equalTo("id", id)
// .findFirst()
// ?.name = name
// }
// }
// }
override fun setConversationName(id: Long, name: String): Completable {
return Completable.fromAction {
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.executeTransaction { realm.executeTransaction {
realm.where(Conversation::class.java) realm.where(Conversation::class.java)
@@ -157,7 +144,6 @@ class ConversationRepositoryImpl @Inject constructor(
} }
} }
}.subscribeOn(Schedulers.io()) // Ensure the operation is performed on a background thread }.subscribeOn(Schedulers.io()) // Ensure the operation is performed on a background thread
}
override fun searchConversations(query: CharSequence): List<SearchResult> { override fun searchConversations(query: CharSequence): List<SearchResult> {
val realm = Realm.getDefaultInstance() val realm = Realm.getDefaultInstance()
@@ -192,11 +178,13 @@ class ConversationRepositoryImpl @Inject constructor(
return conversations return conversations
.filter { conversation -> conversationFilter.filter(conversation, normalizedQuery) } .filter { conversation -> conversationFilter.filter(conversation, normalizedQuery) }
.map { conversation -> SearchResult(normalizedQuery, conversation, 0) } + messagesByConversation .map {
conversation -> SearchResult(normalizedQuery, conversation, 0)
} + messagesByConversation
} }
override fun getBlockedConversations(): RealmResults<Conversation> { override fun getBlockedConversations(): RealmResults<Conversation> =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("blocked", true) .equalTo("blocked", true)
.sort( .sort(
@@ -204,10 +192,9 @@ class ConversationRepositoryImpl @Inject constructor(
arrayOf(Sort.DESCENDING) arrayOf(Sort.DESCENDING)
) )
.findAll() .findAll()
}
override fun getBlockedConversationsAsync(): RealmResults<Conversation> { override fun getBlockedConversationsAsync(): RealmResults<Conversation> =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("blocked", true) .equalTo("blocked", true)
.sort( .sort(
@@ -215,26 +202,22 @@ class ConversationRepositoryImpl @Inject constructor(
arrayOf(Sort.DESCENDING) arrayOf(Sort.DESCENDING)
) )
.findAllAsync() .findAllAsync()
}
override fun getConversationAsync(threadId: Long): Conversation { override fun getConversationAsync(threadId: Long): Conversation =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("id", threadId) .equalTo("id", threadId)
.findFirstAsync() .findFirstAsync()
}
override fun getConversation(threadId: Long): Conversation? { override fun getConversation(threadId: Long) =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.apply { refresh() } .apply { refresh() }
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("id", threadId) .equalTo("id", threadId)
.findFirst() .findFirst()
}
override fun getUnseenIds(archived: Boolean): List<Long> {
val conversationIds = ArrayList<Long>()
override fun getUnseenIds(archived: Boolean) =
ArrayList<Long>().apply {
Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
@@ -246,14 +229,12 @@ class ConversationRepositoryImpl @Inject constructor(
arrayOf(Sort.DESCENDING) arrayOf(Sort.DESCENDING)
) )
.findAllAsync() .findAllAsync()
.forEach { conversation -> conversationIds.add(conversation.id) } .forEach { conversation -> add(conversation.id) }
return conversationIds
} }
override fun getUnreadIds(archived: Boolean): List<Long> {
val conversationIds = ArrayList<Long>()
override fun getUnreadIds(archived: Boolean) =
ArrayList<Long>().apply {
Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
@@ -265,42 +246,32 @@ class ConversationRepositoryImpl @Inject constructor(
arrayOf(Sort.DESCENDING) arrayOf(Sort.DESCENDING)
) )
.findAllAsync() .findAllAsync()
.forEach { conversation -> conversationIds.add(conversation.id) } .forEach { conversation -> add(conversation.id) }
return conversationIds
} }
override fun getConversationAndLastSenderContactName(threadId: Long): Pair<Conversation?, String?>? { override fun getConversationAndLastSenderContactName(threadId: Long): Pair<Conversation?, String?>? =
val conversation = Realm.getDefaultInstance() Realm.getDefaultInstance()
.apply { refresh() } .apply { refresh() }
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("id", threadId) .equalTo("id", threadId)
.findFirst() .findFirst()
?.let { conversation ->
if (conversation === null) val conversationLastSmsSender: String? = conversation.recipients.find { recipient ->
return null
var conversationLastSmsSender: String? = null
if (conversation !== null) {
conversationLastSmsSender = conversation?.recipients?.find { recipient ->
phoneNumberUtils.compare(recipient.address, conversation.lastMessage!!.address) phoneNumberUtils.compare(recipient.address, conversation.lastMessage!!.address)
}?.contact?.name }?.contact?.name
Pair(conversation, conversationLastSmsSender)
} }
return return Pair(conversation, conversationLastSmsSender) override fun getConversations(vararg threadIds: Long): RealmResults<Conversation> =
} Realm.getDefaultInstance()
override fun getConversations(vararg threadIds: Long): RealmResults<Conversation> {
return Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
.findAll() .findAll()
}
override fun getUnmanagedConversations(): Observable<List<Conversation>> { override fun getUnmanagedConversations(): Observable<List<Conversation>> =
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().let { realm->
return realm.where(Conversation::class.java) realm.where(Conversation::class.java)
.sort("lastMessage.date", Sort.DESCENDING) .sort("lastMessage.date", Sort.DESCENDING)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
.isNotNull("lastMessage") .isNotNull("lastMessage")
@@ -317,15 +288,14 @@ class ConversationRepositoryImpl @Inject constructor(
.observeOn(Schedulers.io()) .observeOn(Schedulers.io())
} }
override fun getRecipients(): RealmResults<Recipient> { override fun getRecipients(): RealmResults<Recipient> =
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance()
return realm.where(Recipient::class.java) .where(Recipient::class.java)
.findAll() .findAll()
}
override fun getUnmanagedRecipients(): Observable<List<Recipient>> { override fun getUnmanagedRecipients(): Observable<List<Recipient>> =
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().let { realm ->
return realm.where(Recipient::class.java) realm.where(Recipient::class.java)
.isNotNull("contact") .isNotNull("contact")
.findAllAsync() .findAllAsync()
.asObservable() .asObservable()
@@ -334,19 +304,17 @@ class ConversationRepositoryImpl @Inject constructor(
.subscribeOn(AndroidSchedulers.mainThread()) .subscribeOn(AndroidSchedulers.mainThread())
} }
override fun getRecipient(recipientId: Long): Recipient? { override fun getRecipient(recipientId: Long): Recipient? =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Recipient::class.java) .where(Recipient::class.java)
.equalTo("id", recipientId) .equalTo("id", recipientId)
.findFirst() .findFirst()
}
override fun getThreadId(recipient: String): Long? { override fun getConversation(recipient: String) =
return getThreadId(listOf(recipient)) getConversation(listOf(recipient))
}
override fun getThreadId(recipients: Collection<String>): Long? { override fun getConversation(recipients: Collection<String>) =
return Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
realm.where(Conversation::class.java) realm.where(Conversation::class.java)
.findAll() .findAll()
@@ -356,33 +324,26 @@ class ConversationRepositoryImpl @Inject constructor(
conversation.recipients.map { it.address }.all { address -> conversation.recipients.map { it.address }.all { address ->
recipients.any { recipient -> phoneNumberUtils.compare(recipient, address) } recipients.any { recipient -> phoneNumberUtils.compare(recipient, address) }
} }
}?.id
} }
} }
override fun getOrCreateConversation(threadId: Long): Conversation? { override fun getOrCreateConversation(threadId: Long) =
return getConversation(threadId) ?: getConversationFromCp(threadId) tryOrNull(true) {
getConversation(threadId) ?: createConversationFromCp(threadId)
} }
override fun getOrCreateConversation(address: String): Conversation? { override fun getOrCreateConversation(address: String) =
return getOrCreateConversation(listOf(address)) getOrCreateConversation(listOf(address))
override fun getOrCreateConversation(addresses: Collection<String>) =
tryOrNull(true) {
getConversation(addresses)
?: tryOrNull { TelephonyCompat.getOrCreateThreadId(context, addresses.toSet()) }
?.takeIf { it != 0L }
?.let { threadId -> getOrCreateConversation(threadId) }
} }
override fun getOrCreateConversation(addresses: List<String>): Conversation? { override fun saveDraft(threadId: Long, draft: String) =
if (addresses.isEmpty()) {
return null
}
return (getThreadId(addresses) ?: tryOrNull { TelephonyCompat.getOrCreateThreadId(context, addresses.toSet()) })
?.takeIf { threadId -> threadId != 0L }
?.let { threadId ->
getConversation(threadId)
?.let(Realm.getDefaultInstance()::copyFromRealm)
?: getConversationFromCp(threadId)
}
}
override fun saveDraft(threadId: Long, draft: String) {
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
@@ -394,9 +355,8 @@ class ConversationRepositoryImpl @Inject constructor(
conversation?.takeIf { it.isValid }?.draft = draft conversation?.takeIf { it.isValid }?.draft = draft
} }
} }
}
override fun updateConversations(vararg threadIds: Long) { override fun updateConversations(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
@@ -404,7 +364,7 @@ class ConversationRepositoryImpl @Inject constructor(
val conversation = realm val conversation = realm
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("id", threadId) .equalTo("id", threadId)
.findFirst() ?: return .findFirst() ?: return@forEach
val message = realm val message = realm
.where(Message::class.java) .where(Message::class.java)
@@ -412,62 +372,47 @@ class ConversationRepositoryImpl @Inject constructor(
.sort("date", Sort.DESCENDING) .sort("date", Sort.DESCENDING)
.findFirst() .findFirst()
realm.executeTransaction { realm.executeTransaction { conversation.lastMessage = message }
conversation.lastMessage = message
}
}
} }
} }
override fun markArchived(vararg threadIds: Long) { override fun markArchived(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction { conversations.forEach { it.archived = true } }
conversations.forEach { it.archived = true }
}
}
} }
override fun markUnarchived(vararg threadIds: Long) { override fun markUnarchived(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction { conversations.forEach { it.archived = false } }
conversations.forEach { it.archived = false }
}
}
} }
override fun markPinned(vararg threadIds: Long) { override fun markPinned(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction { conversations.forEach { it.pinned = true } }
conversations.forEach { it.pinned = true }
}
}
} }
override fun markUnpinned(vararg threadIds: Long) { override fun markUnpinned(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction { conversations.forEach { it.pinned = false } }
conversations.forEach { it.pinned = false }
}
}
} }
override fun markBlocked(threadIds: List<Long>, blockingClient: Int, blockReason: String?) { override fun markBlocked(threadIds: Collection<Long>, blockingClient: Int, blockReason: String?) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds.toLongArray()) .anyOf("id", threadIds.toLongArray())
@@ -482,9 +427,8 @@ class ConversationRepositoryImpl @Inject constructor(
} }
} }
} }
}
override fun markUnblocked(vararg threadIds: Long) { override fun markUnblocked(vararg threadIds: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds)
@@ -498,12 +442,15 @@ class ConversationRepositoryImpl @Inject constructor(
} }
} }
} }
}
override fun deleteConversations(vararg threadIds: Long) { override fun deleteConversations(vararg threadIds: Long) {
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val conversation = realm.where(Conversation::class.java).anyOf("id", threadIds).findAll() val conversation = realm.where(Conversation::class.java)
val messages = realm.where(Message::class.java).anyOf("threadId", threadIds).findAll() .anyOf("id", threadIds)
.findAll()
val messages = realm.where(Message::class.java)
.anyOf("threadId", threadIds)
.findAll()
realm.executeTransaction { realm.executeTransaction {
conversation.deleteAllFromRealm() conversation.deleteAllFromRealm()
@@ -511,9 +458,12 @@ class ConversationRepositoryImpl @Inject constructor(
} }
} }
threadIds.forEach { threadId -> threadIds.forEach {
val uri = ContentUris.withAppendedId(Telephony.Threads.CONTENT_URI, threadId) context.contentResolver.delete(
context.contentResolver.delete(uri, null, null) ContentUris.withAppendedId(TelephonyCompat.THREADS_CONTENT_URI, it),
null,
null
)
} }
} }
@@ -524,40 +474,45 @@ class ConversationRepositoryImpl @Inject constructor(
* we can return a [Conversation]. On some devices, the ContentProvider won't return the * we can return a [Conversation]. On some devices, the ContentProvider won't return the
* conversation unless it contains at least 1 message * conversation unless it contains at least 1 message
*/ */
private fun getConversationFromCp(threadId: Long): Conversation? { private fun createConversationFromCp(threadId: Long) =
return cursorToConversation.getConversationsCursor() tryOrNull(true) {
cursorToConversation.getConversationsCursor()
?.map(cursorToConversation::map) ?.map(cursorToConversation::map)
?.firstOrNull { it.id == threadId } ?.firstOrNull { conversation -> conversation.id == threadId }
?.let { conversation -> ?.also { conversation ->
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().use { realm ->
val contacts = realm.copyFromRealm(realm.where(Contact::class.java).findAll()) val realmContacts = realm.where(Contact::class.java).findAll()
val lastMessage = realm.where(Message::class.java).equalTo("threadId", threadId)
.sort("date", Sort.DESCENDING).findFirst()?.let(realm::copyFromRealm)
val recipients = conversation.recipients // match recipients from provider to recipients in realm
.map { recipient -> recipient.id } val matchedRecipients = conversation.recipients
.map { id -> cursorToRecipient.getRecipientCursor(id) } .mapNotNull { recipient ->
.mapNotNull { recipientCursor -> // map the recipient cursor to a list of recipients
// Map the recipient cursor to a list of recipients cursorToRecipient.getRecipientCursor(recipient.id)?.use { cursor ->
recipientCursor?.use { recipientCursor.map { cursorToRecipient.map(recipientCursor) } } cursor.map { cursorToRecipient.map(it) }
}
} }
.flatten() .flatten()
.map { recipient -> .map { recipient ->
recipient.apply { recipient.apply {
contact = contacts.firstOrNull { contact = realmContacts.firstOrNull { realmContact ->
it.numbers.any { phoneNumberUtils.compare(recipient.address, it.address) } realmContact.numbers.any {
phoneNumberUtils.compare(it.address, address)
}
} }
} }
} }
conversation.recipients.clear() conversation.apply {
conversation.recipients.addAll(recipients) recipients.clear()
conversation.lastMessage = lastMessage recipients.addAll(matchedRecipients)
lastMessage = realm.where(Message::class.java)
.equalTo("threadId", threadId)
.sort("date", Sort.DESCENDING)
.findFirst()
}
realm.executeTransaction { it.insertOrUpdate(conversation) } realm.executeTransaction { it.insertOrUpdate(conversation) }
realm.close()
conversation
} }
} }
}
} }
@@ -19,8 +19,6 @@
package dev.octoshrimpy.quik.interactor package dev.octoshrimpy.quik.interactor
import android.content.Context import android.content.Context
import dev.octoshrimpy.quik.compat.TelephonyCompat
import dev.octoshrimpy.quik.extensions.mapNotNull
import dev.octoshrimpy.quik.model.Attachment import dev.octoshrimpy.quik.model.Attachment
import dev.octoshrimpy.quik.repository.ConversationRepository import dev.octoshrimpy.quik.repository.ConversationRepository
import dev.octoshrimpy.quik.repository.MessageRepository import dev.octoshrimpy.quik.repository.MessageRepository
@@ -48,25 +46,25 @@ class SendMessage @Inject constructor(
.doOnNext { .doOnNext {
// If a threadId isn't provided, try to obtain one // If a threadId isn't provided, try to obtain one
val threadId = when (params.threadId) { val threadId = when (params.threadId) {
0L -> TelephonyCompat.getOrCreateThreadId(context, params.addresses.toSet()) 0L -> conversationRepo.getOrCreateConversation(params.addresses)?.id ?: 0
else -> params.threadId else -> params.threadId
} }
messageRepo.sendMessage(params.subId, threadId, params.addresses, params.body, params.attachments,
params.delay) // if unable to find or create a conversation (and/or underlying threadId), fail
if (threadId == 0L)
return@doOnNext
params.apply {
messageRepo.sendMessage(subId, threadId, addresses, body, attachments, delay)
}
conversationRepo.updateConversations(threadId)
conversationRepo.markUnarchived(threadId)
// delete attachment local files, if any, because they're saved to mms db by now // delete attachment local files, if any, because they're saved to mms db by now
params.attachments.forEach { it.removeCacheFile() } params.attachments.forEach { it.removeCacheFile() }
} }
.mapNotNull {
// If the threadId wasn't provided, then it's probably because it doesn't exist in Realm.
// Sync it now and get the id
when (params.threadId) {
0L -> conversationRepo.getOrCreateConversation(params.addresses)?.id
else -> params.threadId
}
}
.doOnNext { threadId -> conversationRepo.updateConversations(threadId) }
.doOnNext { threadId -> conversationRepo.markUnarchived(threadId) }
.flatMap { updateBadge.buildObservable(Unit) } // Update the widget .flatMap { updateBadge.buildObservable(Unit) } // Update the widget
} }
@@ -67,15 +67,15 @@ interface ConversationRepository {
fun getRecipient(recipientId: Long): Recipient? fun getRecipient(recipientId: Long): Recipient?
fun getThreadId(recipient: String): Long? fun getConversation(recipient: String): Conversation?
fun getThreadId(recipients: Collection<String>): Long? fun getConversation(recipients: Collection<String>): Conversation?
fun getOrCreateConversation(threadId: Long): Conversation? fun getOrCreateConversation(threadId: Long): Conversation?
fun getOrCreateConversation(address: String): Conversation? fun getOrCreateConversation(address: String): Conversation?
fun getOrCreateConversation(addresses: List<String>): Conversation? fun getOrCreateConversation(addresses: Collection<String>): Conversation?
fun saveDraft(threadId: Long, draft: String) fun saveDraft(threadId: Long, draft: String)
@@ -92,7 +92,7 @@ interface ConversationRepository {
fun markUnpinned(vararg threadIds: Long) fun markUnpinned(vararg threadIds: Long)
fun markBlocked(threadIds: List<Long>, blockingClient: Int, blockReason: String?) fun markBlocked(threadIds: Collection<Long>, blockingClient: Int, blockReason: String?)
fun markUnblocked(vararg threadIds: Long) fun markUnblocked(vararg threadIds: Long)
@@ -42,8 +42,8 @@ class BlockedNumbersPresenter @Inject constructor(
.observeOn(Schedulers.io()) .observeOn(Schedulers.io())
.doOnNext { id -> .doOnNext { id ->
blockingRepo.getBlockedNumber(id)?.address blockingRepo.getBlockedNumber(id)?.address
?.let(conversationRepo::getThreadId) ?.let(conversationRepo::getConversation)
?.let { threadId -> markUnblocked.execute(listOf(threadId)) } ?.let { conversation -> markUnblocked.execute(listOf(conversation.id)) }
} }
.doOnNext(blockingRepo::unblockNumber) .doOnNext(blockingRepo::unblockNumber)
.subscribeOn(Schedulers.io()) .subscribeOn(Schedulers.io())
@@ -161,51 +161,34 @@ class ComposeViewModel @Inject constructor(
?: Observable.empty() ?: Observable.empty()
val selectedConversation = selectedChips val selectedConversation = selectedChips
.skipWhile { it.isEmpty() } .skipWhile { recipients -> recipients.isEmpty() }
.map { chips -> chips.map { it.address } } .map { recipients -> recipients.map { it.address } }
.distinctUntilChanged() .distinctUntilChanged()
.doOnNext { newState { copy(loading = true) } } .doOnNext { newState { copy(loading = true) } }
.observeOn(Schedulers.io()) .observeOn(Schedulers.io()) // background thread for possible long telephony running
.map { addresses -> Pair(conversationRepo.getOrCreateConversation(addresses)?.id ?: 0, addresses) } .doOnNext { addresses -> conversationRepo.getOrCreateConversation(addresses) }
.observeOn(AndroidSchedulers.mainThread()) .observeOn(AndroidSchedulers.mainThread())
.switchMap { addresses ->
// monitors convos and triggers when wanted convo is present
conversationRepo.getConversations(false)
.asObservable()
.filter { conversations -> conversations.isLoaded }
.mapNotNull { conversationRepo.getConversation(addresses) }
.doOnNext { newState { copy(loading = false) } } .doOnNext { newState { copy(loading = false) } }
.switchMap { (threadId, addresses) -> .switchMap { conversation -> conversation.asObservable() }
// If we already have this thread in realm, or we're able to obtain it from the
// system, just return that.
threadId.takeIf { it > 0 }?.let {
return@switchMap conversationRepo.getConversationAsync(threadId).asObservable()
} }
// Otherwise, we'll monitor the conversations until our expected conversation is created // Merges two potential conversation sources (constructor threadId and contact selection)
conversationRepo.getConversations(prefs.unreadAtTop.get()).asObservable() // into a single stream of conversations. If the conversation was deleted, notify the
.filter { it.isLoaded } // activity to shut down
.observeOn(Schedulers.io())
.map { conversationRepo.getOrCreateConversation(addresses)?.id ?: 0 }
.observeOn(AndroidSchedulers.mainThread())
.switchMap { actualThreadId ->
when (actualThreadId) {
0L -> Observable.just(Conversation(0))
else -> conversationRepo.getConversationAsync(actualThreadId).asObservable()
}
}
}
// Merges two potential conversation sources (threadId from constructor and contact selection) into a single
// stream of conversations. If the conversation was deleted, notify the activity to shut down
disposables += selectedConversation disposables += selectedConversation
.mergeWith(initialConversation) .mergeWith(initialConversation)
.filter { conversation -> conversation.isLoaded } .filter { it.isLoaded }
.doOnNext { conversation -> .filter { it.isValid.also { if (!it) newState { copy(hasError = true) } } }
if (!conversation.isValid) {
newState { copy(hasError = true) }
}
}
.filter { conversation -> conversation.isValid }
.subscribe(conversation::onNext) .subscribe(conversation::onNext)
if (addresses.isNotEmpty()) { if (addresses.isNotEmpty())
selectedChips.onNext(addresses.map { address -> Recipient(address = address) }) selectedChips.onNext(addresses.map { address -> Recipient(address = address) })
}
disposables += chipsReducer disposables += chipsReducer
.scan(listOf<Recipient>()) { previousState, reducer -> reducer(previousState) } .scan(listOf<Recipient>()) { previousState, reducer -> reducer(previousState) }
@@ -1085,8 +1068,12 @@ class ComposeViewModel @Inject constructor(
// Send a message when the send button is clicked, and disable editing mode if it's enabled // Send a message when the send button is clicked, and disable editing mode if it's enabled
view.sendIntent view.sendIntent
.observeOn(Schedulers.io()) .observeOn(Schedulers.io())
.withLatestFrom(view.textChangedIntent) { _, body -> body.toString() } .withLatestFrom(
.withLatestFrom(state, conversation, selectedChips) { body, state, conversation, chips -> view.textChangedIntent,
state,
conversation,
selectedChips
) { _, body, state, conversation, chips ->
if (!permissionManager.isDefaultSms()) { if (!permissionManager.isDefaultSms()) {
view.requestDefaultSms() view.requestDefaultSms()
return@withLatestFrom return@withLatestFrom
@@ -1115,60 +1102,49 @@ class ComposeViewModel @Inject constructor(
false -> chips.map { chip -> chip.address } false -> chips.map { chip -> chip.address }
} }
val sendAsGroup = ((addresses.size > 1) && // if more than one address to send to val sendAsGroup = ((addresses.size > 1) && // if more than one address to send to
(!state.editingMode || // and is not a new convo (!state.editingMode || // and is not a new convo (group msg or not is already set)
state.sendAsGroup)) // or (is a new convo and) send as group is selected state.sendAsGroup)) // or (is a new convo and) send as group is selected
when { when {
// Scheduling a message // Scheduling a message
state.scheduled != 0L -> { state.scheduled != 0L -> addScheduledMessage.execute(
AddScheduledMessage.Params(
state.scheduled,
subId,
addresses,
sendAsGroup,
body.toString(),
state.attachments.map { it.uri.toString() }
)
).also {
newState { copy(scheduled = 0) } newState { copy(scheduled = 0) }
val uris = state.attachments.map { it.uri.toString() }
val params = AddScheduledMessage
.Params(state.scheduled, subId, addresses, sendAsGroup, body, uris)
addScheduledMessage.execute(params)
context.makeToast(R.string.compose_scheduled_toast) context.makeToast(R.string.compose_scheduled_toast)
} }
// Sending a group message // sending a group message
sendAsGroup -> { sendAsGroup -> sendMessage.execute(
sendMessage.execute(SendMessage
.Params(subId, conversation.id, addresses, body, state.attachments, delay))
}
// Sending a message to an existing conversation with one recipient
conversation.recipients.size == 1 -> {
val address = conversation.recipients.map { it.address }
sendMessage.execute(SendMessage.Params(subId, threadId, address, body, state.attachments, delay))
}
// Create a new conversation with one address
addresses.size == 1 -> {
sendMessage.execute(SendMessage
.Params(subId, threadId, addresses, body, state.attachments, delay))
}
// Send a message to multiple addresses
else -> {
addresses.forEach {
val threadId = tryOrNull(false) {
TelephonyCompat.getOrCreateThreadId(context, it)
} ?: 0
val address = conversationRepo.getOrCreateConversation(it)
?.recipients
?.firstOrNull()
?.address
?: it
sendMessage.execute(
SendMessage.Params( SendMessage.Params(
subId, subId,
threadId, 0,
listOf(address), addresses,
body, body.toString(),
state.attachments,
delay
)
)
// sending message to individual address(es)
else -> addresses.forEach {
sendMessage.execute(
SendMessage.Params(
subId,
0,
listOf(it),
body.toString(),
state.attachments, state.attachments,
delay delay
) )
) )
}
} }
} }
@@ -1180,8 +1156,10 @@ class ComposeViewModel @Inject constructor(
!state.sendAsGroup) // and is *not* sent as a group !state.sendAsGroup) // and is *not* sent as a group
) )
} }
.observeOn(AndroidSchedulers.mainThread())
.doOnNext { view.focusMessage() }
.autoDisposable(view.scope()) .autoDisposable(view.scope())
.subscribe{view.focusMessage()} .subscribe()
// View QKSMS+ // View QKSMS+
view.viewQksmsPlusIntent view.viewQksmsPlusIntent