fix: remove MANAGE_EXTERNAL_STORAGE and fix sync workers

Author: zerox80

opencloudApp/src/main/AndroidManifest.xml

@@ -23,7 +23,6 @@
         API >= 23; the app needs to handle this
     -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
-    <uses-permission android:name="android.permission.MANAGE_EXTERNAL_STORAGE" tools:ignore="ScopedStorage" />
     <!--
         Notifications are off by default since API 33;
         See note in https://developer.android.com/develop/ui/views/notifications/notification-permission

opencloudApp/src/main/java/eu/opencloud/android/ui/activity/FileDisplayActivity.kt

@@ -283,25 +283,10 @@ class FileDisplayActivity : FileActivity(),
         }
 
         checkNotificationPermission()
-        checkManageExternalStoragePermission()
         Timber.v("onCreate() end")
     }
 
-    private fun checkManageExternalStoragePermission() {
-        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && !android.os.Environment.isExternalStorageManager()) {
-            val builder = AlertDialog.Builder(this)
-            builder.setTitle(getString(R.string.app_name))
-            builder.setMessage("To save offline files, the app needs access to all files.")
-            builder.setPositiveButton("Settings") { _, _ ->
-                val intent = Intent(android.provider.Settings.ACTION_MANAGE_APP_ALL_FILES_ACCESS_PERMISSION)
-                intent.addCategory("android.intent.category.DEFAULT")
-                intent.data = Uri.parse("package:$packageName")
-                startActivity(intent)
-            }
-            builder.setNegativeButton("Cancel", null)
-            builder.show()
-        }
-    }
+
 
     private fun checkNotificationPermission() {
         // Ask for permission only in case it's api >= 33 and notifications are not granted.

opencloudApp/src/main/java/eu/opencloud/android/usecases/synchronization/SynchronizeFileUseCase.kt

@@ -36,6 +36,8 @@ import java.text.SimpleDateFormat
 import java.util.Date
 import java.util.Locale
 import java.util.UUID
+import kotlinx.coroutines.Dispatchers
+import kotlinx.coroutines.runBlocking
 
 class SynchronizeFileUseCase(
     private val downloadFileUseCase: DownloadFileUseCase,
@@ -44,26 +46,10 @@ class SynchronizeFileUseCase(
     private val preferencesProvider: SharedPreferencesProvider,
 ) : BaseUseCaseWithResult<SynchronizeFileUseCase.SyncType, SynchronizeFileUseCase.Params>() {
 
-    override fun run(params: Params): SyncType {
+    override fun run(params: Params): SyncType = runBlocking(Dispatchers.IO) {
         val fileToSynchronize = params.fileToSynchronize
         val accountName: String = fileToSynchronize.owner
 
-        // Fix: Use correct dispatcher usage. `CoroutineScope(Dispatchers.IO).run` blocks the current thread
-        // if called with `runBlocking` or similar upstream, but here it returns a value, so it implies this is synchronous code?
-        // `BaseUseCaseWithResult` usually runs in a background thread if invoked correctly?
-        // The original code used `CoroutineScope(Dispatchers.IO).run`, which creates a scope and runs the block.
-        // But `run` is incorrect here if we want to return from the function.
-        // `CoroutineScope(Dispatchers.IO).run` returns the result of the block.
-        // Actually `run` is a standard library extension on T.
-        // `CoroutineScope(Dispatchers.IO)` creates a stand-alone scope. `run` executes the block on *that object*.
-        // It does NOT switch threads! `CoroutineScope(Dispatchers.IO)` just creates a new scope object.
-        // The original code was likely running on the caller's thread!
-        // `Dispatchers.IO` was completely ignored because `launch` or `async` wasn't called.
-        // `CoroutineScope(...)` is just a factory. `.run { ... }` just runs the lambda on it.
-        // This is a subtle but massive bug in the original code too if it expected async/threading.
-        // However, `BaseUseCaseWithResult` might be handling threading?
-        // Let's assume we just want to fix the logic bugs for now.
-
         // 1. Check local state first to avoid network calls if possible (optimization)
         // Check if file has changed locally by reading ACTUAL file timestamp from filesystem
         val storagePath = fileToSynchronize.storagePath
@@ -127,9 +113,14 @@ class SynchronizeFileUseCase(
                 } else {
                     // Default: Create conflicted copy of local, download remote.
                     Timber.i("File ${fileToSynchronize.fileName} has changed locally and remotely. Creating conflicted copy.")
-                    val conflictedCopyPath = createConflictedCopyPath(fileToSynchronize)
+                    val localPath = fileToSynchronize.storagePath
+                    if (localPath.isNullOrEmpty()) {
+                        Timber.e("File ${fileToSynchronize.fileName} has no local storage path. Cannot create conflicted copy.")
+                        return@runBlocking SyncType.AlreadySynchronized
+                    }
+                    val conflictedCopyPath = createConflictedCopyPath(localPath)
                     // Fix: Rename safety
-                    val renamed = renameLocalFile(fileToSynchronize.storagePath!!, conflictedCopyPath)
+                    val renamed = renameLocalFile(localPath, conflictedCopyPath)
 
                     if (renamed) {
                         Timber.i("Local file renamed to conflicted copy: $conflictedCopyPath")
@@ -184,18 +175,23 @@ class SynchronizeFileUseCase(
             )
         )
 
-    private fun requestForUpload(accountName: String, ocFile: OCFile): UUID? =
-        uploadFileInConflictUseCase(
+    private fun requestForUpload(accountName: String, ocFile: OCFile): UUID? {
+        val localPath = ocFile.storagePath
+        if (localPath.isNullOrEmpty()) {
+            Timber.e("Cannot upload file ${ocFile.fileName} because storagePath is null or empty.")
+            return null
+        }
+        return uploadFileInConflictUseCase(
             UploadFileInConflictUseCase.Params(
                 accountName = accountName,
-                localPath = ocFile.storagePath!!,
+                localPath = localPath,
                 uploadFolderPath = ocFile.getParentRemotePath(),
                 spaceId = ocFile.spaceId,
             )
         )
+    }
 
-    private fun createConflictedCopyPath(ocFile: OCFile): String {
-        val originalPath = ocFile.storagePath!!
+    private fun createConflictedCopyPath(originalPath: String): String {
         val file = File(originalPath)
         val nameWithoutExt = file.nameWithoutExtension
         val extension = file.extension

opencloudApp/src/main/java/eu/opencloud/android/workers/LocalFileSyncWorker.kt

@@ -210,7 +210,7 @@ class LocalFileSyncWorker(
 
     companion object {
         const val LOCAL_FILE_SYNC_WORKER = "LOCAL_FILE_SYNC_WORKER"
-        const val repeatInterval: Long = 5L
+        const val repeatInterval: Long = 15L
         val repeatIntervalTimeUnit: TimeUnit = TimeUnit.MINUTES
 
         private const val NOTIFICATION_CHANNEL_ID = "auto_sync_channel"