Merge remote-tracking branch 'upstream/master' into emoji-reacts

This commit is contained in:
Ben Iofel
2025-09-02 18:01:14 -04:00
17 changed files with 227 additions and 176 deletions
@@ -36,7 +36,7 @@ class QkRealmMigration @Inject constructor(
) : RealmMigration {
companion object {
const val SchemaVersion: Long = 13
const val SchemaVersion: Long = 14
}
@SuppressLint("ApplySharedPref")
@@ -239,10 +239,6 @@ class QkRealmMigration @Inject constructor(
// Because there was never any property associated with which conversation/recipients a scheduled message was for,
// we can't update this field on a realm migration. It will be set to a default of 0
version++
}
if (version == 11L) {
realm.schema.create("MessageContentFilter")
.addField("id", Long::class.java, FieldAttribute.PRIMARY_KEY, FieldAttribute.REQUIRED)
.addField("value", String::class.java, FieldAttribute.REQUIRED)
@@ -254,6 +250,13 @@ class QkRealmMigration @Inject constructor(
}
if (version == 12L) {
realm.schema.get("Conversation")
?.addField("draftDate", Long::class.java, FieldAttribute.REQUIRED)
version++
}
if (version == 13L) {
val emojiReactionTable = realm.schema.create("EmojiReaction")
.addField("id", Long::class.java, FieldAttribute.PRIMARY_KEY, FieldAttribute.REQUIRED)
.addField("reactionMessageId", Long::class.java, FieldAttribute.INDEXED, FieldAttribute.REQUIRED)
@@ -353,6 +353,7 @@ class ConversationRepositoryImpl @Inject constructor(
realm.executeTransaction {
conversation?.takeIf { it.isValid }?.draft = draft
conversation?.takeIf { it.isValid }?.draftDate = System.currentTimeMillis()
}
}
@@ -173,9 +173,10 @@ open class MessageRepositoryImpl @Inject constructor(
val extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(part.type)
?: return null
val date = part.messages?.first()?.date
val fileName = part.name?.takeIf { name -> name.endsWith(extension) }
?: "${part.type.split("/").last()}_$date.$extension"
// fileDateAndTime is divided by 1000 in order to remove the extra 0's after date and time
// This way the file name isn't so long.
val fileDateAndTime = (part.messages?.first()?.date)?.div(1000)
val fileName = "QUIK_${part.type.split("/").last()}_$fileDateAndTime.$extension"
val values = contentValuesOf(
MediaStore.MediaColumns.DISPLAY_NAME to fileName,
@@ -21,6 +21,8 @@ package dev.octoshrimpy.quik.repository
import android.content.ContentResolver
import android.content.ContentUris
import android.net.Uri
import android.os.Handler
import android.os.HandlerThread
import android.provider.Telephony
import com.f2prateek.rx.preferences2.RxSharedPreferences
import dev.octoshrimpy.quik.extensions.forEach
@@ -51,6 +53,7 @@ import io.reactivex.subjects.Subject
import io.realm.Realm
import io.realm.RealmList
import io.realm.Sort
import timber.log.Timber
import javax.inject.Inject
import javax.inject.Singleton
@@ -75,181 +78,206 @@ class SyncRepositoryImpl @Inject constructor(
override fun syncMessages() {
val oldBlockedSenders = rxPrefs.getStringSet("pref_key_blocked_senders")
// If the sync is already running, don't try to do another one
if (syncProgress.blockingFirst() is SyncRepository.SyncProgress.Running) return
syncProgress.onNext(SyncRepository.SyncProgress.Running(0, 0, true))
val realm = Realm.getDefaultInstance()
realm.beginTransaction()
val handlerThread = HandlerThread("RealmSyncThread")
handlerThread.start()
Handler(handlerThread.looper).post {
Realm.getDefaultInstance().executeTransactionAsync(
{ realm ->
// Prepare existing conversation data
val persistedData = realm.copyFromRealm(
realm.where(Conversation::class.java)
.beginGroup()
.equalTo("archived", true)
.or()
.equalTo("blocked", true)
.or()
.equalTo("pinned", true)
.or()
.isNotEmpty("name")
.or()
.isNotNull("blockingClient")
.or()
.isNotEmpty("blockReason")
.endGroup()
.findAll()
).associateBy { conversation -> conversation.id }.toMutableMap()
val persistedData = realm.copyFromRealm(realm.where(Conversation::class.java)
.beginGroup()
.equalTo("archived", true)
.or()
.equalTo("blocked", true)
.or()
.equalTo("pinned", true)
.or()
.isNotEmpty("name")
.or()
.isNotNull("blockingClient")
.or()
.isNotEmpty("blockReason")
.endGroup()
.findAll())
.associateBy { conversation -> conversation.id }
.toMutableMap()
removeOldMessages(realm)
realm.delete(Contact::class.java)
realm.delete(ContactGroup::class.java)
realm.delete(Conversation::class.java)
realm.delete(Message::class.java)
realm.delete(MmsPart::class.java)
realm.delete(Recipient::class.java)
realm.delete(EmojiReaction::class.java)
keys.reset()
keys.reset()
val partsCursor = cursorToPart.getPartsCursor()
val messageCursor = cursorToMessage.getMessagesCursor()
val conversationCursor = cursorToConversation.getConversationsCursor()
val recipientCursor = cursorToRecipient.getRecipientCursor()
val partsCursor = cursorToPart.getPartsCursor()
val messageCursor = cursorToMessage.getMessagesCursor()
val conversationCursor = cursorToConversation.getConversationsCursor()
val recipientCursor = cursorToRecipient.getRecipientCursor()
val max = (partsCursor?.count ?: 0) +
(messageCursor?.count ?: 0) +
(conversationCursor?.count ?: 0) +
(recipientCursor?.count ?: 0)
val max = (partsCursor?.count ?: 0) +
(messageCursor?.count ?: 0) +
(conversationCursor?.count ?: 0) +
(recipientCursor?.count ?: 0)
var progress = 0
var progress = 0
// Sync message parts
partsCursor?.use {
partsCursor.forEach {
tryOrNull {
progress++
val part = cursorToPart.map(partsCursor)
realm.insertOrUpdate(part)
// Sync message parts
partsCursor?.use {
partsCursor.forEach { cursor ->
tryOrNull {
val part = cursorToPart.map(partsCursor)
realm.insertOrUpdate(part)
progress++
}
}
}
}
}
// Sync messages
messageCursor?.use {
val messageColumns = CursorToMessage.MessageColumns(messageCursor)
messageCursor.forEach { cursor ->
tryOrNull {
progress++
syncProgress.onNext(SyncRepository.SyncProgress.Running(max, progress, false))
val message = cursorToMessage.map(Pair(cursor, messageColumns)).apply {
if (isMms()) {
parts = RealmList<MmsPart>().apply {
addAll(realm.where(MmsPart::class.java)
.equalTo("messageId", contentId)
.findAll())
// Sync messages
messageCursor?.use {
val messageColumns = CursorToMessage.MessageColumns(messageCursor)
messageCursor.forEach { cursor ->
tryOrNull {
syncProgress.onNext(
SyncRepository.SyncProgress.Running(
max,
++progress,
false
)
)
val message = cursorToMessage.map(Pair(cursor, messageColumns)).apply {
if (isMms()) {
parts = RealmList<MmsPart>().apply {
addAll(
realm.where(MmsPart::class.java)
.equalTo("messageId", contentId)
.findAll()
)
}
}
}
realm.insertOrUpdate(message)
}
}
realm.insertOrUpdate(message)
}
}
}
// Migrate blocked conversations from 2.7.3
val oldBlockedSenders = rxPrefs.getStringSet("pref_key_blocked_senders")
oldBlockedSenders.get()
.map { threadIdString -> threadIdString.toLong() }
.filter { threadId -> !persistedData.contains(threadId) }
.forEach { threadId -> persistedData[threadId] = Conversation(id = threadId, blocked = true) }
// Sync conversations
conversationCursor?.use {
conversationCursor.forEach { cursor ->
tryOrNull {
progress++
syncProgress.onNext(SyncRepository.SyncProgress.Running(max, progress, false))
val conversation = cursorToConversation.map(cursor).apply {
persistedData[id]?.let { persistedConversation ->
archived = persistedConversation.archived
blocked = persistedConversation.blocked
pinned = persistedConversation.pinned
name = persistedConversation.name
blockingClient = persistedConversation.blockingClient
blockReason = persistedConversation.blockReason
}
lastMessage = realm.where(Message::class.java)
.sort("date", Sort.DESCENDING)
.equalTo("threadId", id)
.findFirst()
// Migrate blocked conversations from 2.7.3
oldBlockedSenders.get()
.map { threadIdString -> threadIdString.toLong() }
.filter { threadId -> !persistedData.contains(threadId) }
.forEach { threadId ->
persistedData[threadId] = Conversation(id = threadId, blocked = true)
}
realm.insertOrUpdate(conversation)
}
}
}
// Sync recipients
recipientCursor?.use {
val contacts = realm.copyToRealmOrUpdate(getContacts())
recipientCursor.forEach { cursor ->
tryOrNull {
progress++
syncProgress.onNext(SyncRepository.SyncProgress.Running(max, progress, false))
val recipient = cursorToRecipient.map(cursor).apply {
contact = contacts.firstOrNull { contact ->
contact.numbers.any { phoneNumberUtils.compare(address, it.address) }
// Sync conversations
conversationCursor?.use {
conversationCursor.forEach { cursor ->
tryOrNull {
syncProgress.onNext(
SyncRepository.SyncProgress.Running(
max,
++progress,
false
)
)
val conversation = cursorToConversation.map(cursor).apply {
persistedData[id]?.let { persistedConversation ->
archived = persistedConversation.archived
blocked = persistedConversation.blocked
pinned = persistedConversation.pinned
name = persistedConversation.name
blockingClient = persistedConversation.blockingClient
blockReason = persistedConversation.blockReason
}
lastMessage = realm.where(Message::class.java)
.sort("date", Sort.DESCENDING)
.equalTo("threadId", id)
.findFirst()
}
realm.insertOrUpdate(conversation)
}
}
realm.insertOrUpdate(recipient)
}
}
// Sync recipients
val contacts = realm.copyToRealmOrUpdate(getContacts())
recipientCursor?.use {
recipientCursor.forEach { cursor ->
tryOrNull {
syncProgress.onNext(
SyncRepository.SyncProgress.Running(
max,
++progress,
false
)
)
val rec = cursorToRecipient.map(cursor).apply {
contact = contacts.firstOrNull { c ->
c.numbers.any { num ->
phoneNumberUtils.compare(
address,
num.address
)
}
}
}
realm.insertOrUpdate(rec)
}
}
}
syncProgress.onNext(SyncRepository.SyncProgress.Running(0, 0, true))
// Now that we have all the messages, we can scan for emoji reactions
val allMessages = realm.where(Message::class.java)
.beginGroup()
.beginGroup()
.equalTo("type", "sms")
.isNotEmpty("body")
.endGroup()
.or()
.beginGroup()
.equalTo("type", "mms")
.isNotEmpty("parts.text")
.endGroup()
.endGroup()
.sort("date", Sort.ASCENDING) // parse oldest to newest to handle reactions & removals properly
.findAll()
allMessages.forEach { message ->
val text = message.getText(false)
val parsedReaction = EmojiReactionUtils.parseEmojiReaction(text)
if (parsedReaction != null) {
val targetMessage = EmojiReactionUtils.findTargetMessage(
message.threadId,
parsedReaction.originalMessage,
realm
)
EmojiReactionUtils.saveEmojiReaction(
message,
parsedReaction,
targetMessage,
keys,
realm,
)
}
}
realm.insert(SyncLog())
}, {
handlerThread.quitSafely()
oldBlockedSenders.delete()
syncProgress.onNext(SyncRepository.SyncProgress.Idle)
},
{ error ->
handlerThread.quitSafely()
Timber.e(error, "syncMessages Failed")
syncProgress.onNext(SyncRepository.SyncProgress.Idle)
})
}
syncProgress.onNext(SyncRepository.SyncProgress.Running(0, 0, true))
// Now that we have all the messages, we can scan for emoji reactions
val allMessages = realm.where(Message::class.java)
.beginGroup()
.beginGroup()
.equalTo("type", "sms")
.isNotEmpty("body")
.endGroup()
.or()
.beginGroup()
.equalTo("type", "mms")
.isNotEmpty("parts.text")
.endGroup()
.endGroup()
.sort("date", Sort.ASCENDING) // parse oldest to newest to handle reactions & removals properly
.findAll()
allMessages.forEach { message ->
val text = message.getText(false)
val parsedReaction = EmojiReactionUtils.parseEmojiReaction(text)
if (parsedReaction != null) {
val targetMessage = EmojiReactionUtils.findTargetMessage(
message.threadId,
parsedReaction.originalMessage,
realm
)
EmojiReactionUtils.saveEmojiReaction(
message,
parsedReaction,
targetMessage,
keys,
realm,
)
}
}
realm.insert(SyncLog())
realm.commitTransaction()
realm.close()
// Only delete this after the sync has successfully completed
oldBlockedSenders.delete()
syncProgress.onNext(SyncRepository.SyncProgress.Idle)
}
override fun syncMessage(uri: Uri): Message? {
// If we don't have a valid type, return null
@@ -403,4 +431,14 @@ class SyncRepositoryImpl @Inject constructor(
return groups
}
private fun removeOldMessages(realm: Realm) {
realm.delete(Contact::class.java)
realm.delete(ContactGroup::class.java)
realm.delete(Conversation::class.java)
realm.delete(Message::class.java)
realm.delete(MmsPart::class.java)
realm.delete(Recipient::class.java)
realm.delete(EmojiReaction::class.java)
}
}