diff --git a/data/src/main/java/com/moez/QKSMS/repository/MessageRepositoryImpl.kt b/data/src/main/java/com/moez/QKSMS/repository/MessageRepositoryImpl.kt index 85316fac..4484b14f 100644 --- a/data/src/main/java/com/moez/QKSMS/repository/MessageRepositoryImpl.kt +++ b/data/src/main/java/com/moez/QKSMS/repository/MessageRepositoryImpl.kt @@ -62,7 +62,8 @@ class MessageRepositoryImpl @Inject constructor( private val context: Context, private val messageIds: KeyManager, private val imageRepository: ImageRepository, - private val prefs: Preferences) : MessageRepository { + private val prefs: Preferences, + private val syncRepository: SyncRepository) : MessageRepository { override fun getMessages(threadId: Long, query: String): RealmResults { return Realm.getDefaultInstance() @@ -336,6 +337,13 @@ class MessageRepositoryImpl @Inject constructor( realm.executeTransaction { managedMessage?.takeIf { it.isValid }?.contentId = uri.lastPathSegment.toLong() } realm.close() + // On some devices, we can't obtain a threadId until after the first message is sent in a + // conversation. In this case, we need to update the message's threadId after it gets added + // to the native ContentProvider + if (threadId == 0L) { + uri?.let(syncRepository::syncMessage) + } + return message } diff --git a/domain/src/main/java/com/moez/QKSMS/interactor/SendMessage.kt b/domain/src/main/java/com/moez/QKSMS/interactor/SendMessage.kt index 600a7072..6be1006c 100644 --- a/domain/src/main/java/com/moez/QKSMS/interactor/SendMessage.kt +++ b/domain/src/main/java/com/moez/QKSMS/interactor/SendMessage.kt @@ -21,12 +21,14 @@ package com.moez.QKSMS.interactor import com.moez.QKSMS.model.Attachment import com.moez.QKSMS.repository.ConversationRepository import com.moez.QKSMS.repository.MessageRepository +import com.moez.QKSMS.repository.SyncRepository import io.reactivex.Flowable import javax.inject.Inject class SendMessage @Inject constructor( private val conversationRepo: ConversationRepository, - private val messageRepo: MessageRepository + private val messageRepo: MessageRepository, + private val syncRepo: SyncRepository ) : Interactor() { data class Params( @@ -37,12 +39,19 @@ class SendMessage @Inject constructor( val attachments: List = listOf(), val delay: Int = 0) - override fun buildObservable(params: Params): Flowable = Flowable.just(Unit) + override fun buildObservable(params: Params): Flowable<*> = Flowable.just(Unit) .filter { params.addresses.isNotEmpty() } .doOnNext { messageRepo.sendMessage(params.subId, params.threadId, params.addresses, params.body, params.attachments, params.delay) } - // If this was the first message sent in the conversation, the conversation might not exist yet - .doOnNext { conversationRepo.getOrCreateConversation(params.threadId) } - .doOnNext { conversationRepo.updateConversations(params.threadId) } - .doOnNext { conversationRepo.markUnarchived(params.threadId) } + .map { + // On some manufacturers, we can't obtain a threadId for a new conversation. In + // this case, find the threadId manually now that it contains a message + if (params.threadId == 0L) { + conversationRepo.getOrCreateConversation(params.addresses)?.id ?: 0 + } else { + params.threadId + } + } + .doOnNext { threadId -> conversationRepo.updateConversations(threadId) } + .doOnNext { threadId -> conversationRepo.markUnarchived(threadId) } } \ No newline at end of file diff --git a/presentation/src/main/java/com/moez/QKSMS/feature/compose/ComposeViewModel.kt b/presentation/src/main/java/com/moez/QKSMS/feature/compose/ComposeViewModel.kt index f5ab5442..5766a77f 100644 --- a/presentation/src/main/java/com/moez/QKSMS/feature/compose/ComposeViewModel.kt +++ b/presentation/src/main/java/com/moez/QKSMS/feature/compose/ComposeViewModel.kt @@ -107,7 +107,6 @@ class ComposeViewModel @Inject constructor( private val contacts: Observable> by lazy { contactsRepo.getUnmanagedContacts().toObservable() } private val contactsReducer: Subject<(List) -> List> = PublishSubject.create() private val selectedContacts: Subject> = BehaviorSubject.createDefault(listOf()) - private val threadIdSubject: Subject = BehaviorSubject.create() private val searchResults: Subject> = BehaviorSubject.create() private val searchSelection: Subject = BehaviorSubject.createDefault(-1) private val conversation: Subject = BehaviorSubject.create() @@ -119,28 +118,40 @@ class ComposeViewModel @Inject constructor( ?.asObservable() ?: Observable.empty() - // 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 += selectedContacts + val selectedConversation = selectedContacts .skipWhile { it.isEmpty() } .map { contacts -> contacts.map { it.numbers.firstOrNull()?.address ?: "" } } + .distinctUntilChanged() .doOnNext { newState { copy(loading = true) } } - .observeOn(Schedulers.computation()) - .map { addresses -> conversationRepo.getThreadId(addresses) ?: 0 } + .observeOn(Schedulers.io()) + .map { addresses -> Pair(conversationRepo.getOrCreateConversation(addresses)?.id ?: 0, addresses) } .observeOn(AndroidSchedulers.mainThread()) .doOnNext { newState { copy(loading = false) } } - .mergeWith(threadIdSubject) - .switchMap { threadId -> - // Query the entire list of conversations and map from there, rather than - // directly querying the conversation from realm. If querying a single - // conversation and it doesn't exist yet, the realm query will never update + .switchMap { (threadId, addresses) -> + + // If we already have this thread in realm, or were 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 conversationRepo.getConversations().asObservable() - .map { conversations -> - conversations.firstOrNull { it.id == threadId } - ?: conversationRepo.getOrCreateConversation(threadId) - ?: Conversation(id = threadId) + .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 + // stream of conversations. If the conversation was deleted, notify the activity to shut down + disposables += selectedConversation .mergeWith(initialConversation) .filter { conversation -> conversation.isLoaded } .doOnNext { conversation -> @@ -601,6 +612,7 @@ class ComposeViewModel @Inject constructor( } when { + // Scheduling a message state.scheduled != 0L -> { newState { copy(scheduled = 0) } val uris = attachments.map { it.getUri() }.map { it.toString() } @@ -609,17 +621,27 @@ class ComposeViewModel @Inject constructor( context.makeToast(R.string.compose_scheduled_toast) } + // Sending a group message state.sendAsGroup -> { - val threadId = conversation.id.takeIf { it > 0 } - ?: TelephonyCompat.getOrCreateThreadId(context, addresses).also(threadIdSubject::onNext) + sendMessage.execute(SendMessage.Params(subId, conversation.id, addresses, body, 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, attachments, delay)) + } + + // Create a new conversation with one address + addresses.size == 1 -> { sendMessage.execute(SendMessage.Params(subId, threadId, addresses, body, attachments, delay)) } + // Send a message to multiple addresses else -> { addresses.forEach { addr -> - val threadId = TelephonyCompat.getOrCreateThreadId(context, addr) - val address = listOf(conversationRepo.getConversation(threadId)?.recipients?.firstOrNull()?.address - ?: addr) + val threadId = tryOrNull(false) { TelephonyCompat.getOrCreateThreadId(context, addr) } ?: 0 + val address = listOf(conversationRepo.getConversation(threadId)?.recipients?.firstOrNull()?.address ?: addr) sendMessage.execute(SendMessage.Params(subId, threadId, address, body, attachments, delay)) } }