fenix
/
Simple-SMS-Messenger
mirror of https://github.com/SimpleMobileTools/Simple-SMS-Messenger.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Cleanup code and remove logs

This commit is contained in:
darthpaul 2021-09-18 22:07:13 +01:00
parent 24d9988ec1
commit 04cac740ee
7 changed files with 21 additions and 222 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
app/src/main/kotlin/com/simplemobiletools/smsmessenger/activities/MainActivity.kt
View File

@ -11,7 +11,6 @@ import android.graphics.drawable.LayerDrawable
import android.net.Uri
import android.os.Bundle
import android.provider.Telephony
import android.util.Log
import android.view.Menu
import android.view.MenuItem
import com.simplemobiletools.commons.dialogs.FilePickerDialog
@ -362,13 +361,10 @@ class MainActivity : SimpleActivity() {
}
}
private val TAG = "MainActivity"
private fun exportMessagesTo(outputStream: OutputStream?) {
ensureBackgroundThread {
toast(R.string.exporting)
smsExporter.exportMessages(outputStream, { total, current ->
Log.d(TAG, "PERCENTAGE: ${current.toDouble() * 100 / total.toDouble()}%")
}) {
smsExporter.exportMessages(outputStream) {
toast(
when (it) {
MessagesExporter.ExportResult.EXPORT_OK -> R.string.exporting_successful

13
app/src/main/kotlin/com/simplemobiletools/smsmessenger/dialogs/ImportMessagesDialog.kt
View File

@ -1,6 +1,5 @@
package com.simplemobiletools.smsmessenger.dialogs
import android.util.Log
import android.view.ViewGroup
import androidx.appcompat.app.AlertDialog
import com.simplemobiletools.commons.extensions.setupDialogStuff
@ -10,7 +9,9 @@ import com.simplemobiletools.smsmessenger.R
import com.simplemobiletools.smsmessenger.activities.SimpleActivity
import com.simplemobiletools.smsmessenger.extensions.config
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.*
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.IMPORT_FAIL
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.IMPORT_OK
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.IMPORT_PARTIAL
import kotlinx.android.synthetic.main.dialog_import_messages.view.import_mms_checkbox
import kotlinx.android.synthetic.main.dialog_import_messages.view.import_sms_checkbox
@ -20,7 +21,6 @@ class ImportMessagesDialog(
private val callback: (refresh: Boolean) -> Unit,
) {
private val TAG = "ImportMessagesDialog"
private val config = activity.config
init {
@ -39,13 +39,10 @@ class ImportMessagesDialog(
config.importSms = view.import_sms_checkbox.isChecked
config.importMms = view.import_mms_checkbox.isChecked
ensureBackgroundThread {
MessagesImporter(activity).importMessages(path, onProgress = { total: Int, current: Int ->
Log.d(TAG, "PERCENTAGE: ${current.toDouble() * 100 / total.toDouble()}%")
}) {
MessagesImporter(activity).importMessages(path) {
handleParseResult(it)
dismiss()
}
dismiss()
callback.invoke(true)
}
}
}

43
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/JsonObjectWriter.kt
View File

@ -1,43 +0,0 @@
package com.simplemobiletools.smsmessenger.helpers
import com.google.gson.JsonArray
import com.google.gson.JsonNull
import com.google.gson.JsonObject
import com.google.gson.JsonPrimitive
import com.google.gson.stream.JsonWriter
class JsonObjectWriter(private val writer: JsonWriter) {
fun write(obj: JsonObject) {
writer.beginObject()
for (key in obj.keySet()) {
writer.name(key)
val keyObj = obj.get(key)
write(keyObj)
}
writer.endObject()
}
private fun write(arr: JsonArray) {
writer.beginArray()
for (i in 0 until arr.size()) {
write(arr.get(i))
}
writer.endArray()
}
private fun write(obj: Any) {
when (obj) {
is JsonNull -> writer.nullValue()
is JsonPrimitive -> {
when{
obj.isString -> writer.value(obj.asString)
obj.isBoolean -> writer.value(obj.asBoolean)
obj.isNumber -> writer.value(obj.asNumber)
}
}
is JsonArray -> write(obj)
is JsonObject -> write(obj)
}
}
}

15
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/MessagesExporter.kt
View File

@ -23,21 +23,6 @@ class MessagesExporter(private val context: Context) {
callback.invoke(ExportResult.EXPORT_FAIL)
return@ensureBackgroundThread
}
/*
* We should have json in this format
* [
* {
* "sms": [{ smses }],
* "mms": [{ mmses }]
* },
* {
* "sms": [{ smses }],
* "mms": [{ mmses }]
* }
* ]
*
* */
val writer = JsonWriter(outputStream.bufferedWriter())
writer.use {
try {

28
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/MessagesImporter.kt
View File

@ -15,10 +15,6 @@ import com.simplemobiletools.smsmessenger.models.ExportedMessage
import java.io.File
class MessagesImporter(private val context: Context) {
companion object {
private const val TAG = "MessagesImporter"
}
enum class ImportResult {
IMPORT_FAIL, IMPORT_OK, IMPORT_PARTIAL
}
@ -41,13 +37,11 @@ class MessagesImporter(private val context: Context) {
inputStream.bufferedReader().use { reader ->
val json = reader.readText()
Log.d(TAG, "importMessages: json== $json")
val type = object : TypeToken<List<ExportedMessage>>() {}.type
val messages = gson.fromJson<List<ExportedMessage>>(json, type)
val totalMessages = messages.flatMap { it.sms }.size + messages.flatMap { it.mms }.size
onProgress.invoke(totalMessages, messagesImported)
for (message in messages) {
// add sms
if (config.importSms) {
message.sms.forEach { backup ->
messageWriter.writeSmsMessage(backup)
@ -55,7 +49,6 @@ class MessagesImporter(private val context: Context) {
onProgress.invoke(totalMessages, messagesImported)
}
}
// add mms
if (config.importMms) {
message.mms.forEach { backup ->
messageWriter.writeMmsMessage(backup)
@ -63,27 +56,6 @@ class MessagesImporter(private val context: Context) {
onProgress.invoke(totalMessages, messagesImported)
}
}
context.queryCursor(Threads.CONTENT_URI) { cursor ->
val json = cursor.rowsToJson()
Log.w(TAG, "converations = $json")
}
context.queryCursor(Sms.CONTENT_URI) { cursor ->
val json = cursor.rowsToJson()
Log.w(TAG, "smses = $json")
}
context.queryCursor(Mms.CONTENT_URI) { cursor ->
val json = cursor.rowsToJson()
Log.w(TAG, "mmses = $json")
}
context.queryCursor(Uri.parse("content://mms/part")) { cursor ->
val json = cursor.rowsToJson()
Log.w(TAG, "parts = $json")
}
refreshMessages()
}
}

45
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/MessagesReader.kt
View File

@ -3,12 +3,11 @@ package com.simplemobiletools.smsmessenger.helpers
import android.annotation.SuppressLint
import android.content.Context
import android.net.Uri
import android.provider.Telephony.*
import android.provider.Telephony.Mms
import android.provider.Telephony.Sms
import android.util.Base64
import android.util.Log
import com.simplemobiletools.commons.extensions.*
import com.simplemobiletools.commons.helpers.isQPlus
import com.simplemobiletools.smsmessenger.extensions.rowsToJson
import com.simplemobiletools.smsmessenger.models.MmsAddress
import com.simplemobiletools.smsmessenger.models.MmsBackup
import com.simplemobiletools.smsmessenger.models.MmsPart
@ -17,10 +16,6 @@ import java.io.IOException
import java.io.InputStream
class MessagesReader(private val context: Context) {
companion object {
private const val TAG = "MessagesReader"
}
fun forEachSms(threadId: Long, block: (SmsBackup) -> Unit) {
val projection = arrayOf(
Sms.SUBSCRIPTION_ID,
@ -136,11 +131,7 @@ class MessagesReader(private val context: Context) {
@SuppressLint("NewApi")
private fun getParts(mmsId: Long): List<MmsPart> {
val parts = mutableListOf<MmsPart>()
val uri = if (isQPlus()) {
Mms.Part.CONTENT_URI
} else {
Uri.parse("content://mms/part")
}
val uri = if (isQPlus()) Mms.Part.CONTENT_URI else Uri.parse("content://mms/part")
val projection = arrayOf(
Mms.Part._ID,
Mms.Part.CONTENT_DISPOSITION,
@ -178,12 +169,7 @@ class MessagesReader(private val context: Context) {
}
else -> {
usePart(partId) { stream ->
val arr = stream.readBytes()
Log.d(TAG, "getParts: $arr")
Log.d(TAG, "getParts: size = ${arr.size}")
Log.d(TAG, "getParts: US_ASCII-> ${arr.toString(Charsets.US_ASCII)}")
Log.d(TAG, "getParts: UTF_8-> ${arr.toString(Charsets.UTF_8)}")
Base64.encodeToString(arr, Base64.DEFAULT)
Base64.encodeToString(stream.readBytes(), Base64.DEFAULT)
}
}
}
@ -194,24 +180,13 @@ class MessagesReader(private val context: Context) {
@SuppressLint("NewApi")
private fun usePart(partId: Long, block: (InputStream) -> String): String {
val partUri = if (isQPlus()) {
Mms.Part.CONTENT_URI.buildUpon().appendPath(partId.toString()).build()
} else {
Uri.parse("content://mms/part/$partId")
}
val partUri = if (isQPlus()) Mms.Part.CONTENT_URI.buildUpon().appendPath(partId.toString()).build() else Uri.parse("content://mms/part/$partId")
try {
val stream = context.contentResolver.openInputStream(partUri)
if (stream == null) {
val msg = "failed opening stream for mms part $partUri"
Log.e(TAG, msg)
return ""
}
val stream = context.contentResolver.openInputStream(partUri) ?: return ""
stream.use {
return block(stream)
}
} catch (e: IOException) {
val msg = "failed to read MMS part on $partUri"
Log.e(TAG, msg, e)
return ""
}
}
@ -219,22 +194,16 @@ class MessagesReader(private val context: Context) {
@SuppressLint("NewApi")
private fun getMMSAddresses(messageId: Long): List<MmsAddress> {
val addresses = mutableListOf<MmsAddress>()
val uri = if (isQPlus()) {
Mms.Addr.getAddrUriForMessage(messageId.toString())
} else {
Uri.parse("content://mms/$messageId/addr")
}
val uri = if (isQPlus()) Mms.Addr.getAddrUriForMessage(messageId.toString()) else Uri.parse("content://mms/$messageId/addr")
val projection = arrayOf(Mms.Addr.ADDRESS, Mms.Addr.TYPE, Mms.Addr.CHARSET)
val selection = "${Mms.Addr.MSG_ID}= ?"
val selectionArgs = arrayOf(messageId.toString())
context.queryCursor(uri, projection, selection, selectionArgs) { cursor ->
val address = cursor.getStringValue(Mms.Addr.ADDRESS)
val type = cursor.getIntValue(Mms.Addr.TYPE)
val charset = cursor.getIntValue(Mms.Addr.CHARSET)
addresses.add(MmsAddress(address, type, charset))
}
return addresses
}

93
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/MessagesWriter.kt
View File

@ -1,14 +1,11 @@
package com.simplemobiletools.smsmessenger.helpers
import android.annotation.SuppressLint
import android.content.ContentValues
import android.content.Context
import android.net.Uri
import android.provider.Telephony
import android.provider.Telephony.*
import android.provider.Telephony.Mms
import android.provider.Telephony.Sms
import android.util.Base64
import android.util.Log
import androidx.core.content.contentValuesOf
import com.google.android.mms.pdu_alt.PduHeaders
import com.klinker.android.send_message.Utils
import com.simplemobiletools.commons.extensions.getLongValue
@ -20,43 +17,18 @@ import com.simplemobiletools.smsmessenger.models.MmsPart
import com.simplemobiletools.smsmessenger.models.SmsBackup
class MessagesWriter(private val context: Context) {
companion object {
private const val INVALID_ID = -1L
private const val TAG = "MessagesWriter"
}
private val INVALID_ID = -1L
private val contentResolver = context.contentResolver
fun writeSmsMessage(smsBackup: SmsBackup) {
Log.w(TAG, "writeSmsMessage: smsBackup=$smsBackup")
val contentValues = smsBackup.toContentValues()
val threadId = Utils.getOrCreateThreadId(context, smsBackup.address)
contentValues.put(Sms.THREAD_ID, threadId)
Log.d(TAG, "writeSmsMessage: contentValues=$contentValues")
Log.d(TAG, "writeSmsMessage: type=${smsBackup.type}")
if (!smsExist(smsBackup)) {
Log.d(TAG, "writeSmsMessage: Inserting SMS...")
val uri = Sms.CONTENT_URI
Log.d(TAG, "writeSmsMessage: uri=$uri")
contentResolver.insert(Sms.CONTENT_URI, contentValues)
} else {
Log.w(TAG, "SMS already exists")
}
}
private fun updateThreadDate(
threadId: Long,
date: Long,
) {
Log.d(TAG, "updateThreadDate: threadId=$threadId -- date=$date")
val selection = "${Threads._ID} = ?"
val selectionArgs = arrayOf(threadId.toString())
val threadValues = contentValuesOf(Threads.DATE to date)
Log.d(TAG, "threadValues=$threadValues")
val result = contentResolver.update(Threads.CONTENT_URI.buildUpon().appendPath(threadId.toString()).build(), threadValues, null, null)
Log.d(TAG, "updateThreadDate: id=$result")
}
private fun smsExist(smsBackup: SmsBackup): Boolean {
val uri = Sms.CONTENT_URI
val projection = arrayOf(Sms._ID)
@ -65,9 +37,7 @@ class MessagesWriter(private val context: Context) {
var exists = false
context.queryCursor(uri, projection, selection, selectionArgs) {
exists = it.count > 0
Log.i(TAG, "smsExist After: $exists")
}
Log.i(TAG, "smsExist: $exists")
return exists
}
@ -75,41 +45,25 @@ class MessagesWriter(private val context: Context) {
// 1. write mms msg, get the msg_id, check if mms exists before writing
// 2. write parts - parts depend on the msg id, check if part exist before writing, write data if it is a non-text part
// 3. write the addresses, address depends on msg id too, check if address exist before writing
Log.w(TAG, "writeMmsMessage: backup=$mmsBackup")
val contentValues = mmsBackup.toContentValues()
val threadId = getMmsThreadId(mmsBackup)
if (threadId != INVALID_ID) {
contentValues.put(Mms.THREAD_ID, threadId)
Log.w(TAG, "writeMmsMessage: backup=$mmsBackup")
//write mms
if (!mmsExist(mmsBackup)) {
contentResolver.insert(Mms.CONTENT_URI, contentValues)
} else {
Log.w(TAG, "mms already exists")
}
val messageId = getMmsId(mmsBackup)
if (messageId != INVALID_ID) {
Log.d(TAG, "writing mms addresses")
//write addresses
mmsBackup.addresses.forEach { writeMmsAddress(it, messageId) }
mmsBackup.parts.forEach { writeMmsPart(it, messageId) }
} else {
Log.d(TAG, "failed to write mms message, invalid mms id")
mmsBackup.addresses.forEach { writeMmsAddress(it, messageId) }
}
} else {
Log.d(TAG, "failed to write mms message, invalid thread id")
}
}
private fun getMmsThreadId(mmsBackup: MmsBackup): Long {
val address = when (mmsBackup.messageBox) {
Mms.MESSAGE_BOX_INBOX -> {
mmsBackup.addresses.firstOrNull { it.type == PduHeaders.FROM }?.address
}
else -> {
mmsBackup.addresses.firstOrNull { it.type == PduHeaders.TO }?.address
}
Mms.MESSAGE_BOX_INBOX -> mmsBackup.addresses.firstOrNull { it.type == PduHeaders.FROM }?.address
else -> mmsBackup.addresses.firstOrNull { it.type == PduHeaders.TO }?.address
}
return if (!address.isNullOrEmpty()) {
Utils.getOrCreateThreadId(context, address)
@ -124,13 +78,10 @@ class MessagesWriter(private val context: Context) {
val projection = arrayOf(Mms._ID)
val selection = "${Mms.DATE} = ? AND ${Mms.DATE_SENT} = ? AND ${Mms.THREAD_ID} = ? AND ${Mms.MESSAGE_BOX} = ?"
val selectionArgs = arrayOf(mmsBackup.date.toString(), mmsBackup.dateSent.toString(), threadId.toString(), mmsBackup.messageBox.toString())
var id = INVALID_ID
context.queryCursor(uri, projection, selection, selectionArgs) {
id = it.getLongValue(Mms._ID)
Log.i(TAG, "getMmsId After: $id")
}
Log.i(TAG, "getMmsId: $id")
return id
}
@ -141,22 +92,14 @@ class MessagesWriter(private val context: Context) {
@SuppressLint("NewApi")
private fun mmsAddressExist(mmsAddress: MmsAddress, messageId: Long): Boolean {
val addressUri = if (isQPlus()) {
Mms.Addr.getAddrUriForMessage(messageId.toString())
} else {
Uri.parse("content://mms/$messageId/addr")
}
val addressUri = if (isQPlus()) Mms.Addr.getAddrUriForMessage(messageId.toString()) else Uri.parse("content://mms/$messageId/addr")
val projection = arrayOf(Mms.Addr._ID)
val selection = "${Mms.Addr.TYPE} = ? AND ${Mms.Addr.ADDRESS} = ? AND ${Mms.Addr.MSG_ID} = ?"
val selectionArgs = arrayOf(mmsAddress.type.toString(), mmsAddress.address.toString(), messageId.toString())
var exists = false
context.queryCursor(addressUri, projection, selection, selectionArgs) {
exists = it.count > 0
Log.i(TAG, "mmsAddressExist After: $exists")
}
Log.i(TAG, "mmsAddressExist: $exists")
return exists
}
@ -172,37 +115,27 @@ class MessagesWriter(private val context: Context) {
val contentValues = mmsAddress.toContentValues()
contentValues.put(Mms.Addr.MSG_ID, messageId)
contentResolver.insert(addressUri, contentValues)
} else {
Log.w(TAG, "writeMmsAddress: Skip already exists")
}
}
@SuppressLint("NewApi")
private fun writeMmsPart(mmsPart: MmsPart, messageId: Long) {
Log.d(TAG, "writeMmsPart: Writing part= $mmsPart")
if (!mmsPartExist(mmsPart, messageId)) {
val uri = Uri.parse("content://mms/${messageId}/part")
val contentValues = mmsPart.toContentValues()
contentValues.put(Mms.Part.MSG_ID, messageId)
val partUri = contentResolver.insert(uri, contentValues)
//write data
Log.d(TAG, "writeMmsPart: Inserted part=$partUri")
try {
if (partUri != null) {
if (mmsPart.isNonText()) {
contentResolver.openOutputStream(partUri).use {
val arr = Base64.decode(mmsPart.data, Base64.DEFAULT)
it!!.write(arr)
Log.d(TAG, "Wrote part data $mmsPart")
}
} else {
Log.w(TAG, "skip writing text content")
}
} else {
Log.e(TAG, "invalid uri while writing part")
}
} catch (e: Exception) {
Log.e(TAG, "writeMmsPart: uri", e)
}
}
}
@ -217,17 +150,7 @@ class MessagesWriter(private val context: Context) {
var exists = false
context.queryCursor(uri, projection, selection, selectionArgs) {
exists = it.count > 0
Log.i(TAG, "mmsPartExist After: $exists")
}
Log.i(TAG, "mmsPartExist: $exists")
return exists
}
fun updateAllSmsThreads() {
// thread dates + states might be wrong, we need to force a full update
// unfortunately there's no direct way to do that in the SDK, but passing a
// negative conversation id to delete should to the trick
contentResolver.delete(Sms.Conversations.CONTENT_URI.buildUpon().appendPath("-1").build(), null, null)
}
}