LibreTube/app/src/main/java/com/github/libretube/helpers/BackupHelper.kt

105 lines
4.0 KiB
Kotlin
Raw Normal View History

package com.github.libretube.helpers
2022-08-13 18:42:09 +05:30
import android.content.Context
import android.net.Uri
2023-01-19 14:08:21 +05:30
import android.util.Log
import androidx.core.content.edit
2022-08-13 18:42:09 +05:30
import androidx.preference.PreferenceManager
2023-01-19 14:08:21 +05:30
import com.github.libretube.api.JsonHelper
import com.github.libretube.constants.PreferenceKeys
2023-02-11 07:26:07 +05:30
import com.github.libretube.db.DatabaseHolder.Database
2023-01-19 14:08:21 +05:30
import com.github.libretube.extensions.TAG
2022-09-18 16:11:35 +05:30
import com.github.libretube.obj.BackupFile
import com.github.libretube.obj.PreferenceItem
import kotlinx.serialization.ExperimentalSerializationApi
2023-01-19 14:08:21 +05:30
import kotlinx.serialization.json.booleanOrNull
import kotlinx.serialization.json.decodeFromStream
import kotlinx.serialization.json.encodeToStream
import kotlinx.serialization.json.floatOrNull
import kotlinx.serialization.json.intOrNull
import kotlinx.serialization.json.longOrNull
2022-08-13 18:42:09 +05:30
/**
* Backup and restore the preferences
*/
object BackupHelper {
2022-08-13 18:42:09 +05:30
/**
* Write a [BackupFile] containing the database content as well as the preferences
2022-09-18 16:11:35 +05:30
*/
@OptIn(ExperimentalSerializationApi::class)
fun createAdvancedBackup(context: Context, uri: Uri, backupFile: BackupFile) {
try {
context.contentResolver.openOutputStream(uri)?.use { outputStream ->
JsonHelper.json.encodeToStream(backupFile, outputStream)
2022-09-18 16:11:35 +05:30
}
} catch (e: Exception) {
Log.e(TAG(), "Error while writing backup: $e")
2022-09-18 16:11:35 +05:30
}
}
/**
* Restore data from a [BackupFile]
2022-09-18 16:11:35 +05:30
*/
@OptIn(ExperimentalSerializationApi::class)
suspend fun restoreAdvancedBackup(context: Context, uri: Uri) {
val backupFile = context.contentResolver.openInputStream(uri)?.use {
JsonHelper.json.decodeFromStream<BackupFile>(it)
2023-01-19 14:08:21 +05:30
} ?: return
2022-09-18 16:11:35 +05:30
Database.watchHistoryDao().insertAll(backupFile.watchHistory.orEmpty())
Database.searchHistoryDao().insertAll(backupFile.searchHistory.orEmpty())
Database.watchPositionDao().insertAll(backupFile.watchPositions.orEmpty())
Database.localSubscriptionDao().insertAll(backupFile.localSubscriptions.orEmpty())
Database.customInstanceDao().insertAll(backupFile.customInstances.orEmpty())
Database.playlistBookmarkDao().insertAll(
*backupFile.playlistBookmarks.orEmpty().toTypedArray()
)
backupFile.localPlaylists.orEmpty().forEach {
Database.localPlaylistsDao().createPlaylist(it.playlist)
val playlistId = Database.localPlaylistsDao().getAll().last().playlist.id
it.videos.forEach {
it.playlistId = playlistId
Database.localPlaylistsDao().addPlaylistVideo(it)
}
}
restorePreferences(context, backupFile.preferences)
}
/**
* Restore the shared preferences from a backup file
*/
private fun restorePreferences(context: Context, preferences: List<PreferenceItem>?) {
if (preferences == null) return
PreferenceManager.getDefaultSharedPreferences(context).edit(commit = true) {
// clear the previous settings
clear()
// decide for each preference which type it is and save it to the preferences
preferences.forEach { (key, jsonValue) ->
val value = if (jsonValue.isString) {
jsonValue.content
} else {
jsonValue.booleanOrNull
?: jsonValue.intOrNull
?: jsonValue.longOrNull
?: jsonValue.floatOrNull
}
2023-01-19 14:08:21 +05:30
when (value) {
is Boolean -> putBoolean(key, value)
is Float -> putFloat(key, value)
is Long -> putLong(key, value)
is Int -> {
when (key) {
PreferenceKeys.START_FRAGMENT -> putInt(key, value)
else -> putLong(key, value.toLong())
}
}
is String -> putString(key, value)
}
}
2022-09-18 16:11:35 +05:30
}
}
2022-08-13 18:42:09 +05:30
}