Merge pull request #418 from gavine99/mesages-seen-read-congruence

maintain setting messages seen and read congruence with native provider db
This commit is contained in:
octoshrimpy
2025-04-08 11:28:25 -04:00
committed by GitHub
8 changed files with 602 additions and 431 deletions
@@ -21,7 +21,6 @@ package dev.octoshrimpy.quik.repository
import android.app.AlarmManager import android.app.AlarmManager
import android.app.PendingIntent import android.app.PendingIntent
import android.content.ContentUris import android.content.ContentUris
import android.content.ContentValues
import android.content.Context import android.content.Context
import android.content.Intent import android.content.Intent
import android.graphics.BitmapFactory import android.graphics.BitmapFactory
@@ -63,7 +62,6 @@ import dev.octoshrimpy.quik.util.Preferences
import dev.octoshrimpy.quik.util.tryOrNull import dev.octoshrimpy.quik.util.tryOrNull
import io.realm.Case import io.realm.Case
import io.realm.Realm import io.realm.Realm
import io.realm.RealmQuery
import io.realm.RealmResults import io.realm.RealmResults
import io.realm.Sort import io.realm.Sort
import timber.log.Timber import timber.log.Timber
@@ -80,11 +78,15 @@ open class MessageRepositoryImpl @Inject constructor(
private val messageIds: KeyManager, private val messageIds: KeyManager,
private val phoneNumberUtils: PhoneNumberUtils, private val phoneNumberUtils: PhoneNumberUtils,
private val prefs: Preferences, private val prefs: Preferences,
private val syncRepository: SyncRepository private val syncRepository: SyncRepository,
) : MessageRepository { ) : MessageRepository {
private fun getMessagesBase(threadId: Long, query: String): RealmQuery<Message> { companion object {
return Realm.getDefaultInstance() const val TELEPHONY_UPDATE_CHUNK_SIZE = 200
}
private fun getMessagesBase(threadId: Long, query: String) =
Realm.getDefaultInstance()
.where(Message::class.java) .where(Message::class.java)
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.let { .let {
@@ -99,33 +101,28 @@ open class MessageRepositoryImpl @Inject constructor(
} }
} }
.sort("date") .sort("date")
}
override fun getMessages(threadId: Long, query: String): RealmResults<Message> { override fun getMessages(threadId: Long, query: String): RealmResults<Message> =
return getMessagesBase(threadId, query).findAllAsync() getMessagesBase(threadId, query).findAllAsync()
}
override fun getMessagesSync(threadId: Long, query: String): RealmResults<Message> { override fun getMessagesSync(threadId: Long, query: String): RealmResults<Message> =
return getMessagesBase(threadId, query).findAll() getMessagesBase(threadId, query).findAll()
}
override fun getMessage(id: Long): Message? { override fun getMessage(id: Long) =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.also { realm -> realm.refresh() } .also { it.refresh() }
.where(Message::class.java) .where(Message::class.java)
.equalTo("id", id) .equalTo("id", id)
.findFirst() .findFirst()
}
override fun getMessageForPart(id: Long): Message? { override fun getMessageForPart(id: Long) =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Message::class.java) .where(Message::class.java)
.equalTo("parts.id", id) .equalTo("parts.id", id)
.findFirst() .findFirst()
}
override fun getLastIncomingMessage(threadId: Long): RealmResults<Message> { override fun getLastIncomingMessage(threadId: Long): RealmResults<Message> =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Message::class.java) .where(Message::class.java)
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.beginGroup() .beginGroup()
@@ -141,10 +138,9 @@ open class MessageRepositoryImpl @Inject constructor(
.endGroup() .endGroup()
.sort("date", Sort.DESCENDING) .sort("date", Sort.DESCENDING)
.findAll() .findAll()
}
override fun getUnreadCount(): Long { override fun getUnreadCount() =
return Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
realm.where(Conversation::class.java) realm.where(Conversation::class.java)
.equalTo("archived", false) .equalTo("archived", false)
@@ -152,17 +148,15 @@ open class MessageRepositoryImpl @Inject constructor(
.equalTo("lastMessage.read", false) .equalTo("lastMessage.read", false)
.count() .count()
} }
}
override fun getPart(id: Long): MmsPart? { override fun getPart(id: Long) =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(MmsPart::class.java) .where(MmsPart::class.java)
.equalTo("id", id) .equalTo("id", id)
.findFirst() .findFirst()
}
override fun getPartsForConversation(threadId: Long): RealmResults<MmsPart> { override fun getPartsForConversation(threadId: Long): RealmResults<MmsPart> =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(MmsPart::class.java) .where(MmsPart::class.java)
.equalTo("messages.threadId", threadId) .equalTo("messages.threadId", threadId)
.beginGroup() .beginGroup()
@@ -172,12 +166,12 @@ open class MessageRepositoryImpl @Inject constructor(
.endGroup() .endGroup()
.sort("id", Sort.DESCENDING) .sort("id", Sort.DESCENDING)
.findAllAsync() .findAllAsync()
}
override fun savePart(id: Long): Uri? { override fun savePart(id: Long): Uri? {
val part = getPart(id) ?: return null val part = getPart(id) ?: return null
val extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(part.type) ?: return null val extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(part.type)
?: return null
val date = part.messages?.first()?.date val date = part.messages?.first()?.date
val fileName = part.name?.takeIf { name -> name.endsWith(extension) } val fileName = part.name?.takeIf { name -> name.endsWith(extension) }
?: "${part.type.split("/").last()}_$date.$extension" ?: "${part.type.split("/").last()}_$date.$extension"
@@ -189,25 +183,28 @@ open class MessageRepositoryImpl @Inject constructor(
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
values.put(MediaStore.MediaColumns.IS_PENDING, 1) values.put(MediaStore.MediaColumns.IS_PENDING, 1)
values.put(MediaStore.MediaColumns.RELATIVE_PATH, when { values.put(
MediaStore.MediaColumns.RELATIVE_PATH, when {
part.isImage() -> "${Environment.DIRECTORY_PICTURES}/QUIK" part.isImage() -> "${Environment.DIRECTORY_PICTURES}/QUIK"
part.isVideo() -> "${Environment.DIRECTORY_MOVIES}/QUIK" part.isVideo() -> "${Environment.DIRECTORY_MOVIES}/QUIK"
else -> "${Environment.DIRECTORY_DOWNLOADS}/QUIK" else -> "${Environment.DIRECTORY_DOWNLOADS}/QUIK"
}) }
)
} }
val contentUri = when { val contentUri = when {
part.isImage() -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI part.isImage() -> MediaStore.Images.Media.EXTERNAL_CONTENT_URI
part.isVideo() -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI part.isVideo() -> MediaStore.Video.Media.EXTERNAL_CONTENT_URI
Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q -> MediaStore.Downloads.EXTERNAL_CONTENT_URI Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q ->
MediaStore.Downloads.EXTERNAL_CONTENT_URI
else -> MediaStore.Files.getContentUri("external") else -> MediaStore.Files.getContentUri("external")
} }
val resolver = context.contentResolver
val uri = resolver.insert(contentUri, values) val uri = context.contentResolver.insert(contentUri, values)
Timber.v("Saving $fileName (${part.type}) to $uri") Timber.v("Saving $fileName (${part.type}) to $uri")
uri?.let { uri?.let {
resolver.openOutputStream(uri)?.use { outputStream -> context.contentResolver.openOutputStream(uri)?.use { outputStream ->
context.contentResolver.openInputStream(part.getUri())?.use { inputStream -> context.contentResolver.openInputStream(part.getUri())?.use { inputStream ->
inputStream.copyTo(outputStream, 1024) inputStream.copyTo(outputStream, 1024)
} }
@@ -215,7 +212,12 @@ open class MessageRepositoryImpl @Inject constructor(
Timber.v("Saved $fileName (${part.type}) to $uri") Timber.v("Saved $fileName (${part.type}) to $uri")
if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) { if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) {
resolver.update(uri, contentValuesOf(MediaStore.MediaColumns.IS_PENDING to 0), null, null) context.contentResolver.update(
uri,
contentValuesOf(MediaStore.MediaColumns.IS_PENDING to 0),
null,
null
)
Timber.v("Marked $uri as not pending") Timber.v("Marked $uri as not pending")
} }
} }
@@ -223,12 +225,8 @@ open class MessageRepositoryImpl @Inject constructor(
return uri return uri
} }
/** override fun getUnreadUnseenMessages(threadId: Long): RealmResults<Message> =
* Retrieves the list of messages which should be shown in the notification Realm.getDefaultInstance()
* for a given conversation
*/
override fun getUnreadUnseenMessages(threadId: Long): RealmResults<Message> {
return Realm.getDefaultInstance()
.also { it.refresh() } .also { it.refresh() }
.where(Message::class.java) .where(Message::class.java)
.equalTo("seen", false) .equalTo("seen", false)
@@ -236,93 +234,159 @@ open class MessageRepositoryImpl @Inject constructor(
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.sort("date") .sort("date")
.findAll() .findAll()
}
override fun getUnreadMessages(threadId: Long): RealmResults<Message> { override fun getUnreadMessages(threadId: Long): RealmResults<Message> =
return Realm.getDefaultInstance() Realm.getDefaultInstance()
.where(Message::class.java) .where(Message::class.java)
.equalTo("read", false) .equalTo("read", false)
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.sort("date") .sort("date")
.findAll() .findAll()
// marks all messages in threads as read and/or seen in the native provider
private fun telephonyMarkSeenRead(
seen: Boolean?,
read: Boolean?,
threadIds: Collection<Long>,
): Int {
if (((seen == null) && (read == null)) || threadIds.isEmpty())
return -1
var countUpdated = 0
// 'read' can be modified at the conversation level which updates all messages
read?.let {
tryOrNull(true) {
// chunked so where clause doesn't get too long if there are many threads
threadIds.forEach {
countUpdated += context.contentResolver.update(
ContentUris.withAppendedId(
Telephony.MmsSms.CONTENT_CONVERSATIONS_URI,
it
),
contentValuesOf(Sms.READ to read),
"${Sms.READ} = ${if (read) 0 else 1}",
null
)
}
}
} }
override fun markAllSeen() { seen?.let {
val realm = Realm.getDefaultInstance() // 'seen' has to be modified at the messages level
val messages = realm.where(Message::class.java).equalTo("seen", false).findAll() threadIds.chunked(TELEPHONY_UPDATE_CHUNK_SIZE).forEach {
realm.executeTransaction { messages.forEach { message -> message.seen = true } } // chunked for smaller where clause size
realm.close() val values = contentValuesOf(Sms.SEEN to seen)
val whereClause ="${Sms.SEEN} = ${if (seen) 0 else 1} " +
"and ${Sms.THREAD_ID} in (${it.joinToString(",")})"
// sms messages
tryOrNull(true) {
countUpdated += context.contentResolver.update(
Sms.CONTENT_URI,
values,
whereClause,
null
)
} }
override fun markSeen(threadId: Long) { // mms messages
val realm = Realm.getDefaultInstance() tryOrNull(true) {
val messages = realm.where(Message::class.java) countUpdated += context.contentResolver.update(
Mms.CONTENT_URI,
values,
whereClause,
null
)
}
}
}
return countUpdated // a mix of convo and message updates, so not overly useful. meh
}
override fun markAllSeen() =
mutableSetOf<Long>().let { threadIds ->
Realm.getDefaultInstance().use { realm ->
realm.where(Message::class.java)
.equalTo("seen", false)
.findAll()
.takeIf { it.isNotEmpty() }
?.let { messages ->
realm.executeTransaction {
messages.forEach {
it.seen = true
threadIds += it.threadId
}
}
}
}.run {
telephonyMarkSeenRead(true, null, threadIds)
}
}
override fun markSeen(threadId: Long) =
Realm.getDefaultInstance().use { realm ->
realm.where(Message::class.java)
.equalTo("threadId", threadId) .equalTo("threadId", threadId)
.equalTo("seen", false) .equalTo("seen", false)
.findAll() .findAll()
.let { messages ->
realm.executeTransaction { realm.executeTransaction {
messages.forEach { message -> messages.forEach { it.seen = true }
message.seen = true
} }
} }
realm.close() }.run {
telephonyMarkSeenRead(true, null, listOf(threadId))
} }
override fun markRead(vararg threadIds: Long) { override fun markRead(threadIds: Collection<Long>) =
threadIds.takeIf { it.isNotEmpty() }
?.let {
Realm.getDefaultInstance()?.use { realm -> Realm.getDefaultInstance()?.use { realm ->
val messages = realm.where(Message::class.java) realm.where(Message::class.java)
.anyOf("threadId", threadIds) .anyOf("threadId", threadIds.toLongArray())
.beginGroup() .beginGroup()
.equalTo("read", false) .equalTo("read", false)
.or() .or()
.equalTo("seen", false) .equalTo("seen", false)
.endGroup() .endGroup()
.findAll() .findAll()
.let { messages ->
realm.executeTransaction { realm.executeTransaction {
messages.forEach { message -> messages.forEach { it.seen = true; it.read = true }
message.seen = true
message.read = true
} }
} }
}.run {
telephonyMarkSeenRead(true, true, threadIds)
} }
}
?: 0
val values = ContentValues() override fun markUnread(threadIds: Collection<Long>) =
values.put(Sms.SEEN, true) threadIds.takeIf { it.isNotEmpty() }
values.put(Sms.READ, true) ?.let {
threadIds.forEach { threadId ->
try {
val uri = ContentUris.withAppendedId(Telephony.MmsSms.CONTENT_CONVERSATIONS_URI, threadId)
context.contentResolver.update(uri, values, "${Sms.READ} = 0", null)
} catch (exception: Exception) {
Timber.w(exception)
}
}
}
override fun markUnread(vararg threadIds: Long) {
Realm.getDefaultInstance()?.use { realm -> Realm.getDefaultInstance()?.use { realm ->
val conversations = realm.where(Conversation::class.java) val conversations = realm.where(Conversation::class.java)
.anyOf("id", threadIds) .anyOf("id", threadIds.toLongArray())
.equalTo("lastMessage.read", true) .equalTo("lastMessage.read", true)
.findAll() .findAll()
realm.executeTransaction { realm.executeTransaction {
conversations.forEach { conversation -> conversations.forEach { it.lastMessage?.read = false }
conversation.lastMessage?.read = false }
} }.run {
} telephonyMarkSeenRead(null, false, threadIds)
} }
} }
?: 0
override fun sendMessage( override fun sendMessage(
subId: Int, subId: Int,
threadId: Long, threadId: Long,
addresses: List<String>, addresses: Collection<String>,
body: String, body: String,
attachments: List<Attachment>, attachments: Collection<Attachment>,
delay: Int delay: Int
) { ) {
val signedBody = when { val signedBody = when {
@@ -347,23 +411,36 @@ open class MessageRepositoryImpl @Inject constructor(
if (addresses.size == 1 && attachments.isEmpty() && !forceMms) { // SMS if (addresses.size == 1 && attachments.isEmpty() && !forceMms) { // SMS
if (delay > 0) { // With delay if (delay > 0) { // With delay
val sendTime = System.currentTimeMillis() + delay val sendTime = System.currentTimeMillis() + delay
val message = insertSentSms(subId, threadId, addresses.first(), strippedBody, sendTime) val message = insertSentSms(
subId,
threadId,
addresses.first(),
strippedBody,
sendTime
)
val intent = getIntentForDelayedSms(message.id) val intent = getIntentForDelayedSms(message.id)
val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager
alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, sendTime, intent) alarmManager.setExactAndAllowWhileIdle(AlarmManager.RTC_WAKEUP, sendTime, intent)
} else { // No delay } else { // No delay
val message = insertSentSms(subId, threadId, addresses.first(), strippedBody, now()) val message = insertSentSms(
subId,
threadId,
addresses.first(),
strippedBody, now()
)
sendSms(message) sendSms(message)
} }
} else { // MMS } else { // MMS
val parts = arrayListOf<MMSPart>() val parts = arrayListOf<MMSPart>()
val maxWidth = smsManager.carrierConfigValues.getInt(SmsManager.MMS_CONFIG_MAX_IMAGE_WIDTH) val maxWidth = smsManager.carrierConfigValues
.getInt(SmsManager.MMS_CONFIG_MAX_IMAGE_WIDTH)
.takeIf { prefs.mmsSize.get() == -1 } ?: Int.MAX_VALUE .takeIf { prefs.mmsSize.get() == -1 } ?: Int.MAX_VALUE
val maxHeight = smsManager.carrierConfigValues.getInt(SmsManager.MMS_CONFIG_MAX_IMAGE_HEIGHT) val maxHeight = smsManager.carrierConfigValues
.getInt(SmsManager.MMS_CONFIG_MAX_IMAGE_HEIGHT)
.takeIf { prefs.mmsSize.get() == -1 } ?: Int.MAX_VALUE .takeIf { prefs.mmsSize.get() == -1 } ?: Int.MAX_VALUE
var remainingBytes = when (prefs.mmsSize.get()) { var remainingBytes = when (prefs.mmsSize.get()) {
@@ -413,12 +490,16 @@ open class MessageRepositoryImpl @Inject constructor(
val imageByteCount = imageBytesByAttachment.values.sumOf { it.size } val imageByteCount = imageBytesByAttachment.values.sumOf { it.size }
if (imageByteCount > remainingBytes) { if (imageByteCount > remainingBytes) {
imageBytesByAttachment.forEach { (attachment, originalBytes) -> imageBytesByAttachment.forEach { (attachment, originalBytes) ->
val uri = attachment.uri ?: return@forEach val uri = attachment.uri
val maxBytes = originalBytes.size / imageByteCount.toFloat() * remainingBytes val maxBytes = originalBytes.size / imageByteCount.toFloat() * remainingBytes
// Get the image dimensions // Get the image dimensions
val options = BitmapFactory.Options().apply { inJustDecodeBounds = true } val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
BitmapFactory.decodeStream(context.contentResolver.openInputStream(uri), null, options) BitmapFactory.decodeStream(
context.contentResolver.openInputStream(uri),
null,
options
)
val width = options.outWidth val width = options.outWidth
val height = options.outHeight val height = options.outHeight
val aspectRatio = width.toFloat() / height.toFloat() val aspectRatio = width.toFloat() / height.toFloat()
@@ -427,11 +508,12 @@ open class MessageRepositoryImpl @Inject constructor(
var scaledBytes = originalBytes var scaledBytes = originalBytes
while (scaledBytes.size > maxBytes) { while (scaledBytes.size > maxBytes) {
// Estimate how much we need to scale the image down by. If it's still too big, we'll need to // Estimate how much we need to scale the image down by. If it's still
// try smaller and smaller values // too big, we'll need to try smaller and smaller values
val scale = maxBytes / originalBytes.size * (0.9 - attempts * 0.2) val scale = maxBytes / originalBytes.size * (0.9 - attempts * 0.2)
if (scale <= 0) { if (scale <= 0) {
Timber.w("Failed to compress ${originalBytes.size / 1024}Kb to ${maxBytes.toInt() / 1024}Kb") Timber.w("Failed to compress ${originalBytes.size / 1024
}Kb to ${maxBytes.toInt() / 1024}Kb")
return@forEach return@forEach
} }
@@ -441,17 +523,31 @@ open class MessageRepositoryImpl @Inject constructor(
attempts++ attempts++
scaledBytes = when (attachment.getType(context) == "image/gif") { scaledBytes = when (attachment.getType(context) == "image/gif") {
true -> ImageUtils.getScaledGif(context, attachment.uri, newWidth, newHeight) true -> ImageUtils.getScaledGif(
false -> ImageUtils.getScaledImage(context, attachment.uri, newWidth, newHeight) context,
attachment.uri,
newWidth,
newHeight
)
false -> ImageUtils.getScaledImage(
context,
attachment.uri,
newWidth,
newHeight
)
} }
Timber.d("Compression attempt $attempts: ${scaledBytes.size / 1024}/${maxBytes.toInt() / 1024}Kb ($width*$height -> $newWidth*$newHeight)") Timber.d("Compression attempt $attempts: ${scaledBytes.size / 1024
}/${maxBytes.toInt() / 1024}Kb ($width*$height -> $newWidth*${
newHeight})")
// release the attachment hold on the image bytes so the GC can reclaim // release the attachment hold on the image bytes so the GC can reclaim
attachment.releaseResourceBytes() attachment.releaseResourceBytes()
} }
Timber.v("Compressed ${originalBytes.size / 1024}Kb to ${scaledBytes.size / 1024}Kb with a target size of ${maxBytes.toInt() / 1024}Kb in $attempts attempts") Timber.v("Compressed ${originalBytes.size / 1024}Kb to ${
scaledBytes.size / 1024}Kb with a target size of ${
maxBytes.toInt() / 1024}Kb in $attempts attempts")
imageBytesByAttachment[attachment] = scaledBytes imageBytesByAttachment[attachment] = scaledBytes
} }
} }
@@ -463,10 +559,18 @@ open class MessageRepositoryImpl @Inject constructor(
} }
} }
// We need to strip the separators from outgoing MMS, or else they'll appear to have sent and not go through // We need to strip the separators from outgoing MMS, or else they'll appear to have
// sent and not go through
val transaction = Transaction(context) val transaction = Transaction(context)
val recipients = addresses.map(phoneNumberUtils::normalizeNumber) val recipients = addresses.map(phoneNumberUtils::normalizeNumber)
transaction.sendNewMessage(subId, threadId, recipients, parts, null, null) transaction.sendNewMessage(
subId,
threadId,
recipients,
parts,
null,
null
)
} }
} }
@@ -475,29 +579,40 @@ open class MessageRepositoryImpl @Inject constructor(
?.let(SmsManagerFactory::createSmsManager) ?.let(SmsManagerFactory::createSmsManager)
?: SmsManager.getDefault() ?: SmsManager.getDefault()
val parts = smsManager val parts = smsManager.divideMessage(
.divideMessage(if (prefs.unicode.get()) StripAccents.stripAccents(message.body) else message.body) if (prefs.unicode.get()) StripAccents.stripAccents(message.body)
else message.body
)
?: arrayListOf() ?: arrayListOf()
val sentIntents = parts.map {
val intent = Intent(context, SmsSentReceiver::class.java).putExtra("id", message.id)
PendingIntent.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
}
val deliveredIntents = parts.map {
val intent = Intent(context, SmsDeliveredReceiver::class.java).putExtra("id", message.id)
val pendingIntent = PendingIntent
.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
if (prefs.delivery.get()) pendingIntent else null
}
try { try {
smsManager.sendMultipartTextMessage( smsManager.sendMultipartTextMessage(
message.address, message.address,
null, null,
parts, parts,
ArrayList(sentIntents), ArrayList(
ArrayList(deliveredIntents) parts.map {
PendingIntent.getBroadcast(
context,
message.id.toInt(),
Intent(context, SmsSentReceiver::class.java)
.putExtra("id", message.id),
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
}
),
ArrayList(
parts.map {
val pendingIntent = PendingIntent.getBroadcast(
context,
message.id.toInt(),
Intent(context, SmsDeliveredReceiver::class.java)
.putExtra("id", message.id),
PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
)
if (prefs.delivery.get()) pendingIntent else null
}
)
) )
} catch (e: IllegalArgumentException) { } catch (e: IllegalArgumentException) {
Timber.w(e, "Message body lengths: ${parts.map { it?.length }}") Timber.w(e, "Message body lengths: ${parts.map { it?.length }}")
@@ -505,37 +620,49 @@ open class MessageRepositoryImpl @Inject constructor(
} }
} }
override fun resendMms(message: Message) { override fun resendMms(message: Message) =
val subId = message.subId tryOrNull {
val threadId = message.threadId
val pdu = tryOrNull {
PduPersister.getPduPersister(context).load(message.getUri()) as MultimediaMessagePdu PduPersister.getPduPersister(context).load(message.getUri()) as MultimediaMessagePdu
} ?: return }
?.let { pdu ->
val addresses = pdu.to.map { it.string }.filter { it.isNotBlank() } Transaction(context).sendNewMessage(
val parts = message.parts.mapNotNull { part -> message.subId,
message.threadId,
pdu.to.map { it.string }.filter { it.isNotBlank() },
message.parts.mapNotNull { part ->
val bytes = tryOrNull(false) { val bytes = tryOrNull(false) {
context.contentResolver.openInputStream(part.getUri())?.use { inputStream -> inputStream.readBytes() } context.contentResolver.openInputStream(part.getUri())?.use {
inputStream -> inputStream.readBytes()
}
} ?: return@mapNotNull null } ?: return@mapNotNull null
MMSPart(part.name.orEmpty(), part.type, bytes) MMSPart(part.name.orEmpty(), part.type, bytes)
},
message.subject,
message.getUri()
)
} }
?: Unit
Transaction(context).sendNewMessage(subId, threadId, addresses, parts, message.subject, message.getUri()) override fun cancelDelayedSms(id: Long) =
} (context.getSystemService(Context.ALARM_SERVICE) as AlarmManager)
.cancel(getIntentForDelayedSms(id))
override fun cancelDelayedSms(id: Long) { private fun getIntentForDelayedSms(id: Long) =
val alarmManager = context.getSystemService(Context.ALARM_SERVICE) as AlarmManager PendingIntent.getBroadcast(
alarmManager.cancel(getIntentForDelayedSms(id)) context,
} id.toInt(),
Intent(context, SendSmsReceiver::class.java).putExtra("id", id),
private fun getIntentForDelayedSms(id: Long): PendingIntent { PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE
val intent = Intent(context, SendSmsReceiver::class.java).putExtra("id", id) )
return PendingIntent.getBroadcast(context, id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT or PendingIntent.FLAG_IMMUTABLE)
}
override fun insertSentSms(subId: Int, threadId: Long, address: String, body: String, date: Long): Message {
override fun insertSentSms(
subId: Int,
threadId: Long,
address: String,
body: String,
date: Long
): Message {
// Insert the message to Realm // Insert the message to Realm
val message = Message().apply { val message = Message().apply {
this.threadId = threadId this.threadId = threadId
@@ -550,9 +677,6 @@ open class MessageRepositoryImpl @Inject constructor(
read = true read = true
seen = true seen = true
} }
val realm = Realm.getDefaultInstance()
var managedMessage: Message? = null
realm.executeTransaction { managedMessage = realm.copyToRealmOrUpdate(message) }
// Insert the message to the native content provider // Insert the message to the native content provider
val values = contentValuesOf( val values = contentValuesOf(
@@ -565,34 +689,44 @@ open class MessageRepositoryImpl @Inject constructor(
Sms.THREAD_ID to threadId Sms.THREAD_ID to threadId
) )
if (prefs.canUseSubId.get()) { if (prefs.canUseSubId.get())
values.put(Sms.SUBSCRIPTION_ID, message.subId) values.put(Sms.SUBSCRIPTION_ID, message.subId)
}
val uri = context.contentResolver.insert(Sms.CONTENT_URI, values) var uri: Uri?
var managedMessage: Message? = null
Realm.getDefaultInstance().use { realm ->
realm.executeTransaction { managedMessage = realm.copyToRealmOrUpdate(message) }
// Update the contentId after the message has been inserted to the content provider // Update the contentId after the message has been inserted to the content provider
// The message might have been deleted by now, so only proceed if it's valid // The message might have been deleted by now, so only proceed if it's valid
// //
// We do this after inserting the message because it might be slow, and we want the message // do this after inserting the message because it might be slow, and we want the message
// to be inserted into Realm immediately. We don't need to do this after receiving one // to be inserted into Realm immediately. We don't need to do this after receiving one
uri?.lastPathSegment?.toLong()?.let { id -> uri = context.contentResolver.insert(Sms.CONTENT_URI, values)?.apply {
realm.executeTransaction { managedMessage?.takeIf { it.isValid }?.contentId = id } lastPathSegment?.toLong()?.let { id ->
realm.executeTransaction {
managedMessage?.takeIf { it.isValid }?.contentId = id
}
}
}
} }
realm.close()
// On some devices, we can't obtain a threadId until after the first message is sent in a // 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 // conversation. In this case, update the message's threadId after it gets added
// to the native ContentProvider // to the native ContentProvider
if (threadId == 0L) { if (threadId == 0L)
uri?.let(syncRepository::syncMessage) uri?.let(syncRepository::syncMessage)
}
return message return message
} }
override fun insertReceivedSms(subId: Int, address: String, body: String, sentTime: Long): Message { override fun insertReceivedSms(
subId: Int,
address: String,
body: String,
sentTime: Long
): Message {
// Insert the message to Realm // Insert the message to Realm
val message = Message().apply { val message = Message().apply {
this.address = address this.address = address
@@ -607,9 +741,6 @@ open class MessageRepositoryImpl @Inject constructor(
type = "sms" type = "sms"
read = activeConversationManager.getActiveConversation() == threadId read = activeConversationManager.getActiveConversation() == threadId
} }
val realm = Realm.getDefaultInstance()
var managedMessage: Message? = null
realm.executeTransaction { managedMessage = realm.copyToRealmOrUpdate(message) }
// Insert the message to the native content provider // Insert the message to the native content provider
val values = contentValuesOf( val values = contentValuesOf(
@@ -618,16 +749,19 @@ open class MessageRepositoryImpl @Inject constructor(
Sms.DATE_SENT to sentTime Sms.DATE_SENT to sentTime
) )
if (prefs.canUseSubId.get()) { if (prefs.canUseSubId.get())
values.put(Sms.SUBSCRIPTION_ID, message.subId) values.put(Sms.SUBSCRIPTION_ID, message.subId)
}
context.contentResolver.insert(Sms.Inbox.CONTENT_URI, values)?.lastPathSegment?.toLong()?.let { id -> Realm.getDefaultInstance().use { realm ->
// Update the contentId after the message has been inserted to the content provider var managedMessage: Message? = null
realm.executeTransaction { managedMessage = realm.copyToRealmOrUpdate(message) }
context.contentResolver.insert(Sms.Inbox.CONTENT_URI, values)
?.lastPathSegment?.toLong()?.let { id ->
// Update contentId after the message has been inserted to the content provider
realm.executeTransaction { managedMessage?.contentId = id } realm.executeTransaction { managedMessage?.contentId = id }
} }
}
realm.close()
return message return message
} }
@@ -635,12 +769,14 @@ open class MessageRepositoryImpl @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
*/ */
override fun markSending(id: Long) { override fun markSending(id: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val message = realm.where(Message::class.java).equalTo("id", id).findFirst() realm.where(Message::class.java)
message?.let { .equalTo("id", id)
.findFirst()
?.let { message ->
// Update the message in realm // Update the message in realm
realm.executeTransaction { realm.executeTransaction {
message.boxId = when (message.isSms()) { message.boxId = when (message.isSms()) {
@@ -650,40 +786,49 @@ open class MessageRepositoryImpl @Inject constructor(
} }
// Update the message in the native ContentProvider // Update the message in the native ContentProvider
val values = when (message.isSms()) { context.contentResolver.update(
message.getUri(),
when (message.isSms()) {
true -> contentValuesOf(Sms.TYPE to Sms.MESSAGE_TYPE_OUTBOX) true -> contentValuesOf(Sms.TYPE to Sms.MESSAGE_TYPE_OUTBOX)
false -> contentValuesOf(Mms.MESSAGE_BOX to Mms.MESSAGE_BOX_OUTBOX) false -> contentValuesOf(Mms.MESSAGE_BOX to Mms.MESSAGE_BOX_OUTBOX)
},
null,
null
)
} }
context.contentResolver.update(message.getUri(), values, null, null) Unit
}
}
} }
override fun markSent(id: Long) { override fun markSent(id: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val message = realm.where(Message::class.java).equalTo("id", id).findFirst() realm.where(Message::class.java)
message?.let { .equalTo("id", id)
.findFirst()
?.let { message ->
// Update the message in realm // Update the message in realm
realm.executeTransaction { realm.executeTransaction { message.boxId = Sms.MESSAGE_TYPE_SENT }
message.boxId = Sms.MESSAGE_TYPE_SENT
}
// Update the message in the native ContentProvider // Update the message in the native ContentProvider
val values = ContentValues() context.contentResolver.update(
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_SENT) message.getUri(),
context.contentResolver.update(message.getUri(), values, null, null) contentValuesOf(Sms.TYPE to Sms.MESSAGE_TYPE_SENT),
} null,
null
)
} }
Unit
} }
override fun markFailed(id: Long, resultCode: Int) { override fun markFailed(id: Long, resultCode: Int) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val message = realm.where(Message::class.java).equalTo("id", id).findFirst() realm.where(Message::class.java)
message?.let { .equalTo("id", id)
.findFirst()
?.let { message ->
// Update the message in realm // Update the message in realm
realm.executeTransaction { realm.executeTransaction {
message.boxId = Sms.MESSAGE_TYPE_FAILED message.boxId = Sms.MESSAGE_TYPE_FAILED
@@ -691,20 +836,27 @@ open class MessageRepositoryImpl @Inject constructor(
} }
// Update the message in the native ContentProvider // Update the message in the native ContentProvider
val values = ContentValues() context.contentResolver.update(
values.put(Sms.TYPE, Sms.MESSAGE_TYPE_FAILED) message.getUri(),
values.put(Sms.ERROR_CODE, resultCode) contentValuesOf(
context.contentResolver.update(message.getUri(), values, null, null) Sms.TYPE to Sms.MESSAGE_TYPE_FAILED,
} Sms.ERROR_CODE to resultCode,
),
null,
null
)
} }
Unit
} }
override fun markDelivered(id: Long) { override fun markDelivered(id: Long) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val message = realm.where(Message::class.java).equalTo("id", id).findFirst() realm.where(Message::class.java)
message?.let { .equalTo("id", id)
.findFirst()
?.let { message ->
// Update the message in realm // Update the message in realm
realm.executeTransaction { realm.executeTransaction {
message.deliveryStatus = Sms.STATUS_COMPLETE message.deliveryStatus = Sms.STATUS_COMPLETE
@@ -713,21 +865,28 @@ open class MessageRepositoryImpl @Inject constructor(
} }
// Update the message in the native ContentProvider // Update the message in the native ContentProvider
val values = ContentValues() context.contentResolver.update(
values.put(Sms.STATUS, Sms.STATUS_COMPLETE) message.getUri(),
values.put(Sms.DATE_SENT, System.currentTimeMillis()) contentValuesOf(
values.put(Sms.READ, true) Sms.STATUS to Sms.STATUS_COMPLETE,
context.contentResolver.update(message.getUri(), values, null, null) Sms.DATE_SENT to System.currentTimeMillis(),
} Sms.READ to true,
),
null,
null
)
} }
Unit
} }
override fun markDeliveryFailed(id: Long, resultCode: Int) { override fun markDeliveryFailed(id: Long, resultCode: Int) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val message = realm.where(Message::class.java).equalTo("id", id).findFirst() realm.where(Message::class.java)
message?.let { .equalTo("id", id)
.findFirst()
?.let { message ->
// Update the message in realm // Update the message in realm
realm.executeTransaction { realm.executeTransaction {
message.deliveryStatus = Sms.STATUS_FAILED message.deliveryStatus = Sms.STATUS_FAILED
@@ -737,53 +896,65 @@ open class MessageRepositoryImpl @Inject constructor(
} }
// Update the message in the native ContentProvider // Update the message in the native ContentProvider
val values = ContentValues() context.contentResolver.update(
values.put(Sms.STATUS, Sms.STATUS_FAILED) message.getUri(),
values.put(Sms.DATE_SENT, System.currentTimeMillis()) contentValuesOf(
values.put(Sms.READ, true) Sms.STATUS to Sms.STATUS_FAILED,
values.put(Sms.ERROR_CODE, resultCode) Sms.DATE_SENT to System.currentTimeMillis(),
context.contentResolver.update(message.getUri(), values, null, null) Sms.READ to true,
} Sms.ERROR_CODE to resultCode,
),
null,
null
)
} }
Unit
} }
override fun deleteMessages(vararg messageIds: Long) { override fun deleteMessages(messageIds: Collection<Long>) =
Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.refresh() realm.refresh()
val messages = realm.where(Message::class.java) val messages = realm.where(Message::class.java)
.anyOf("id", messageIds) .anyOf("id", messageIds.toLongArray())
.findAll() .findAll()
val uris = messages.map { it.getUri() } val uris = messages.map { it.getUri() }
realm.executeTransaction { messages.deleteAllFromRealm() } realm.executeTransaction { messages.deleteAllFromRealm() }
uris.forEach { uri -> context.contentResolver.delete(uri, null, null) } uris.forEach {
uri -> context.contentResolver.delete(uri, null, null)
} }
} }
override fun getOldMessageCounts(maxAgeDays: Int): Map<Long, Int> { override fun getOldMessageCounts(maxAgeDays: Int) =
return Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
realm.where(Message::class.java) realm.where(Message::class.java)
.lessThan("date", now() - TimeUnit.DAYS.toMillis(maxAgeDays.toLong())) .lessThan(
"date",
now() - TimeUnit.DAYS.toMillis(maxAgeDays.toLong())
)
.findAll() .findAll()
.groupingBy { message -> message.threadId } .groupingBy { message -> message.threadId }
.eachCount() .eachCount()
} }
}
override fun deleteOldMessages(maxAgeDays: Int) { override fun deleteOldMessages(maxAgeDays: Int) =
return Realm.getDefaultInstance().use { realm -> Realm.getDefaultInstance().use { realm ->
val messages = realm.where(Message::class.java) val messages = realm.where(Message::class.java)
.lessThan("date", now() - TimeUnit.DAYS.toMillis(maxAgeDays.toLong())) .lessThan(
"date",
now() - TimeUnit.DAYS.toMillis(maxAgeDays.toLong())
)
.findAll() .findAll()
val uris = messages.map { it.getUri() } val uris = messages.map { it.getUri() }
realm.executeTransaction { messages.deleteAllFromRealm() } realm.executeTransaction { messages.deleteAllFromRealm() }
uris.forEach { uri -> context.contentResolver.delete(uri, null, null) } uris.forEach {
uri -> context.contentResolver.delete(uri, null, null)
} }
} }
} }
@@ -33,7 +33,7 @@ class CancelDelayedMessage @Inject constructor(
override fun buildObservable(params: Params): Flowable<*> { override fun buildObservable(params: Params): Flowable<*> {
return Flowable.just(Unit) return Flowable.just(Unit)
.doOnNext { messageRepo.cancelDelayedSms(params.messageId) } .doOnNext { messageRepo.cancelDelayedSms(params.messageId) }
.doOnNext { messageRepo.deleteMessages(params.messageId) } .doOnNext { messageRepo.deleteMessages(listOf(params.messageId)) }
.doOnNext { conversationRepo.updateConversations(params.threadId) } // Update the conversation .doOnNext { conversationRepo.updateConversations(params.threadId) } // Update the conversation
} }
@@ -34,8 +34,8 @@ class DeleteMessages @Inject constructor(
data class Params(val messageIds: List<Long>, val threadId: Long) data class Params(val messageIds: List<Long>, val threadId: Long)
override fun buildObservable(params: Params): Flowable<*> { override fun buildObservable(params: Params): Flowable<*> {
return Flowable.just(params.messageIds.toLongArray()) return Flowable.just(params.messageIds)
.doOnNext { messageIds -> messageRepo.deleteMessages(*messageIds) } // Delete the messages .doOnNext { messageIds -> messageRepo.deleteMessages(messageIds) } // Delete the messages
.doOnNext { conversationRepo.updateConversations(params.threadId) } // Update the conversation .doOnNext { conversationRepo.updateConversations(params.threadId) } // Update the conversation
.doOnNext { notificationManager.update(params.threadId) } .doOnNext { notificationManager.update(params.threadId) }
.flatMap { updateBadge.buildObservable(Unit) } // Update the badge .flatMap { updateBadge.buildObservable(Unit) } // Update the badge
@@ -30,8 +30,8 @@ class MarkRead @Inject constructor(
) : Interactor<List<Long>>() { ) : Interactor<List<Long>>() {
override fun buildObservable(params: List<Long>): Flowable<*> { override fun buildObservable(params: List<Long>): Flowable<*> {
return Flowable.just(params.toLongArray()) return Flowable.just(params)
.doOnNext { threadIds -> messageRepo.markRead(*threadIds) } .doOnNext { threadIds -> messageRepo.markRead(threadIds) }
.doOnNext { threadIds -> threadIds.forEach(notificationManager::update) } .doOnNext { threadIds -> threadIds.forEach(notificationManager::update) }
.flatMap { updateBadge.buildObservable(Unit) } // Update the badge .flatMap { updateBadge.buildObservable(Unit) } // Update the badge
} }
@@ -28,8 +28,8 @@ class MarkUnread @Inject constructor(
) : Interactor<List<Long>>() { ) : Interactor<List<Long>>() {
override fun buildObservable(params: List<Long>): Flowable<*> { override fun buildObservable(params: List<Long>): Flowable<*> {
return Flowable.just(params.toLongArray()) return Flowable.just(params)
.doOnNext { threadId -> messageRepo.markUnread(*threadId) } .doOnNext { threadIds -> messageRepo.markUnread(threadIds) }
.flatMap { updateBadge.buildObservable(Unit) } // Update the badge .flatMap { updateBadge.buildObservable(Unit) } // Update the badge
} }
@@ -49,7 +49,7 @@ class ReceiveMms @Inject constructor(
// TODO: Ideally this is done when we're saving the MMS to ContentResolver // TODO: Ideally this is done when we're saving the MMS to ContentResolver
// This change can be made once we move the MMS storing code to the Data module // This change can be made once we move the MMS storing code to the Data module
if (activeConversationManager.getActiveConversation() == message.threadId) { if (activeConversationManager.getActiveConversation() == message.threadId) {
messageRepo.markRead(message.threadId) messageRepo.markRead(listOf(message.threadId))
} }
} }
.mapNotNull { message -> .mapNotNull { message ->
@@ -62,13 +62,13 @@ class ReceiveMms @Inject constructor(
Timber.v("block=$action, drop=$shouldDrop") Timber.v("block=$action, drop=$shouldDrop")
if (action is BlockingClient.Action.Block && shouldDrop) { if (action is BlockingClient.Action.Block && shouldDrop) {
messageRepo.deleteMessages(message.id) messageRepo.deleteMessages(listOf(message.id))
return@mapNotNull null return@mapNotNull null
} }
when (action) { when (action) {
is BlockingClient.Action.Block -> { is BlockingClient.Action.Block -> {
messageRepo.markRead(message.threadId) messageRepo.markRead(listOf(message.threadId))
conversationRepo.markBlocked(listOf(message.threadId), prefs.blockingManager.get(), action.reason) conversationRepo.markBlocked(listOf(message.threadId), prefs.blockingManager.get(), action.reason)
} }
is BlockingClient.Action.Unblock -> conversationRepo.markUnblocked(message.threadId) is BlockingClient.Action.Unblock -> conversationRepo.markUnblocked(message.threadId)
@@ -49,13 +49,13 @@ class ReceiveSms @Inject constructor(
((action is BlockingClient.Action.Block) && prefs.drop.get()) -> { ((action is BlockingClient.Action.Block) && prefs.drop.get()) -> {
// blocked and 'drop blocked.' remove from db and don't continue // blocked and 'drop blocked.' remove from db and don't continue
Timber.v("address is blocked and drop blocked is on. dropped") Timber.v("address is blocked and drop blocked is on. dropped")
messageRepo.deleteMessages(it.id) messageRepo.deleteMessages(listOf(it.id))
return@mapNotNull null return@mapNotNull null
} }
action is BlockingClient.Action.Block -> { action is BlockingClient.Action.Block -> {
// blocked // blocked
Timber.v("address is blocked") Timber.v("address is blocked")
messageRepo.markRead(it.threadId) messageRepo.markRead(listOf(it.threadId))
conversationRepo.markBlocked( conversationRepo.markBlocked(
listOf(it.threadId), listOf(it.threadId),
prefs.blockingManager.get(), prefs.blockingManager.get(),
@@ -57,20 +57,20 @@ interface MessageRepository {
*/ */
fun getUnreadMessages(threadId: Long): RealmResults<Message> fun getUnreadMessages(threadId: Long): RealmResults<Message>
fun markAllSeen() fun markAllSeen(): Int
fun markSeen(threadId: Long) fun markSeen(threadId: Long): Int
fun markRead(vararg threadIds: Long) fun markRead(threadIds: Collection<Long>): Int
fun markUnread(vararg threadIds: Long) fun markUnread(threadIds: Collection<Long>): Int
fun sendMessage( fun sendMessage(
subId: Int, subId: Int,
threadId: Long, threadId: Long,
addresses: List<String>, addresses: Collection<String>,
body: String, body: String,
attachments: List<Attachment>, attachments: Collection<Attachment>,
delay: Int = 0 delay: Int = 0
) )
@@ -103,7 +103,7 @@ interface MessageRepository {
fun markDeliveryFailed(id: Long, resultCode: Int) fun markDeliveryFailed(id: Long, resultCode: Int)
fun deleteMessages(vararg messageIds: Long) fun deleteMessages(messageIds: Collection<Long>)
/** /**
* Returns the number of messages older than [maxAgeDays] per conversation * Returns the number of messages older than [maxAgeDays] per conversation