Implement Sync via SyncManager

lemuroid-app-ext-free/build.gradle.kts

@@ -16,4 +16,7 @@ dependencies {
 
     implementation(deps.libs.retrofit)
     implementation(deps.libs.kotlinxCoroutinesAndroid)
+    implementation("androidx.appcompat:appcompat:1.6.1")
+    implementation("com.google.android.material:material:1.4.0")
+    implementation("androidx.constraintlayout:constraintlayout:2.1.4")
 }

lemuroid-app-ext-free/src/main/AndroidManifest.xml

@@ -1,4 +1,9 @@
-<manifest package="com.swordfish.lemuroid.ext"
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
     xmlns:tools="http://schemas.android.com/tools"
-    tools:ignore="MissingLeanbackLauncher">
+    package="com.swordfish.lemuroid.ext"
+    tools:ignore="MissingLeanbackLauncher,ImpliedTouchscreenHardware,MissingLeanbackSupport">
+
+    <application>
+        <activity android:name="com.swordfish.lemuroid.ext.feature.savesync.ActivateSAFActivity"/>
+    </application>
 </manifest>

lemuroid-app-ext-free/src/main/java/com/swordfish/lemuroid/ext/feature/savesync/ActivateSAFActivity.kt

@@ -0,0 +1,59 @@
+package com.swordfish.lemuroid.ext.feature.savesync
+
+import android.app.Activity
+import android.content.Intent
+import androidx.appcompat.app.AppCompatActivity
+import android.os.Bundle
+import android.widget.Toast
+import androidx.activity.result.contract.ActivityResultContracts
+import com.swordfish.lemuroid.ext.R
+import com.swordfish.lemuroid.lib.preferences.SharedPreferencesHelper
+
+class ActivateSAFActivity : AppCompatActivity() {
+
+    companion object {
+        const val PREF_KEY_STORAGE_URI_NONE = ""
+    }
+
+    override fun onCreate(savedInstanceState: Bundle?) {
+        super.onCreate(savedInstanceState)
+        setContentView(R.layout.activity_activate_safactivity)
+
+        openPicker()
+    }
+
+    private fun openPicker() {
+
+        val intent = Intent(Intent.ACTION_OPEN_DOCUMENT_TREE)
+        val resultLauncher = registerForActivityResult(ActivityResultContracts.StartActivityForResult()) { result ->
+            when (result.resultCode) {
+                Activity.RESULT_OK -> {
+                    val targetUri = result?.data?.data
+
+                    if (targetUri != null ) {
+                        contentResolver.takePersistableUriPermission(
+                            targetUri,
+                            Intent.FLAG_GRANT_WRITE_URI_PERMISSION
+                        )
+                        setStorageUri(targetUri.toString())
+                    }
+                    finish()
+                }
+                else -> {
+                    Toast.makeText(this, getString(R.string.saf_save_sync_no_uri_selected), Toast.LENGTH_LONG).show()
+                    setStorageUri(PREF_KEY_STORAGE_URI_NONE)
+                    finish()
+                }
+            }
+        }
+
+        resultLauncher.launch(intent)
+    }
+
+    private fun setStorageUri(uri: String) {
+        val sharedPreferences = SharedPreferencesHelper.getSharedPreferences(this).edit()
+        val preferenceKey = getString(R.string.pref_key_saf_uri)
+        sharedPreferences.putString(preferenceKey, uri)
+        sharedPreferences.apply()
+    }
+}

lemuroid-app-ext-free/src/main/java/com/swordfish/lemuroid/ext/feature/savesync/SaveSyncManagerImpl.kt

@@ -2,29 +2,224 @@ package com.swordfish.lemuroid.ext.feature.savesync
 
 import android.app.Activity
 import android.content.Context
+import android.net.Uri
+import android.text.format.Formatter
+import androidx.documentfile.provider.DocumentFile
+import com.swordfish.lemuroid.common.kotlin.SharedPreferencesDelegates
+import com.swordfish.lemuroid.ext.R
 import com.swordfish.lemuroid.lib.library.CoreID
+import com.swordfish.lemuroid.lib.preferences.SharedPreferencesHelper
 import com.swordfish.lemuroid.lib.savesync.SaveSyncManager
 import com.swordfish.lemuroid.lib.storage.DirectoriesManager
+import timber.log.Timber
+import java.io.*
+import java.text.SimpleDateFormat
+
 
 class SaveSyncManagerImpl(
     private val appContext: Context,
     private val directoriesManager: DirectoriesManager
 ) : SaveSyncManager {
-    override fun getProvider(): String = ""
 
-    override fun getSettingsActivity(): Class<out Activity>? = null
+    private var lastSyncTimestamp: Long by SharedPreferencesDelegates.LongDelegate(
+        SharedPreferencesHelper.getSharedPreferences(appContext),
+        appContext.getString(R.string.pref_key_last_save_sync),
+        0L
+    )
+
+    private var storageUri: String by SharedPreferencesDelegates.StringDelegate(
+        SharedPreferencesHelper.getSharedPreferences(appContext),
+        appContext.getString(R.string.pref_key_saf_uri),
+        ActivateSAFActivity.PREF_KEY_STORAGE_URI_NONE
+    )
+
+
+    override fun getProvider(): String = appContext.getString(R.string.saf_save_sync_providername)
+
+    override fun getSettingsActivity(): Class<out Activity>? = ActivateSAFActivity::class.java
+
+    override fun isSupported(): Boolean = true
+
+    override fun isConfigured(): Boolean {
+        return storageUri != ActivateSAFActivity.PREF_KEY_STORAGE_URI_NONE
+    }
+
+    override fun getLastSyncInfo(): String {
+        val dateString = if (lastSyncTimestamp > 0) {
+            SimpleDateFormat.getDateTimeInstance().format(lastSyncTimestamp)
+        } else {
+            "-"
+        }
+        return appContext.getString(R.string.saf_last_sync_completed, dateString)
+    }
+
+    override fun getConfigInfo(): String {
+        return storageUri
+    }
+
+    /**
+     * Sync savegames.
+     *
+     * Todo: Sync states!
+     */
+    override suspend fun sync(cores: Set<CoreID>) {
+        synchronized(SYNC_LOCK) {
+            val saveSyncResult = runCatching {
+                val safProviderUri = Uri.parse(storageUri)
+                val safDirectory = DocumentFile.fromTreeUri(appContext.applicationContext, safProviderUri)
+
+                if (safDirectory != null) {
+
+                    // copy from saf to internal
+                    updateInternalStorage(safDirectory)
+
+                    // now copy from internal to saf
+                    updateRemoteStorage(safDirectory)
+                }
+                lastSyncTimestamp = System.currentTimeMillis()
+            }
+
+            saveSyncResult.onFailure {
+                Timber.e(it, "Error while performing save sync.")
+            }
+        }
+    }
+
+    private fun updateInternalStorage(safDirectory: DocumentFile) {
+        val saveFiles = safDirectory.listFiles()
+
+        for (saveFile in saveFiles) {
+            if (!saveFile.name.isNullOrEmpty()) {
+                val internalTarget = getInternalSaveFile(saveFile.name!!)
+                if (internalTarget != null) {
+                    if (internalTarget.lastModified() < saveFile.lastModified()) {
+                        copyFromSafToInternal(saveFile, internalTarget)
+                    }
+                } else {
+                    val internalDir = File(appContext.getExternalFilesDir(null), "saves");
+                    val newTarget = File(internalDir, saveFile.name)
+                    if (newTarget.createNewFile()) {
+                        copyFromSafToInternal(saveFile, newTarget)
+                    } else {
+                        Timber.e("Could not create new file in internal storage")
+                    }
+                }
+            } else {
+                Timber.tag("SAF to Internal").d("Error: Remote file does not have a name!")
+            }
+        }
+    }
+
+    private fun updateRemoteStorage(safDirectory: DocumentFile) {
+        // todo: check if there is a "saves"-constant
+        val internalSavefiles = File(appContext.getExternalFilesDir(null), "saves").listFiles()
+
+        if (internalSavefiles != null) {
+            for (internalFile in internalSavefiles) {
+                val safTarget = safDirectory.findFile(internalFile.name)
+                if (safTarget != null) {
+                    if (safTarget.lastModified() < internalFile.lastModified()) {
+                        copyFromInternalToSaf(safTarget, internalFile)
+                    }
+                } else {
+                    val newTarget = safDirectory.createFile("application/octet-stream", internalFile.name)
+                    if (newTarget != null) {
+                        copyFromInternalToSaf(newTarget, internalFile)
+                    }
+                }
+            }
+        }
+    }
+
+    private fun getInternalSaveFile(filename: String): File? {
+        val saves = File(appContext.getExternalFilesDir(null), "saves")
+        saves.mkdirs()
+        for (i in saves.listFiles()!!) {
+            if (i.name.equals(filename)) {
+                return File(saves, i.name)
+            }
+        }
+        return null
+    }
+
+    /**
+     * Copy a file from the provided DocumentFile to File via copyFile().
+     * File will get an updated timestamp, matching the older DocumentFile.
+     * File will have a backdated timestamp. This is so that the sync-client will
+     * not "backsync" the "newer" file in Internal Storage back to SAF even if both are identical.
+     */
+    private fun copyFromSafToInternal(saf: DocumentFile, internal: File) {
+        val output: OutputStream = FileOutputStream(internal)
+        val input: InputStream? = appContext.contentResolver.openInputStream(saf.uri)
+        copyFile(input, output)
+        // update last modified timestamp to match (this one backdates the file)
+        internal.setLastModified(saf.lastModified())
+    }
+
+    /**
+     * Copy a file from the provided File to DocumentFile via copyFile().
+     * File will get an updated timestamp, matching the (new) DocumentFile.
+     * For the reasoning, see copyFromSafToInternal()
+     */
+    private fun copyFromInternalToSaf(saf: DocumentFile, internal: File) {
+        val output: OutputStream? = appContext.contentResolver.openOutputStream(saf.uri)
+        val input: InputStream = FileInputStream(internal)
+        copyFile(input, output)
+
+        // update last modified timestamp to match
+        internal.setLastModified(saf.lastModified())
+    }
+
+
+    /**
+     * This function writes from input to output.
+     * Null-checks are performed and caught.
+     */
+    private fun copyFile(inputStream: InputStream?, outputStream: OutputStream?) {
+        if (inputStream == null) {
+            Timber.d("SaveSyncManagerImpl: copyFile: Could not read source file!")
+            return
+        }
+        if (outputStream == null) {
+            Timber.d("SaveSyncManagerImpl: copyFile: Could not read target file!")
+            return
+        }
+
+        inputStream.use { input ->
+            outputStream.use { output ->
+                // use 8k buffer for better performance
+                val buf = ByteArray(8192)
+                var len: Int
+                while (input.read(buf).also { len = it } > 0) {
+                    output.write(buf, 0, len)
+                }
+            }
+        }
+    }
 
-    override fun isSupported(): Boolean = false
+    override fun computeSavesSpace(): String {
+        var size = 0L
+        val safProviderUri = Uri.parse(storageUri)
+        val safDirectory = DocumentFile.fromTreeUri(appContext.applicationContext, safProviderUri)
 
-    override fun isConfigured(): Boolean = false
+        if (safDirectory != null) {
 
-    override fun getLastSyncInfo(): String = ""
+            val saveFiles = safDirectory.listFiles()
 
-    override fun getConfigInfo(): String = ""
+            for (saveFile in saveFiles) {
+                size += saveFile.length()
+            }
+        }
+        return Formatter.formatShortFileSize(appContext, size)
+    }
 
-    override suspend fun sync(cores: Set<CoreID>) {}
+    override fun computeStatesSpace(coreID: CoreID): String {
+        return "0"
+    }
 
-    override fun computeSavesSpace() = ""
 
-    override fun computeStatesSpace(coreID: CoreID) = ""
+    companion object {
+        const val GDRIVE_PROPERTY_LOCAL_PATH = "localPath"
+        private val SYNC_LOCK = Object()
+    }
 }

lemuroid-app-ext-free/src/main/res/layout/activity_activate_safactivity.xml

@@ -0,0 +1,9 @@
+<?xml version="1.0" encoding="utf-8"?>
+<androidx.constraintlayout.widget.ConstraintLayout xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    xmlns:tools="http://schemas.android.com/tools"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent"
+    tools:context=".feature.savesync.ActivateSAFActivity">
+
+</androidx.constraintlayout.widget.ConstraintLayout>

lemuroid-app-ext-free/src/main/res/values/strings.xml

@@ -6,4 +6,7 @@
     <string name="installing_core_notification_message">This can take up to a few minutes</string>
 
     <string name="game_loader_error_load_core">The Libretro core was not loaded. Make sure your device is connected to internet and try to rescan your library. If the issue persist this core might not be supported on your device.</string>
+    <string name="saf_last_sync_completed">Last sync: %s</string>
+    <string name="saf_save_sync_providername">SAF</string>
+    <string name="saf_save_sync_no_uri_selected">You have not selected a folder. Sync unavailable!</string>
 </resources>

retrograde-app-shared/src/main/res/values/keys.xml

@@ -5,4 +5,5 @@
     <string name="pref_key_last_save_sync" translatable="false">last_save_sync</string>
     <string name="pref_key_extenral_folder" translatable="false">external_folder</string>
     <string name="pref_key_legacy_external_folder" translatable="false">legacy_external_folder</string>
+    <string name="pref_key_saf_uri" translatable="false">pref_key_saf_uri</string>
 </resources>