Refresh realm instead of waiting on async query when changing message box and close realm instance when finished

This commit is contained in:
Moez Bhatti
2018-02-23 22:46:14 -05:00
parent 9ac7fadfdd
commit 2db4468b19
6 changed files with 92 additions and 123 deletions
@@ -33,7 +33,10 @@ import com.klinker.android.send_message.StripAccents
import common.util.Keys import common.util.Keys
import common.util.MessageUtils import common.util.MessageUtils
import common.util.Preferences import common.util.Preferences
import common.util.extensions.* import common.util.extensions.asFlowable
import common.util.extensions.asMaybe
import common.util.extensions.insertOrUpdate
import common.util.extensions.map
import data.mapper.CursorToConversation import data.mapper.CursorToConversation
import data.mapper.CursorToRecipient import data.mapper.CursorToRecipient
import data.model.* import data.model.*
@@ -384,29 +387,23 @@ class MessageRepository @Inject constructor(
/** /**
* Marks the message as sending, in case we need to retry sending it * Marks the message as sending, in case we need to retry sending it
*/ */
fun markSending(id: Long): Flowable<*> { fun markSending(id: Long) {
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().use { realm ->
return realm.where(Message::class.java).equalTo("id", id) realm.refresh()
.findAllAsync()
.asFlowable() val message = realm.where(Message::class.java).equalTo("id", id).findFirst()
.filter { it.isLoaded } message?.let {
.filter { it.isValid } // Update the message in realm
.mapNotNull { it[0] } realm.executeTransaction {
.take(1) message.boxId = Sms.MESSAGE_TYPE_OUTBOX
.doOnNext { message ->
// Update the message in realm
realm.executeTransaction {
message.boxId = Sms.MESSAGE_TYPE_OUTBOX
}
}
.map { message -> message.getUri() }
.observeOn(Schedulers.computation())
.doOnNext { uri ->
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_OUTBOX)
context.contentResolver.update(uri, values, null, null)
} }
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_OUTBOX)
context.contentResolver.update(message.getUri(), values, null, null)
}
}
} }
fun markSent(id: Long) { fun markSent(id: Long) {
@@ -428,91 +425,73 @@ class MessageRepository @Inject constructor(
} }
} }
fun markFailed(id: Long, resultCode: Int): Flowable<*> { fun markFailed(id: Long, resultCode: Int) {
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().use { realm ->
return realm.where(Message::class.java).equalTo("id", id) realm.refresh()
.findAllAsync()
.asFlowable() val message = realm.where(Message::class.java).equalTo("id", id).findFirst()
.filter { it.isLoaded } message?.let {
.filter { it.isValid } // Update the message in realm
.mapNotNull { it[0] } realm.executeTransaction {
.take(1) message.boxId = Sms.MESSAGE_TYPE_FAILED
.doOnNext { message -> message.errorCode = resultCode
// Update the message in realm
realm.executeTransaction {
message.boxId = Sms.MESSAGE_TYPE_FAILED
message.errorCode = resultCode
}
}
.map { message -> message.getUri() }
.observeOn(Schedulers.computation())
.doOnNext { uri ->
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_FAILED)
values.put(Sms.ERROR_CODE, resultCode)
context.contentResolver.update(uri, values, null, null)
} }
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_FAILED)
values.put(Sms.ERROR_CODE, resultCode)
context.contentResolver.update(message.getUri(), values, null, null)
}
}
} }
fun markDelivered(id: Long): Flowable<*> { fun markDelivered(id: Long) {
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().use { realm ->
return realm.where(Message::class.java).equalTo("id", id) realm.refresh()
.findAllAsync()
.asFlowable() val message = realm.where(Message::class.java).equalTo("id", id).findFirst()
.filter { it.isLoaded } message?.let {
.filter { it.isValid } // Update the message in realm
.mapNotNull { it[0] } realm.executeTransaction {
.take(1) message.deliveryStatus = Sms.STATUS_COMPLETE
.doOnNext { message -> message.dateSent = System.currentTimeMillis()
// Update the message in realm message.read = true
realm.executeTransaction {
message.deliveryStatus = Sms.STATUS_COMPLETE
message.dateSent = System.currentTimeMillis()
message.read = true
}
}
.map { message -> message.getUri() }
.observeOn(Schedulers.computation())
.doOnNext { uri ->
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.STATUS, Sms.STATUS_COMPLETE)
values.put(Sms.DATE_SENT, System.currentTimeMillis())
values.put(Sms.READ, true)
context.contentResolver.update(uri, values, null, null)
} }
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.STATUS, Sms.STATUS_COMPLETE)
values.put(Sms.DATE_SENT, System.currentTimeMillis())
values.put(Sms.READ, true)
context.contentResolver.update(message.getUri(), values, null, null)
}
}
} }
fun markDeliveryFailed(id: Long, resultCode: Int): Flowable<*> { fun markDeliveryFailed(id: Long, resultCode: Int) {
val realm = Realm.getDefaultInstance() Realm.getDefaultInstance().use { realm ->
return realm.where(Message::class.java).equalTo("id", id) realm.refresh()
.findAllAsync()
.asFlowable() val message = realm.where(Message::class.java).equalTo("id", id).findFirst()
.filter { it.isLoaded } message?.let {
.filter { it.isValid } // Update the message in realm
.mapNotNull { it[0] } realm.executeTransaction {
.take(1) message.deliveryStatus = Sms.STATUS_FAILED
.doOnNext { message -> message.dateSent = System.currentTimeMillis()
// Update the message in realm message.read = true
realm.executeTransaction { message.errorCode = resultCode
message.deliveryStatus = Sms.STATUS_FAILED
message.dateSent = System.currentTimeMillis()
message.read = true
message.errorCode = resultCode
}
}
.map { message -> message.getUri() }
.observeOn(Schedulers.computation())
.doOnNext { uri ->
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.STATUS, Sms.STATUS_FAILED)
values.put(Sms.DATE_SENT, System.currentTimeMillis())
values.put(Sms.READ, true)
values.put(Sms.ERROR_CODE, resultCode)
context.contentResolver.update(uri, values, null, null)
} }
// Update the message in the native ContentProvider
val values = ContentValues()
values.put(Sms.STATUS, Sms.STATUS_FAILED)
values.put(Sms.DATE_SENT, System.currentTimeMillis())
values.put(Sms.READ, true)
values.put(Sms.ERROR_CODE, resultCode)
context.contentResolver.update(message.getUri(), values, null, null)
}
}
} }
fun deleteMessage(messageId: Long) { fun deleteMessage(messageId: Long) {
@@ -20,15 +20,13 @@ package interactor
import data.repository.MessageRepository import data.repository.MessageRepository
import io.reactivex.Flowable import io.reactivex.Flowable
import io.reactivex.android.schedulers.AndroidSchedulers
import javax.inject.Inject import javax.inject.Inject
class MarkDelivered @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Long, Any>() { class MarkDelivered @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Long, Unit>() {
override fun buildObservable(params: Long): Flowable<Any> { override fun buildObservable(params: Long): Flowable<Unit> {
return Flowable.just(Unit) return Flowable.just(Unit)
.observeOn(AndroidSchedulers.mainThread()) .doOnNext { messageRepo.markDelivered(params) }
.flatMap { messageRepo.markDelivered(params) }
} }
} }
@@ -20,19 +20,17 @@ package interactor
import data.repository.MessageRepository import data.repository.MessageRepository
import io.reactivex.Flowable import io.reactivex.Flowable
import io.reactivex.android.schedulers.AndroidSchedulers
import javax.inject.Inject import javax.inject.Inject
class MarkDeliveryFailed @Inject constructor( class MarkDeliveryFailed @Inject constructor(
private val messageRepo: MessageRepository) private val messageRepo: MessageRepository)
: Interactor<MarkDeliveryFailed.Params, Any>() { : Interactor<MarkDeliveryFailed.Params, Unit>() {
data class Params(val id: Long, val resultCode: Int) data class Params(val id: Long, val resultCode: Int)
override fun buildObservable(params: Params): Flowable<Any> { override fun buildObservable(params: Params): Flowable<Unit> {
return Flowable.just(Unit) return Flowable.just(Unit)
.observeOn(AndroidSchedulers.mainThread()) .doOnNext { messageRepo.markDeliveryFailed(params.id, params.resultCode) }
.flatMap { messageRepo.markDeliveryFailed(params.id, params.resultCode) }
} }
} }
+3 -5
View File
@@ -21,20 +21,18 @@ package interactor
import common.util.NotificationManager import common.util.NotificationManager
import data.repository.MessageRepository import data.repository.MessageRepository
import io.reactivex.Flowable import io.reactivex.Flowable
import io.reactivex.android.schedulers.AndroidSchedulers
import javax.inject.Inject import javax.inject.Inject
class MarkFailed @Inject constructor( class MarkFailed @Inject constructor(
private val messageRepo: MessageRepository, private val messageRepo: MessageRepository,
private val notificationManager: NotificationManager private val notificationManager: NotificationManager
) : Interactor<MarkFailed.Params, Any>() { ) : Interactor<MarkFailed.Params, Unit>() {
data class Params(val id: Long, val resultCode: Int) data class Params(val id: Long, val resultCode: Int)
override fun buildObservable(params: Params): Flowable<Any> { override fun buildObservable(params: Params): Flowable<Unit> {
return Flowable.just(Unit) return Flowable.just(Unit)
.observeOn(AndroidSchedulers.mainThread()) .doOnNext { messageRepo.markFailed(params.id, params.resultCode) }
.flatMap { messageRepo.markFailed(params.id, params.resultCode) }
.doOnNext { notificationManager.notifyFailed(params.id) } .doOnNext { notificationManager.notifyFailed(params.id) }
} }
+3 -3
View File
@@ -22,10 +22,10 @@ import data.repository.MessageRepository
import io.reactivex.Flowable import io.reactivex.Flowable
import javax.inject.Inject import javax.inject.Inject
class MarkSent @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Long, Long>() { class MarkSent @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Long, Unit>() {
override fun buildObservable(params: Long): Flowable<Long> { override fun buildObservable(params: Long): Flowable<Unit> {
return Flowable.just(params) return Flowable.just(Unit)
.doOnNext { messageRepo.markSent(params) } .doOnNext { messageRepo.markSent(params) }
} }
@@ -21,8 +21,6 @@ package interactor
import data.model.Message import data.model.Message
import data.repository.MessageRepository import data.repository.MessageRepository
import io.reactivex.Flowable import io.reactivex.Flowable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.schedulers.Schedulers
import javax.inject.Inject import javax.inject.Inject
class RetrySending @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Message, Message>() { class RetrySending @Inject constructor(private val messageRepo: MessageRepository) : Interactor<Message, Message>() {
@@ -42,8 +40,6 @@ class RetrySending @Inject constructor(private val messageRepo: MessageRepositor
return Flowable.just(message) return Flowable.just(message)
.filter { message.isSms() } // TODO support resending failed MMS .filter { message.isSms() } // TODO support resending failed MMS
.doOnNext { messageRepo.markSending(message.id) } .doOnNext { messageRepo.markSending(message.id) }
.subscribeOn(AndroidSchedulers.mainThread())
.observeOn(Schedulers.io())
.doOnNext { messageRepo.sendSms(message) } .doOnNext { messageRepo.sendSms(message) }
} }