fenix/Simple-SMS-Messenger
1
0
Fork 0
mirror of https://github.com/SimpleMobileTools/Simple-SMS-Messenger.git synced 2025-02-16 11:40:51 +01:00
Code Issues Packages Projects Releases Wiki Activity

Add support for importing XML exports

Browse Source 
This covers importing from Signal and Silence applications export

This closes #519
This commit is contained in:
Ensar Sarajčić 2023-07-12 12:13:59 +02:00
parent 7ca11c8427
commit e825e44f54
3 changed files with 155 additions and 57 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -627,6 +627,7 @@ class MainActivity : SimpleActivity() {
Intent(Intent.ACTION_GET_CONTENT).apply {
addCategory(Intent.CATEGORY_OPENABLE)
type = EXPORT_MIME_TYPE
putExtra(Intent.EXTRA_MIME_TYPES, arrayOf(EXPORT_MIME_TYPE, XML_IMPORT_MIME_TYPE))
try {
startActivityForResult(this, PICK_IMPORT_SOURCE_INTENT)
@ -639,27 +640,27 @@ class MainActivity : SimpleActivity() {
} else {
handlePermission(PERMISSION_READ_STORAGE) {
if (it) {
importEvents()
importMessages()
}
}
}
}
private fun importEvents() {
private fun importMessages() {
FilePickerDialog(this) {
showImportEventsDialog(it)
showImportMessagesDialog(it)
}
}
private fun showImportEventsDialog(path: String) {
private fun showImportMessagesDialog(path: String) {
ImportMessagesDialog(this, path)
}
private fun tryImportMessagesFromFile(uri: Uri) {
when (uri.scheme) {
"file" -> showImportEventsDialog(uri.path!!)
"file" -> showImportMessagesDialog(uri.path!!)
"content" -> {
val tempFile = getTempFile("messages", "backup.json")
var tempFile = getTempFile("messages", "backup.json")
if (tempFile == null) {
toast(R.string.unknown_error_occurred)
return
@ -669,7 +670,18 @@ class MainActivity : SimpleActivity() {
val inputStream = contentResolver.openInputStream(uri)
val out = FileOutputStream(tempFile)
inputStream!!.copyTo(out)
showImportEventsDialog(tempFile.absolutePath)
// Check is XML and properly rename
tempFile.bufferedReader().use {
if (it.readLine().startsWith("<?xml")) {
val xmlFile = getTempFile("messages", "backup.xml")
if (xmlFile == null || tempFile?.renameTo(xmlFile) == false) {
toast(R.string.unknown_error_occurred)
return
}
tempFile = xmlFile
}
}
showImportMessagesDialog(tempFile!!.absolutePath)
} catch (e: Exception) {
showErrorToast(e)
}

1
app/src/main/kotlin/com/simplemobiletools/smsmessenger/helpers/Constants.kt
View File

@ -30,6 +30,7 @@ const val EXPORT_SMS = "export_sms"
const val EXPORT_MMS = "export_mms"
const val EXPORT_MIME_TYPE = "application/json"
const val EXPORT_FILE_EXT = ".json"
const val XML_IMPORT_MIME_TYPE = "text/xml"
const val IMPORT_SMS = "import_sms"
const val IMPORT_MMS = "import_mms"
const val WAS_DB_CLEARED = "was_db_cleared_2"

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

@ -2,6 +2,7 @@ package com.simplemobiletools.smsmessenger.helpers
import android.content.Context
import android.util.JsonToken
import android.util.Xml
import com.google.gson.Gson
import com.google.gson.reflect.TypeToken
import com.simplemobiletools.commons.extensions.showErrorToast
@ -13,7 +14,9 @@ import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.
import com.simplemobiletools.smsmessenger.helpers.MessagesImporter.ImportResult.IMPORT_PARTIAL
import com.simplemobiletools.smsmessenger.models.MmsBackup
import com.simplemobiletools.smsmessenger.models.SmsBackup
import org.xmlpull.v1.XmlPullParser
import java.io.File
import java.io.InputStream
class MessagesImporter(private val context: Context) {
enum class ImportResult {
@ -35,57 +38,12 @@ class MessagesImporter(private val context: Context) {
context.assets.open(path)
}
inputStream.bufferedReader().use { reader ->
val jsonReader = gson.newJsonReader(reader)
val smsMessageType = object : TypeToken<SmsBackup>() {}.type
val mmsMessageType = object : TypeToken<MmsBackup>() {}.type
jsonReader.beginArray()
while (jsonReader.hasNext()) {
jsonReader.beginObject()
while (jsonReader.hasNext()) {
val nextToken = jsonReader.peek()
if (nextToken.ordinal == JsonToken.NAME.ordinal) {
val msgType = jsonReader.nextName()
if ((!msgType.equals("sms") && !msgType.equals("mms")) ||
(msgType.equals("sms") && !config.importSms) ||
(msgType.equals("mms") && !config.importMms)
) {
jsonReader.skipValue()
continue
}
jsonReader.beginArray()
while (jsonReader.hasNext()) {
try {
if (msgType.equals("sms")) {
val message = gson.fromJson<SmsBackup>(jsonReader, smsMessageType)
messageWriter.writeSmsMessage(message)
} else {
val message = gson.fromJson<MmsBackup>(jsonReader, mmsMessageType)
messageWriter.writeMmsMessage(message)
}
messagesImported++
} catch (e: Exception) {
context.showErrorToast(e)
messagesFailed++
}
}
jsonReader.endArray()
} else {
jsonReader.skipValue()
}
}
jsonReader.endObject()
refreshMessages()
}
jsonReader.endArray()
if (path.endsWith("xml")) {
inputStream.importXml()
} else {
inputStream.importJson()
}
} catch (e: Exception) {
context.showErrorToast(e)
messagesFailed++
@ -101,4 +59,131 @@ class MessagesImporter(private val context: Context) {
)
}
}
private fun InputStream.importJson() {
bufferedReader().use { reader ->
val jsonReader = gson.newJsonReader(reader)
val smsMessageType = object : TypeToken<SmsBackup>() {}.type
val mmsMessageType = object : TypeToken<MmsBackup>() {}.type
jsonReader.beginArray()
while (jsonReader.hasNext()) {
jsonReader.beginObject()
while (jsonReader.hasNext()) {
val nextToken = jsonReader.peek()
if (nextToken.ordinal == JsonToken.NAME.ordinal) {
val msgType = jsonReader.nextName()
if ((!msgType.equals("sms") && !msgType.equals("mms")) ||
(msgType.equals("sms") && !config.importSms) ||
(msgType.equals("mms") && !config.importMms)
) {
jsonReader.skipValue()
continue
}
jsonReader.beginArray()
while (jsonReader.hasNext()) {
try {
if (msgType.equals("sms")) {
val message = gson.fromJson<SmsBackup>(jsonReader, smsMessageType)
messageWriter.writeSmsMessage(message)
} else {
val message = gson.fromJson<MmsBackup>(jsonReader, mmsMessageType)
messageWriter.writeMmsMessage(message)
}
messagesImported++
} catch (e: Exception) {
context.showErrorToast(e)
messagesFailed++
}
}
jsonReader.endArray()
} else {
jsonReader.skipValue()
}
}
jsonReader.endObject()
refreshMessages()
}
jsonReader.endArray()
}
}
private fun InputStream.importXml() {
bufferedReader().use { reader ->
val xmlParser = Xml.newPullParser().apply {
setInput(reader)
}
xmlParser.nextTag()
xmlParser.require(XmlPullParser.START_TAG, null, "smses")
var depth = 1
while (depth != 0) {
when (xmlParser.next()) {
XmlPullParser.END_TAG -> depth--
XmlPullParser.START_TAG -> depth++
}
if (xmlParser.eventType != XmlPullParser.START_TAG) {
continue
}
try {
if (xmlParser.name == "sms") {
if (config.importSms) {
val message = xmlParser.readSms()
messageWriter.writeSmsMessage(message)
messagesImported++
} else {
xmlParser.skip()
}
} else {
xmlParser.skip()
}
} catch (e: Exception) {
context.showErrorToast(e)
messagesFailed++
}
}
refreshMessages()
}
}
private fun XmlPullParser.readSms(): SmsBackup {
require(XmlPullParser.START_TAG, null, "sms")
return SmsBackup(
subscriptionId = 0,
address = getAttributeValue(null, "address"),
body = getAttributeValue(null, "body"),
date = getAttributeValue(null, "date").toLong(),
dateSent = getAttributeValue(null, "date").toLong(),
locked = getAttributeValue(null, "locked").toInt(),
protocol = getAttributeValue(null, "protocol"),
read = getAttributeValue(null, "read").toInt(),
status = getAttributeValue(null, "status").toInt(),
type = getAttributeValue(null, "type").toInt(),
serviceCenter = getAttributeValue(null, "service_center")
)
}
private fun XmlPullParser.skip() {
if (eventType != XmlPullParser.START_TAG) {
throw IllegalStateException()
}
var depth = 1
while (depth != 0) {
when (next()) {
XmlPullParser.END_TAG -> depth--
XmlPullParser.START_TAG -> depth++
}
}
}
}