Remove link between messages and conversations

data/src/main/java/mapper/CursorToConversationImpl.kt

@@ -33,20 +33,29 @@ class CursorToConversationImpl @Inject constructor(private val context: Context)
         val URI: Uri = Uri.parse("content://mms-sms/conversations?simple=true")
         val PROJECTION = arrayOf(
                 Threads._ID,
-                Threads.RECIPIENT_IDS)
+                Threads.DATE,
+                Threads.RECIPIENT_IDS,
+                Threads.READ,
+                Threads.SNIPPET)
 
-        val ID = 0
-        val RECIPIENT_IDS = 1
+        const val ID = 0
+        const val DATE = 1
+        const val RECIPIENT_IDS = 2
+        const val READ = 3
+        const val SNIPPET = 4
     }
 
     override fun map(from: Cursor): Conversation {
         return Conversation().apply {
             id = from.getLong(ID)
+            date = from.getLong(DATE)
             recipients.addAll(from.getString(RECIPIENT_IDS)
                     .split(" ")
                     .filter { it.isNotBlank() }
                     .map { recipientId -> recipientId.toLong() }
                     .map { recipientId -> Recipient().apply { id = recipientId } })
+            read = from.getInt(READ) == 1
+            snippet = from.getString(SNIPPET) ?: ""
         }
     }
 

data/src/main/java/mapper/CursorToMessageImpl.kt

@@ -24,7 +24,6 @@ import android.net.Uri
 import android.provider.Telephony.*
 import com.google.android.mms.pdu_alt.PduHeaders
 import manager.KeyManager
-import model.Conversation
 import model.Message
 import util.extensions.map
 import javax.inject.Inject
@@ -77,14 +76,13 @@ class CursorToMessageImpl @Inject constructor(
             }
 
             id = keys.newId()
+            threadId = cursor.getLong(columnsMap.threadId)
             contentId = cursor.getLong(columnsMap.msgId)
             date = cursor.getLong(columnsMap.date)
             dateSent = cursor.getLong(columnsMap.dateSent)
             read = cursor.getInt(columnsMap.read) != 0
             locked = cursor.getInt(columnsMap.locked) != 0
 
-            conversation = Conversation().apply { id = cursor.getLong(columnsMap.threadId) }
-
             when (type) {
                 "sms" -> {
                     address = cursor.getString(columnsMap.smsAddress) ?: ""

data/src/main/java/repository/MessageRepositoryImpl.kt

@@ -63,26 +63,24 @@ class MessageRepositoryImpl @Inject constructor(
         private val cursorToRecipient: CursorToRecipient,
         private val prefs: Preferences) : MessageRepository {
 
-    override fun getConversations(archived: Boolean): RealmResults<Message> {
+    override fun getConversations(archived: Boolean): RealmResults<Conversation> {
         return Realm.getDefaultInstance()
-                .where(Message::class.java)
-                .distinctValues("threadId")
-                .notEqualTo("threadId", 0L)
-                .equalTo("conversation.archived", archived)
-                .equalTo("conversation.blocked", false)
-                .isNotEmpty("conversation.recipients")
+                .where(Conversation::class.java)
+                .notEqualTo("id", 0L)
+                .equalTo("archived", archived)
+                .equalTo("blocked", false)
+                .isNotEmpty("recipients")
                 .sort("date", Sort.DESCENDING)
                 .findAllAsync()
     }
 
-    override fun getConversationsSnapshot(): List<Message> {
+    override fun getConversationsSnapshot(): List<Conversation> {
         val realm = Realm.getDefaultInstance()
-        return realm.copyFromRealm(realm.where(Message::class.java)
-                .distinctValues("threadId")
-                .notEqualTo("threadId", 0L)
-                .equalTo("conversation.archived", false)
-                .equalTo("conversation.blocked", false)
-                .isNotEmpty("conversation.recipients")
+        return realm.copyFromRealm(realm.where(Conversation::class.java)
+                .notEqualTo("id", 0L)
+                .equalTo("archived", false)
+                .equalTo("blocked", false)
+                .isNotEmpty("recipients")
                 .sort("date", Sort.DESCENDING)
                 .findAll())
     }
@@ -186,9 +184,9 @@ class MessageRepositoryImpl @Inject constructor(
                 .findFirst()
     }
 
-    override fun getUnreadMessageCount(): Long {
+    override fun getUnreadCount(): Long {
         return Realm.getDefaultInstance()
-                .where(Message::class.java)
+                .where(Conversation::class.java)
                 .equalTo("read", false)
                 .count()
     }
@@ -234,6 +232,30 @@ class MessageRepositoryImpl @Inject constructor(
                 .findAll()
     }
 
+    override fun updateConversation(threadId: Long) {
+        Realm.getDefaultInstance().use { realm ->
+            realm.refresh()
+
+            val conversation = realm
+                    .where(Conversation::class.java)
+                    .equalTo("id", threadId)
+                    .findFirst() ?: return
+
+            val message = realm
+                    .where(Message::class.java)
+                    .equalTo("threadId", threadId)
+                    .sort("date", Sort.DESCENDING)
+                    .findAll().first() ?: return
+
+            realm.executeTransaction {
+                conversation.date = message.date
+                conversation.snippet = message.getSummary()
+                conversation.read = message.read
+                conversation.me = message.isMe()
+            }
+        }
+    }
+
     override fun markArchived(threadId: Long) {
         val realm = Realm.getDefaultInstance()
         val conversation = realm.where(Conversation::class.java)
@@ -365,6 +387,7 @@ class MessageRepositoryImpl @Inject constructor(
 
         // Insert the message to Realm
         val message = Message().apply {
+            this.threadId = threadId
             this.address = address
             this.body = body
             this.date = System.currentTimeMillis()
@@ -374,8 +397,6 @@ class MessageRepositoryImpl @Inject constructor(
             type = "sms"
             read = true
             seen = true
-
-            conversation = getOrCreateConversation(threadId)
         }
         val realm = Realm.getDefaultInstance()
         var managedMessage: Message? = null
@@ -410,10 +431,9 @@ class MessageRepositoryImpl @Inject constructor(
             this.date = System.currentTimeMillis()
 
             id = messageIds.newId()
+            threadId = getOrCreateConversation(address).blockingGet().id
             boxId = Telephony.Sms.MESSAGE_TYPE_INBOX
             type = "sms"
-
-            conversation = getOrCreateConversation(address).blockingGet()
         }
         val realm = Realm.getDefaultInstance()
         var managedMessage: Message? = null

data/src/main/java/repository/SyncRepositoryImpl.kt

@@ -169,10 +169,7 @@ class SyncRepositoryImpl @Inject constructor(
         return cursor.asFlowable()
                 .map { cursorToMessage.map(Pair(it, columnsMap)) }
                 .doOnNext { message -> existingId?.let { message.id = it } }
-                .doOnNext { message ->
-                    val threadId = message.conversation?.id
-                    message.conversation = threadId?.let { messageRepo.getOrCreateConversation(threadId) }
-                }
+                .doOnNext { message -> messageRepo.getOrCreateConversation(message.threadId) }
                 .doOnNext { message -> message.insertOrUpdate() }
     }