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,46 +19,46 @@
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)
private val THREAD_ID_CONTENT_URI = Uri.parse("content://mms-sms/threadID") private val THREAD_ID_CONTENT_URI = Uri.parse("content://mms-sms/threadID")
val NAME_ADDR_EMAIL_PATTERN = Pattern.compile("\\s*(\"[^\"]*\"|[^<>\"]+)\\s*<([^<>]+)>\\s*") val NAME_ADDR_EMAIL_PATTERN = Pattern.compile("\\s*(\"[^\"]*\"|[^<>\"]+)\\s*<([^<>]+)>\\s*")
fun getOrCreateThreadId(context: Context, recipient: String): Long { fun getOrCreateThreadId(context: Context, recipient: String): Long {
return getOrCreateThreadId(context, listOf(recipient)) return getOrCreateThreadId(context, listOf(recipient))
} }
fun getOrCreateThreadId(context: Context, recipients: Collection<String>): Long { fun getOrCreateThreadId(context: Context, recipients: Collection<String>): Long {
return Telephony.Threads.getOrCreateThreadId(context, recipients.toSet()) return Telephony.Threads.getOrCreateThreadId(context, recipients.toSet())
} }
fun extractAddrSpec(address: String): String { fun extractAddrSpec(address: String): String {
val match = NAME_ADDR_EMAIL_PATTERN.matcher(address) val match = NAME_ADDR_EMAIL_PATTERN.matcher(address)
return if (match.matches()) { return if (match.matches()) {
match.group(2) match.group(2)
} else address } else address
} }
fun isEmailAddress(address: String): Boolean { fun isEmailAddress(address: String): Boolean {
if (TextUtils.isEmpty(address)) { if (TextUtils.isEmpty(address)) {
return false return false
}
val s = extractAddrSpec(address)
val match = Patterns.EMAIL_ADDRESS.matcher(s)
return match.matches()
} }
val s = extractAddrSpec(address)
val match = Patterns.EMAIL_ADDRESS.matcher(s)
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
@@ -66,21 +64,21 @@ class ConversationRepositoryImpl @Inject constructor(
} }
return Realm.getDefaultInstance() return Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
.equalTo("archived", archived) .equalTo("archived", archived)
.equalTo("blocked", false) .equalTo("blocked", false)
.isNotEmpty("recipients") .isNotEmpty("recipients")
.beginGroup() .beginGroup()
.isNotNull("lastMessage") .isNotNull("lastMessage")
.or() .or()
.isNotEmpty("draft") .isNotEmpty("draft")
.endGroup() .endGroup()
.sort( .sort(
sortOrder.toTypedArray(), sortOrder.toTypedArray(),
sortDirections.toTypedArray() sortDirections.toTypedArray()
) )
.findAllAsync() .findAllAsync()
} }
override fun getConversationsSnapshot(unreadAtTop: Boolean): List<Conversation> { override fun getConversationsSnapshot(unreadAtTop: Boolean): List<Conversation> {
@@ -94,60 +92,49 @@ 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)
.isNotEmpty("recipients") .isNotEmpty("recipients")
.beginGroup() .beginGroup()
.isNotNull("lastMessage") .isNotNull("lastMessage")
.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()
.equalTo("pinned", true) .equalTo("pinned", true)
.or() .or()
.greaterThan("lastMessage.date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7)) .greaterThan("lastMessage.date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7))
.endGroup() .endGroup()
.equalTo("archived", false) .equalTo("archived", false)
.equalTo("blocked", false) .equalTo("blocked", false)
.isNotEmpty("recipients") .isNotEmpty("recipients")
.findAll()) .findAll()
.sortedWith(compareByDescending<Conversation> { conversation -> conversation.pinned } .let(realm::copyFromRealm)
.thenByDescending { conversation -> .sortedWith(compareByDescending<Conversation> { conversation -> conversation.pinned }
realm.where(Message::class.java) .thenByDescending { conversation ->
.equalTo("threadId", conversation.id) realm.where(Message::class.java)
.greaterThan("date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7)) .equalTo("threadId", conversation.id)
.count() .greaterThan("date", System.currentTimeMillis() - TimeUnit.DAYS.toMillis(7))
}) .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,150 +144,134 @@ 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()
val normalizedQuery = query.removeAccents() val normalizedQuery = query.removeAccents()
val conversations = realm.copyFromRealm(realm val conversations = realm.copyFromRealm(realm
.where(Conversation::class.java) .where(Conversation::class.java)
.notEqualTo("id", 0L) .notEqualTo("id", 0L)
.isNotNull("lastMessage") .isNotNull("lastMessage")
.equalTo("blocked", false) .equalTo("blocked", false)
.isNotEmpty("recipients") .isNotEmpty("recipients")
.sort("pinned", Sort.DESCENDING, "lastMessage.date", Sort.DESCENDING) .sort("pinned", Sort.DESCENDING, "lastMessage.date", Sort.DESCENDING)
.findAll()) .findAll())
val messagesByConversation = realm.copyFromRealm(realm val messagesByConversation = realm.copyFromRealm(realm
.where(Message::class.java) .where(Message::class.java)
.beginGroup() .beginGroup()
.contains("body", normalizedQuery, Case.INSENSITIVE) .contains("body", normalizedQuery, Case.INSENSITIVE)
.or() .or()
.contains("parts.text", normalizedQuery, Case.INSENSITIVE) .contains("parts.text", normalizedQuery, Case.INSENSITIVE)
.endGroup() .endGroup()
.findAll()) .findAll())
.asSequence() .asSequence()
.groupBy { message -> message.threadId } .groupBy { message -> message.threadId }
.filter { (threadId, _) -> conversations.firstOrNull { it.id == threadId } != null } .filter { (threadId, _) -> conversations.firstOrNull { it.id == threadId } != null }
.map { (threadId, messages) -> Pair(conversations.first { it.id == threadId }, messages.size) } .map { (threadId, messages) -> Pair(conversations.first { it.id == threadId }, messages.size) }
.map { (conversation, messages) -> SearchResult(normalizedQuery, conversation, messages) } .map { (conversation, messages) -> SearchResult(normalizedQuery, conversation, messages) }
.sortedByDescending { result -> result.messages } .sortedByDescending { result -> result.messages }
.toList() .toList()
realm.close() realm.close()
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(
arrayOf("lastMessage.date"), arrayOf("lastMessage.date"),
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)
.equalTo("blocked", true)
.sort(
arrayOf("lastMessage.date"),
arrayOf(Sort.DESCENDING)
)
.findAllAsync()
override fun getConversationAsync(threadId: Long): Conversation =
Realm.getDefaultInstance()
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirstAsync()
override fun getConversation(threadId: Long) =
Realm.getDefaultInstance()
.apply { refresh() }
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirst()
override fun getUnseenIds(archived: Boolean) =
ArrayList<Long>().apply {
Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.equalTo("blocked", true) .notEqualTo("id", 0L)
.equalTo("archived", archived)
.equalTo("blocked", false)
.equalTo("lastMessage.seen", false)
.sort( .sort(
arrayOf("lastMessage.date"), arrayOf("lastMessage.date"),
arrayOf(Sort.DESCENDING) arrayOf(Sort.DESCENDING)
) )
.findAllAsync() .findAllAsync()
} .forEach { conversation -> add(conversation.id) }
override fun getConversationAsync(threadId: Long): Conversation {
return Realm.getDefaultInstance()
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirstAsync()
}
override fun getConversation(threadId: Long): Conversation? {
return Realm.getDefaultInstance()
.apply { refresh() }
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirst()
}
override fun getUnseenIds(archived: Boolean): List<Long> {
val conversationIds = ArrayList<Long>()
Realm.getDefaultInstance()
.where(Conversation::class.java)
.notEqualTo("id", 0L)
.equalTo("archived", archived)
.equalTo("blocked", false)
.equalTo("lastMessage.seen", false)
.sort(
arrayOf("lastMessage.date"),
arrayOf(Sort.DESCENDING)
)
.findAllAsync()
.forEach { conversation -> conversationIds.add(conversation.id) }
return conversationIds
}
override fun getUnreadIds(archived: Boolean): List<Long> {
val conversationIds = ArrayList<Long>()
Realm.getDefaultInstance()
.where(Conversation::class.java)
.notEqualTo("id", 0L)
.equalTo("archived", archived)
.equalTo("blocked", false)
.equalTo("lastMessage.read", false)
.sort(
arrayOf("lastMessage.date"),
arrayOf(Sort.DESCENDING)
)
.findAllAsync()
.forEach { conversation -> conversationIds.add(conversation.id) }
return conversationIds
}
override fun getConversationAndLastSenderContactName(threadId: Long): Pair<Conversation?, String?>? {
val conversation = Realm.getDefaultInstance()
.apply { refresh() }
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirst()
if (conversation === null)
return null
var conversationLastSmsSender: String? = null
if (conversation !== null) {
conversationLastSmsSender = conversation?.recipients?.find { recipient ->
phoneNumberUtils.compare(recipient.address, conversation.lastMessage!!.address)
}?.contact?.name
} }
return return Pair(conversation, conversationLastSmsSender)
}
override fun getConversations(vararg threadIds: Long): RealmResults<Conversation> { override fun getUnreadIds(archived: Boolean) =
return Realm.getDefaultInstance() ArrayList<Long>().apply {
Realm.getDefaultInstance()
.where(Conversation::class.java) .where(Conversation::class.java)
.anyOf("id", threadIds) .notEqualTo("id", 0L)
.findAll() .equalTo("archived", archived)
} .equalTo("blocked", false)
.equalTo("lastMessage.read", false)
.sort(
arrayOf("lastMessage.date"),
arrayOf(Sort.DESCENDING)
)
.findAllAsync()
.forEach { conversation -> add(conversation.id) }
}
override fun getUnmanagedConversations(): Observable<List<Conversation>> { override fun getConversationAndLastSenderContactName(threadId: Long): Pair<Conversation?, String?>? =
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance()
return realm.where(Conversation::class.java) .apply { refresh() }
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirst()
?.let { conversation ->
val conversationLastSmsSender: String? = conversation.recipients.find { recipient ->
phoneNumberUtils.compare(recipient.address, conversation.lastMessage!!.address)
}?.contact?.name
Pair(conversation, conversationLastSmsSender)
}
override fun getConversations(vararg threadIds: Long): RealmResults<Conversation> =
Realm.getDefaultInstance()
.where(Conversation::class.java)
.anyOf("id", threadIds)
.findAll()
override fun getUnmanagedConversations(): Observable<List<Conversation>> =
Realm.getDefaultInstance().let { realm->
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")
@@ -315,164 +286,138 @@ class ConversationRepositoryImpl @Inject constructor(
.map { realm.copyFromRealm(it) } .map { realm.copyFromRealm(it) }
.subscribeOn(AndroidSchedulers.mainThread()) .subscribeOn(AndroidSchedulers.mainThread())
.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()
.filter { it.isLoaded && it.isValid } .filter { it.isLoaded && it.isValid }
.map { realm.copyFromRealm(it) } .map { realm.copyFromRealm(it) }
.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()
.asSequence() .asSequence()
.filter { conversation -> conversation.recipients.size == recipients.size } .filter { conversation -> conversation.recipients.size == recipients.size }
.find { conversation -> .find { conversation ->
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? {
return getConversation(threadId) ?: getConversationFromCp(threadId)
}
override fun getOrCreateConversation(address: String): Conversation? {
return getOrCreateConversation(listOf(address))
}
override fun getOrCreateConversation(addresses: List<String>): Conversation? {
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) { override fun getOrCreateConversation(threadId: Long) =
tryOrNull(true) {
getConversation(threadId) ?: createConversationFromCp(threadId)
}
override fun getOrCreateConversation(address: String) =
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 saveDraft(threadId: Long, draft: String) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val conversation = realm.where(Conversation::class.java) val conversation = realm.where(Conversation::class.java)
.equalTo("id", threadId) .equalTo("id", threadId)
.findFirst() .findFirst()
realm.executeTransaction { realm.executeTransaction {
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()
threadIds.forEach { threadId -> threadIds.forEach { threadId ->
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)
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.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())
.equalTo("blocked", false) .equalTo("blocked", false)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction {
conversations.forEach { conversation -> conversations.forEach { conversation ->
@@ -482,13 +427,12 @@ 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)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction {
conversations.forEach { conversation -> conversations.forEach { conversation ->
@@ -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)
realm.executeTransaction { it.insertOrUpdate(conversation) } lastMessage = realm.where(Message::class.java)
realm.close() .equalTo("threadId", threadId)
.sort("date", Sort.DESCENDING)
.findFirst()
}
conversation realm.executeTransaction { it.insertOrUpdate(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
@@ -44,29 +42,29 @@ class SendMessage @Inject constructor(
) )
override fun buildObservable(params: Params): Flowable<*> = Flowable.just(Unit) override fun buildObservable(params: Params): Flowable<*> = Flowable.just(Unit)
.filter { params.addresses.isNotEmpty() } .filter { params.addresses.isNotEmpty() }
.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)
// delete attachment local files, if any, because they're saved to mms db by now // if unable to find or create a conversation (and/or underlying threadId), fail
params.attachments.forEach { it.removeCacheFile() } if (threadId == 0L)
return@doOnNext
params.apply {
messageRepo.sendMessage(subId, threadId, addresses, body, attachments, delay)
} }
.mapNotNull {
// If the threadId wasn't provided, then it's probably because it doesn't exist in Realm. conversationRepo.updateConversations(threadId)
// Sync it now and get the id
when (params.threadId) { conversationRepo.markUnarchived(threadId)
0L -> conversationRepo.getOrCreateConversation(params.addresses)?.id
else -> params.threadId // delete attachment local files, if any, because they're saved to mms db by now
} params.attachments.forEach { it.removeCacheFile() }
} }
.doOnNext { threadId -> conversationRepo.updateConversations(threadId) } .flatMap { updateBadge.buildObservable(Unit) } // Update the widget
.doOnNext { threadId -> conversationRepo.markUnarchived(threadId) }
.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())
@@ -156,56 +156,39 @@ class ComposeViewModel @Inject constructor(
newState { copy(attachments = sharedAttachments) } newState { copy(attachments = sharedAttachments) }
val initialConversation = threadId.takeIf { it != 0L } val initialConversation = threadId.takeIf { it != 0L }
?.let(conversationRepo::getConversationAsync) ?.let(conversationRepo::getConversationAsync)
?.asObservable() ?.asObservable()
?: 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())
.doOnNext { newState { copy(loading = false) } } .switchMap { addresses ->
.switchMap { (threadId, addresses) -> // monitors convos and triggers when wanted convo is present
// If we already have this thread in realm, or we're able to obtain it from the conversationRepo.getConversations(false)
// system, just return that. .asObservable()
threadId.takeIf { it > 0 }?.let { .filter { conversations -> conversations.isLoaded }
return@switchMap conversationRepo.getConversationAsync(threadId).asObservable() .mapNotNull { conversationRepo.getConversation(addresses) }
} .doOnNext { newState { copy(loading = false) } }
.switchMap { conversation -> conversation.asObservable() }
// Otherwise, we'll monitor the conversations until our expected conversation is created
conversationRepo.getConversations(prefs.unreadAtTop.get()).asObservable()
.filter { it.isLoaded }
.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 // Merges two potential conversation sources (constructor threadId and contact selection)
// stream of conversations. If the conversation was deleted, notify the activity to shut down // 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) { .subscribe(conversation::onNext)
newState { copy(hasError = true) }
}
}
.filter { conversation -> conversation.isValid }
.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 SendMessage.Params(
.Params(subId, conversation.id, addresses, body, state.attachments, delay)) subId,
} 0,
addresses,
body.toString(),
state.attachments,
delay
)
)
// Sending a message to an existing conversation with one recipient // sending message to individual address(es)
conversation.recipients.size == 1 -> { else -> addresses.forEach {
val address = conversation.recipients.map { it.address } sendMessage.execute(
sendMessage.execute(SendMessage.Params(subId, threadId, address, body, state.attachments, delay)) SendMessage.Params(
} subId,
0,
// Create a new conversation with one address listOf(it),
addresses.size == 1 -> { body.toString(),
sendMessage.execute(SendMessage state.attachments,
.Params(subId, threadId, addresses, body, state.attachments, delay)) 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(
subId,
threadId,
listOf(address),
body,
state.attachments,
delay
)
) )
} )
} }
} }
@@ -1176,12 +1152,14 @@ class ComposeViewModel @Inject constructor(
// compose activity) // compose activity)
view.clearCurrentMessageIntent.onNext( view.clearCurrentMessageIntent.onNext(
((addresses.size > 1) && // if more than one address to send to ((addresses.size > 1) && // if more than one address to send to
state.editingMode && // and is a new convo state.editingMode && // and is a new convo
!state.sendAsGroup) // and is *not* sent as a group !state.sendAsGroup) // and is *not* sent as a group
) )
} }
.autoDisposable(view.scope()) .observeOn(AndroidSchedulers.mainThread())
.subscribe{view.focusMessage()} .doOnNext { view.focusMessage() }
.autoDisposable(view.scope())
.subscribe()
// View QKSMS+ // View QKSMS+
view.viewQksmsPlusIntent view.viewQksmsPlusIntent