Simplify API for sending messages (81d77eb1) · Commits · e / os / Message

data/src/main/java/com/moez/QKSMS/repository/MessageRepositoryImpl.kt

+46 −53

Original line number	Diff line number	Diff line
		@@ -206,17 +206,11 @@ class MessageRepositoryImpl @Inject constructor(
		}
		}

		override fun sendSmsAndPersist(subId: Int, threadId: Long, address: String, body: String) {
		if (prefs.sendDelay.get() != Preferences.SEND_DELAY_NONE) {
		val delay = when (prefs.sendDelay.get()) {
		Preferences.SEND_DELAY_SHORT -> 3000
		Preferences.SEND_DELAY_MEDIUM -> 5000
		Preferences.SEND_DELAY_LONG -> 10000
		else -> 0
		}

		override fun sendMessage(subId: Int, threadId: Long, addresses: List<String>, body: String, attachments: List<Attachment>, delay: Int) {
		if (addresses.size == 1 && attachments.isEmpty()) { // SMS
		if (delay > 0) { // With delay
		val sendTime = System.currentTimeMillis() + delay
		val message = insertSentSms(subId, threadId, address, body, sendTime)
		val message = insertSentSms(subId, threadId, addresses.first(), body, sendTime)

		val intent = getIntentForDelayedSms(message.id)

		@@ -226,39 +220,11 @@ class MessageRepositoryImpl @Inject constructor(
		} else {
		alarmManager.setExact(AlarmManager.RTC_WAKEUP, sendTime, intent)
		}
		} else {
		val message = insertSentSms(subId, threadId, address, body, System.currentTimeMillis())
		} else { // No delay
		val message = insertSentSms(subId, threadId, addresses.first(), body, System.currentTimeMillis())
		sendSms(message)
		}
		}

		override fun sendSms(message: Message) {
		val smsManager = message.subId.takeIf { it != -1 }
		?.let(SmsManager::getSmsManagerForSubscriptionId)
		?: SmsManager.getDefault()

		val parts = smsManager.divideMessage(if (prefs.unicode.get()) StripAccents.stripAccents(message.body) else message.body)
		?: arrayListOf()

		val sentIntents = parts.map {
		val action = "com.moez.QKSMS.SMS_SENT"
		val intent = Intent(action).putExtra("id", message.id)
		BroadcastUtils.addClassName(context, intent, action)
		PendingIntent.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT)
		}

		val deliveredIntents = parts.map {
		val action = "com.moez.QKSMS.SMS_DELIVERED"
		val intent = Intent(action).putExtra("id", message.id)
		BroadcastUtils.addClassName(context, intent, action)
		val pendingIntent = PendingIntent.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT)
		if (prefs.delivery.get()) pendingIntent else null
		}

		smsManager.sendMultipartTextMessage(message.address, null, parts, ArrayList(sentIntents), ArrayList(deliveredIntents))
		}

		override fun sendMms(subId: Int, threadId: Long, addresses: List<String>, body: String, attachments: List<Attachment>) {
		} else { // MMS
		val settings = Settings().apply { subscriptionId = subId }
		val message = com.klinker.android.send_message.Message(body, addresses.toTypedArray())

		@@ -288,6 +254,33 @@ class MessageRepositoryImpl @Inject constructor(
		val transaction = Transaction(context, settings)
		transaction.sendNewMessage(message, threadId)
		}
		}

		override fun sendSms(message: Message) {
		val smsManager = message.subId.takeIf { it != -1 }
		?.let(SmsManager::getSmsManagerForSubscriptionId)
		?: SmsManager.getDefault()

		val parts = smsManager.divideMessage(if (prefs.unicode.get()) StripAccents.stripAccents(message.body) else message.body)
		?: arrayListOf()

		val sentIntents = parts.map {
		val action = "com.moez.QKSMS.SMS_SENT"
		val intent = Intent(action).putExtra("id", message.id)
		BroadcastUtils.addClassName(context, intent, action)
		PendingIntent.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT)
		}

		val deliveredIntents = parts.map {
		val action = "com.moez.QKSMS.SMS_DELIVERED"
		val intent = Intent(action).putExtra("id", message.id)
		BroadcastUtils.addClassName(context, intent, action)
		val pendingIntent = PendingIntent.getBroadcast(context, message.id.toInt(), intent, PendingIntent.FLAG_UPDATE_CURRENT)
		if (prefs.delivery.get()) pendingIntent else null
		}

		smsManager.sendMultipartTextMessage(message.address, null, parts, ArrayList(sentIntents), ArrayList(deliveredIntents))
		}

		private fun shrink(src: Bitmap, maxBytes: Int): ByteArray {
		var step = 0.0

domain/src/main/java/com/moez/QKSMS/interactor/SendMessage.kt

+14 −16

Original line number	Diff line number	Diff line
		@@ -29,22 +29,20 @@ class SendMessage @Inject constructor(
		private val messageRepo: MessageRepository
		) : Interactor<SendMessage.Params>() {

		data class Params(val subId: Int, val threadId: Long, val addresses: List<String>, val body: String, val attachments: List<Attachment> = listOf())
		data class Params(
		val subId: Int,
		val threadId: Long,
		val addresses: List<String>,
		val body: String,
		val attachments: List<Attachment> = listOf(),
		val delay: Int = 0)

		override fun buildObservable(params: Params): Flowable<Unit> {
		return Flowable.just(Unit)
		override fun buildObservable(params: Params): Flowable<Unit> = Flowable.just(Unit)
		.filter { params.addresses.isNotEmpty() }
		.doOnNext {
		if (params.addresses.size == 1 && params.attachments.isEmpty()) {
		messageRepo.sendSmsAndPersist(params.subId, params.threadId, params.addresses.first(), params.body)
		} else {
		messageRepo.sendMms(params.subId, params.threadId, params.addresses, params.body, params.attachments)
		}
		}
		.doOnNext { messageRepo.sendMessage(params.subId, params.threadId, params.addresses, params.body, params.attachments, params.delay) }
		// If this was the first message sent in the conversation, the conversation might not exist yet
		.doOnNext { conversationRepo.getOrCreateConversation(params.threadId) }
		.doOnNext { conversationRepo.updateConversations(params.threadId) }
		.doOnNext { conversationRepo.markUnarchived(params.threadId) }
		}

		}
		No newline at end of file

domain/src/main/java/com/moez/QKSMS/interactor/SendScheduledMessage.kt

+16 −20

Original line number	Diff line number	Diff line
		@@ -5,39 +5,35 @@ import android.net.Uri
		import com.moez.QKSMS.compat.TelephonyCompat
		import com.moez.QKSMS.extensions.mapNotNull
		import com.moez.QKSMS.model.Attachment
		import com.moez.QKSMS.repository.ConversationRepository
		import com.moez.QKSMS.repository.MessageRepository
		import com.moez.QKSMS.repository.ScheduledMessageRepository
		import io.reactivex.Flowable
		import io.reactivex.rxkotlin.toFlowable
		import io.realm.RealmList
		import javax.inject.Inject

		class SendScheduledMessage @Inject constructor(
		private val context: Context,
		private val conversationRepo: ConversationRepository,
		private val messageRepo: MessageRepository,
		private val scheduledMessageRepo: ScheduledMessageRepository
		private val scheduledMessageRepo: ScheduledMessageRepository,
		private val sendMessage: SendMessage
		) : Interactor<Long>() {

		override fun buildObservable(params: Long): Flowable<*> {
		return Flowable.just(params)
		.mapNotNull(scheduledMessageRepo::getScheduledMessage)
		.map { message ->
		TelephonyCompat.getOrCreateThreadId(context, message.recipients).also { threadId ->
		if ((message.recipients.size == 1 \|\| !message.sendAsGroup) && message.attachments.isEmpty()) {
		message.recipients.forEach { address ->
		messageRepo.sendSmsAndPersist(message.subId, threadId, address, message.body)
		}
		.flatMap { message ->
		if (message.sendAsGroup) {
		listOf(message)
		} else {
		val attachments = message.attachments.mapNotNull(Uri::parse).map { Attachment(it) }
		messageRepo.sendMms(message.subId, threadId, message.recipients, message.body, attachments)
		}
		message.recipients.map { recipient -> message.copy(recipients = RealmList(recipient)) }
		}.toFlowable()
		}
		.map { message ->
		val threadId = TelephonyCompat.getOrCreateThreadId(context, message.recipients)
		val attachments = message.attachments.mapNotNull(Uri::parse).map { Attachment(it) }
		SendMessage.Params(message.subId, threadId, message.recipients, message.body, attachments)
		}
		.doOnNext { scheduledMessageRepo.deleteScheduledMessage(params) }
		// If this was the first message sent in the conversation, the conversation might not exist yet
		.doOnNext { conversationRepo.getOrCreateConversation(it) }
		.doOnNext { conversationRepo.updateConversations(it) }
		.doOnNext { conversationRepo.markUnarchived(it) }
		.flatMap(sendMessage::buildObservable)
		.doFinally { scheduledMessageRepo.deleteScheduledMessage(params) }
		}

		}
		No newline at end of file

domain/src/main/java/com/moez/QKSMS/model/ScheduledMessage.kt

+14 −1

Original line number	Diff line number	Diff line
		@@ -12,4 +12,17 @@ open class ScheduledMessage(
		var sendAsGroup: Boolean = true,
		var body: String = "",
		var attachments: RealmList<String> = RealmList()
		) : RealmObject()
		No newline at end of file
		) : RealmObject() {

		fun copy(id: Long = this.id,
		date: Long = this.date,
		subId: Int = this.subId,
		recipients: RealmList<String> = this.recipients,
		sendAsGroup: Boolean = this.sendAsGroup,
		body: String = this.body,
		attachments: RealmList<String> = this.attachments): ScheduledMessage {

		return ScheduledMessage(id, date, subId, recipients, sendAsGroup, body, attachments)
		}

		}
		No newline at end of file

domain/src/main/java/com/moez/QKSMS/repository/MessageRepository.kt

+1 −6

Original line number	Diff line number	Diff line
		@@ -57,18 +57,13 @@ interface MessageRepository {

		fun markUnread(vararg threadIds: Long)

		/**
		* Persists the SMS and attempts to send it
		*/
		fun sendSmsAndPersist(subId: Int, threadId: Long, address: String, body: String)
		fun sendMessage(subId: Int, threadId: Long, addresses: List<String>, body: String, attachments: List<Attachment>, delay: Int = 0)

		/**
		* Attempts to send the SMS message. This can be called if the message has already been persisted
		*/
		fun sendSms(message: Message)

		fun sendMms(subId: Int, threadId: Long, addresses: List<String>, body: String, attachments: List<Attachment>)

		/**
		* Attempts to cancel sending the message with the given id
		*/