Files
quik/qksms/src/main/java/data/repository/MessageRepository.kt
T

491 lines
19 KiB
Kotlin

/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package data.repository
import android.content.ContentValues
import android.content.Context
import android.net.Uri
import android.provider.BaseColumns
import android.provider.Telephony
import android.provider.Telephony.Sms
import android.provider.Telephony.TextBasedSmsColumns
import common.util.Keys
import common.util.MessageUtils
import common.util.extensions.*
import data.mapper.CursorToConversation
import data.mapper.CursorToPart
import data.mapper.CursorToRecipient
import data.model.Conversation
import data.model.InboxItem
import data.model.Message
import data.model.MmsPart
import io.reactivex.Flowable
import io.reactivex.Maybe
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.rxkotlin.Flowables
import io.reactivex.rxkotlin.toFlowable
import io.reactivex.schedulers.Schedulers
import io.realm.Realm
import io.realm.RealmList
import io.realm.RealmResults
import io.realm.Sort
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class MessageRepository @Inject constructor(
private val context: Context,
private val messageIds: Keys,
private val cursorToConversation: CursorToConversation,
private val cursorToPart: CursorToPart,
private val cursorToRecipient: CursorToRecipient) {
fun getConversations(archived: Boolean = false): Flowable<List<InboxItem>> {
val realm = Realm.getDefaultInstance()
val conversationFlowable = realm.where(Conversation::class.java)
.equalTo("archived", archived)
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.map { realm.copyFromRealm(it) }
val messageFlowable = realm.where(Message::class.java)
.sort("date", Sort.DESCENDING)
.distinctValues("threadId")
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.map { realm.copyFromRealm(it) }
return Flowables.combineLatest(conversationFlowable, messageFlowable, { conversations, messages ->
val conversationMap = conversations.associateBy { conversation -> conversation.id }
messages.mapNotNull { message ->
val conversation = conversationMap[message.threadId]
if (conversation == null) null else InboxItem(conversation, message)
}
})
}
fun getConversationAsync(threadId: Long): Conversation {
return Realm.getDefaultInstance()
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirstAsync()
}
fun getConversation(threadId: Long): Conversation? {
return Realm.getDefaultInstance()
.where(Conversation::class.java)
.equalTo("id", threadId)
.findFirst()
}
fun getOrCreateConversation(address: String): Maybe<Conversation> {
return getOrCreateConversation(listOf(address))
}
fun getOrCreateConversation(addresses: List<String>): Maybe<Conversation> {
return Maybe.just(addresses)
.map { recipients ->
recipients.map { address ->
when (MessageUtils.isEmailAddress(address)) {
true -> MessageUtils.extractAddrSpec(address)
false -> address
}
}
}
.map { recipients ->
Uri.parse("content://mms-sms/threadID").buildUpon().apply {
recipients.forEach { recipient -> appendQueryParameter("recipient", recipient) }
}
}
.flatMap { uriBuilder ->
context.contentResolver.query(uriBuilder.build(), arrayOf(BaseColumns._ID), null, null, null).asMaybe()
}
.map { cursor -> cursor.getLong(0) }
.filter { threadId -> threadId != 0L }
.map { threadId ->
var conversation = getConversation(threadId)
if (conversation != null) conversation = Realm.getDefaultInstance().copyFromRealm(conversation)
conversation ?: getConversationFromCp(threadId)?.apply { insertOrUpdate() } ?: Conversation()
}
.onErrorReturn { Conversation() }
.subscribeOn(Schedulers.io())
.observeOn(AndroidSchedulers.mainThread())
}
fun getMessages(threadId: Long): RealmResults<Message> {
return Realm.getDefaultInstance()
.where(Message::class.java)
.equalTo("threadId", threadId)
.findAllSorted("date")
}
fun loadParts(id: Long) {
Realm.getDefaultInstance()?.use { realm ->
realm.where(Message::class.java).equalTo("id", id).findFirst()?.let { message ->
realm.executeTransaction {
val parts = realm.copyToRealmOrUpdate(context.contentResolver.query(CursorToPart.CONTENT_URI, null,
"${Telephony.Mms.Part.MSG_ID} = ?", arrayOf(message.contentId.toString()), null)
.map { cursorToPart.map(it) })
message.parts = RealmList<MmsPart>().apply { addAll(parts) }
}
}
}
}
/**
* Retrieves the list of messages which should be shown in the notification
* for a given conversation
*/
fun getUnreadUnseenMessages(threadId: Long): RealmResults<Message> {
return Realm.getDefaultInstance()
.where(Message::class.java)
.equalTo("seen", false)
.equalTo("read", false)
.equalTo("threadId", threadId)
.findAllSorted("date")
}
fun markArchived(threadId: Long) {
val realm = Realm.getDefaultInstance()
val conversation = realm.where(Conversation::class.java)
.equalTo("id", threadId)
.equalTo("archived", false)
.findFirst()
realm.executeTransaction { conversation?.archived = true }
realm.close()
}
fun markUnarchived(threadId: Long) {
val realm = Realm.getDefaultInstance()
val conversation = realm.where(Conversation::class.java)
.equalTo("id", threadId)
.equalTo("archived", true)
.findFirst()
realm.executeTransaction { conversation?.archived = false }
realm.close()
}
fun markAllSeen() {
val realm = Realm.getDefaultInstance()
val messages = realm.where(Message::class.java).equalTo("seen", false).findAll()
realm.executeTransaction { messages.forEach { message -> message.seen = true } }
realm.close()
}
fun markSeen(threadId: Long) {
val realm = Realm.getDefaultInstance()
val messages = realm.where(Message::class.java)
.equalTo("threadId", threadId)
.equalTo("seen", false)
.findAll()
realm.executeTransaction {
messages.forEach { message ->
message.seen = true
}
}
realm.close()
}
fun markRead(threadId: Long) {
// TODO also need to mark MMS in ContentProvider as Read
val projection = arrayOf(BaseColumns._ID)
val selection = "${Sms.THREAD_ID} = $threadId AND (${Sms.SEEN} = 0 OR ${Sms.READ} = 0)"
val contentResolver = context.contentResolver
contentResolver.query(Sms.Inbox.CONTENT_URI, projection, selection, null, null)
.asFlowable()
.subscribeOn(Schedulers.io())
.map { cursor -> cursor.getLong(0) }
.map { id -> Uri.withAppendedPath(Sms.CONTENT_URI, id.toString()) }
.subscribe { uri ->
val values = ContentValues()
values.put(Sms.SEEN, true)
values.put(Sms.READ, true)
contentResolver.update(uri, values, null, null)
}
val realm = Realm.getDefaultInstance()
val messages = realm.where(Message::class.java)
.equalTo("threadId", threadId)
.beginGroup()
.equalTo("read", false)
.or()
.equalTo("seen", false)
.endGroup()
.findAll()
realm.executeTransaction {
messages.forEach { message ->
message.seen = true
message.read = true
}
}
realm.close()
}
fun insertSentSms(threadId: Long, address: String, body: String): Message {
// Insert the message to Realm
val message = Message().apply {
this.threadId = threadId
this.address = address
this.body = body
this.date = System.currentTimeMillis()
id = messageIds.newId()
boxId = Sms.MESSAGE_TYPE_OUTBOX
type = "sms"
read = true
seen = true
}
val realm = Realm.getDefaultInstance()
var managedMessage: Message? = null
realm.executeTransaction { managedMessage = realm.copyToRealm(message) }
// Insert the message to the native content provider
val values = ContentValues().apply {
put(Telephony.Sms.ADDRESS, address)
put(Telephony.Sms.BODY, body)
put(Telephony.Sms.DATE, System.currentTimeMillis())
put(Telephony.Sms.READ, true)
put(Telephony.Sms.SEEN, true)
put(Telephony.Sms.TYPE, Telephony.Sms.MESSAGE_TYPE_OUTBOX)
put(Telephony.Sms.THREAD_ID, threadId)
}
val uri = context.contentResolver.insert(Telephony.Sms.CONTENT_URI, values)
// Update the contentId after the message has been inserted to the content provider
realm.executeTransaction { managedMessage?.contentId = uri.lastPathSegment.toLong() }
realm.close()
return message
}
fun insertReceivedSms(address: String, body: String, sentTime: Long): Message {
// Insert the message to Realm
val message = Message().apply {
this.address = address
this.body = body
this.dateSent = sentTime
this.date = System.currentTimeMillis()
id = messageIds.newId()
threadId = getOrCreateConversation(address).blockingGet().id
boxId = Sms.MESSAGE_TYPE_INBOX
type = "sms"
}
val realm = Realm.getDefaultInstance()
var managedMessage: Message? = null
realm.executeTransaction { managedMessage = realm.copyToRealm(message) }
// Insert the message to the native content provider
val values = ContentValues().apply {
put(Telephony.Sms.ADDRESS, address)
put(Telephony.Sms.BODY, body)
put(Telephony.Sms.DATE_SENT, sentTime)
put(Telephony.Sms.READ, false)
put(Telephony.Sms.SEEN, false)
}
val uri = context.contentResolver.insert(Telephony.Sms.Inbox.CONTENT_URI, values)
// Update the contentId after the message has been inserted to the content provider
realm.executeTransaction { managedMessage?.contentId = uri.lastPathSegment.toLong() }
realm.close()
return message
}
fun markSent(id: Long): Flowable<*> {
val realm = Realm.getDefaultInstance()
return realm.where(Message::class.java).equalTo("id", id)
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.filter { it.isValid }
.mapNotNull { it[0] }
.take(1)
.doOnNext { message ->
// Update the message in realm
realm.executeTransaction {
message.boxId = Sms.MESSAGE_TYPE_SENT
}
}
.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_SENT)
context.contentResolver.update(uri, values, null, null)
}
}
fun markFailed(id: Long, resultCode: Int): Flowable<*> {
val realm = Realm.getDefaultInstance()
return realm.where(Message::class.java).equalTo("id", id)
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.filter { it.isValid }
.mapNotNull { it[0] }
.take(1)
.doOnNext { message ->
// 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)
}
}
fun markDelivered(id: Long): Flowable<*> {
val realm = Realm.getDefaultInstance()
return realm.where(Message::class.java).equalTo("id", id)
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.filter { it.isValid }
.mapNotNull { it[0] }
.take(1)
.doOnNext { message ->
// Update the message in realm
realm.executeTransaction {
message.deliveryStatus = Message.DeliveryStatus.RECEIVED
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, TextBasedSmsColumns.STATUS_COMPLETE)
values.put(Sms.DATE_SENT, System.currentTimeMillis())
values.put(Sms.READ, true)
context.contentResolver.update(uri, values, null, null)
}
}
fun markDeliveryFailed(id: Long, resultCode: Int): Flowable<*> {
val realm = Realm.getDefaultInstance()
return realm.where(Message::class.java).equalTo("id", id)
.findAllAsync()
.asFlowable()
.filter { it.isLoaded }
.filter { it.isValid }
.mapNotNull { it[0] }
.take(1)
.doOnNext { message ->
// Update the message in realm
realm.executeTransaction {
message.deliveryStatus = Message.DeliveryStatus.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, TextBasedSmsColumns.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)
}
}
fun deleteMessage(messageId: Long) {
val realm = Realm.getDefaultInstance()
realm.where(Message::class.java).equalTo("id", messageId).findFirst()?.let { message ->
val uri = message.getUri()
realm.executeTransaction { message.deleteFromRealm() }
context.contentResolver.delete(uri, null, null)
}
realm.close()
}
fun deleteConversation(threadId: Long) {
val realm = Realm.getDefaultInstance()
val conversation = realm.where(Conversation::class.java).equalTo("id", threadId).findAll()
val messages = realm.where(Message::class.java).equalTo("threadId", threadId).findAll()
realm.executeTransaction {
conversation.deleteAllFromRealm()
messages.deleteAllFromRealm()
}
realm.close()
val uri = Uri.withAppendedPath(Telephony.Threads.CONTENT_URI, threadId.toString())
context.contentResolver.delete(uri, null, null)
}
private fun getConversationFromCp(threadId: Long): Conversation? {
var conversation: Conversation? = null
val cursor = context.contentResolver.query(
CursorToConversation.URI,
CursorToConversation.PROJECTION,
"_id = ?",
arrayOf(threadId.toString()),
null)
if (cursor.moveToFirst()) {
conversation = cursorToConversation.map(cursor)
conversation.insertOrUpdate()
conversation.recipients.toFlowable()
.map { recipient -> recipient.id.toString() }
.map { id -> context.contentResolver.query(CursorToRecipient.URI, null, "_id = ?", arrayOf(id), null) }
.flatMap { recipientCursor -> recipientCursor.asFlowable().map { cursor -> cursorToRecipient.map(cursor) } }
.doOnNext { recipient -> recipient.insertOrUpdate() }
.blockingSubscribe()
}
cursor.close()
return conversation
}
}