Cleanup code and remove logs

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

@@ -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 ->
+            smsExporter.exportMessages(outputStream) {
-                Log.d(TAG, "PERCENTAGE: ${current.toDouble() * 100 / total.toDouble()}%")
-            }) {
                 toast(
                     when (it) {
                         MessagesExporter.ExportResult.EXPORT_OK -> R.string.exporting_successful

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

@@ -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 ->
+                            MessagesImporter(activity).importMessages(path) {
-                                Log.d(TAG, "PERCENTAGE: ${current.toDouble() * 100 / total.toDouble()}%")
-                            }) {
                                 handleParseResult(it)
-                            }
                                 dismiss()
-                            callback.invoke(true)
+                            }
                         }
                     }
                 }

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

@@ -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)
-        }
-    }
-}

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

@@ -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 {

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

@@ -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()
                     }
                 }

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

@@ -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()) {
+        val uri = if (isQPlus()) Mms.Part.CONTENT_URI else Uri.parse("content://mms/part")
-            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()
+                        Base64.encodeToString(stream.readBytes(), Base64.DEFAULT)
-                        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)
                     }
                 }
             }
@@ -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()) {
+        val partUri = if (isQPlus()) Mms.Part.CONTENT_URI.buildUpon().appendPath(partId.toString()).build() else Uri.parse("content://mms/part/$partId")
-            Mms.Part.CONTENT_URI.buildUpon().appendPath(partId.toString()).build()
-        } else {
-            Uri.parse("content://mms/part/$partId")
-        }
         try {
-            val stream = context.contentResolver.openInputStream(partUri)
+            val stream = context.contentResolver.openInputStream(partUri) ?: return ""
-            if (stream == null) {
-                val msg = "failed opening stream for mms part $partUri"
-                Log.e(TAG, msg)
-                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()) {
+        val uri = if (isQPlus()) Mms.Addr.getAddrUriForMessage(messageId.toString()) else Uri.parse("content://mms/$messageId/addr")
-            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
     }
 

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

@@ -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.Mms
-import android.provider.Telephony.*
+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 val INVALID_ID = -1L
-        private const val INVALID_ID = -1L
-        private const val TAG = "MessagesWriter"
-    }
-
     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 {
+                mmsBackup.addresses.forEach { writeMmsAddress(it, messageId) }
-                Log.d(TAG, "failed to write mms message, invalid mms id")
             }
-        } 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 -> {
+            Mms.MESSAGE_BOX_INBOX -> mmsBackup.addresses.firstOrNull { it.type == PduHeaders.FROM }?.address
-                mmsBackup.addresses.firstOrNull { it.type == PduHeaders.FROM }?.address
+            else -> mmsBackup.addresses.firstOrNull { it.type == PduHeaders.TO }?.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()) {
+        val addressUri = if (isQPlus()) Mms.Addr.getAddrUriForMessage(messageId.toString()) else Uri.parse("content://mms/$messageId/addr")
-            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)
-    }
 }