diff --git a/opencloudApp/src/main/AndroidManifest.xml b/opencloudApp/src/main/AndroidManifest.xml
index 4ced565012..f580645441 100644
--- a/opencloudApp/src/main/AndroidManifest.xml
+++ b/opencloudApp/src/main/AndroidManifest.xml
@@ -23,6 +23,12 @@
         API >= 23; the app needs to handle this
     -->
     <uses-permission android:name="android.permission.WRITE_EXTERNAL_STORAGE" />
+    <!--
+        Since API 29 the system strips location metadata (GPS EXIF) from photos and videos read
+        through the media store / SAF unless this permission is held. Requested at runtime only
+        when picture or video automatic uploads are enabled.
+    -->
+    <uses-permission android:name="android.permission.ACCESS_MEDIA_LOCATION" />
     <!--
         Notifications are off by default since API 33;
         See note in https://developer.android.com/develop/ui/views/notifications/notification-permission
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/extensions/FragmentExt.kt b/opencloudApp/src/main/java/eu/opencloud/android/extensions/FragmentExt.kt
index 17d9ebf969..7294f19be0 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/extensions/FragmentExt.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/extensions/FragmentExt.kt
@@ -57,7 +57,8 @@ fun Fragment.showAlertDialog(
     positiveButtonText: String = getString(android.R.string.ok),
     positiveButtonListener: ((DialogInterface, Int) -> Unit)? = null,
     negativeButtonText: String = "",
-    negativeButtonListener: ((DialogInterface, Int) -> Unit)? = null
+    negativeButtonListener: ((DialogInterface, Int) -> Unit)? = null,
+    onDismissListener: DialogInterface.OnDismissListener? = null
 ) {
     val requiredActivity = activity ?: return
     AlertDialog.Builder(requiredActivity)
@@ -65,6 +66,7 @@ fun Fragment.showAlertDialog(
         .setMessage(message)
         .setPositiveButton(positiveButtonText, positiveButtonListener)
         .setNegativeButton(negativeButtonText, negativeButtonListener)
+        .setOnDismissListener(onDismissListener)
         .show()
         .avoidScreenshotsIfNeeded()
 }
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequester.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequester.kt
new file mode 100644
index 0000000000..4d758f5947
--- /dev/null
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequester.kt
@@ -0,0 +1,113 @@
+/**
+ * openCloud Android client application
+ *
+ * Copyright (C) 2026 OpenCloud GmbH.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.presentation.settings.automaticuploads
+
+import android.Manifest
+import androidx.activity.result.contract.ActivityResultContracts
+import androidx.fragment.app.Fragment
+import eu.opencloud.android.R
+import eu.opencloud.android.data.providers.SharedPreferencesProvider
+import eu.opencloud.android.extensions.showMessageInSnackbar
+import eu.opencloud.android.utils.MediaLocationUtils
+import org.koin.android.ext.android.inject
+
+/**
+ * Asks for [Manifest.permission.ACCESS_MEDIA_LOCATION] from the picture and video automatic
+ * upload settings. Without it, Android strips the GPS metadata from the media we read (API >= 29).
+ *
+ * The system dialog is only launched when Android will really show it, so the user is never
+ * prompted on every visit and the "denied" hint only follows an answer the user actually gave.
+ *
+ * Must be created while the fragment is being initialized (it registers an activity result launcher).
+ */
+class MediaLocationPermissionRequester(private val fragment: Fragment) {
+
+    private val preferencesProvider: SharedPreferencesProvider by fragment.inject()
+
+    private val requestPermissionLauncher =
+        fragment.registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
+            if (!isGranted && fragment.isAdded) {
+                fragment.showMessageInSnackbar(fragment.getString(R.string.media_location_permission_denied))
+            }
+        }
+
+    // True between the user switching uploads on and the "Important" dialog being dismissed,
+    // so the system dialog does not open on top of it.
+    private var isPostponed = false
+
+    /**
+     * The screen shows enabled automatic uploads: ask, but only if the user was never asked before.
+     */
+    fun requestIfNeverAsked() {
+        if (isPostponed) return
+        request(userInitiated = false)
+    }
+
+    /**
+     * The user is switching automatic uploads on. Holds back [requestIfNeverAsked] until
+     * [requestAfterEnabling] is called.
+     */
+    fun postpone() {
+        isPostponed = true
+    }
+
+    /**
+     * The user switched automatic uploads on and has dismissed the "Important" dialog. Asks again
+     * after an earlier denial as long as Android still shows the dialog.
+     */
+    fun requestAfterEnabling() {
+        isPostponed = false
+        request(userInitiated = true)
+    }
+
+    private fun request(userInitiated: Boolean) {
+        val context = fragment.context ?: return
+        if (!fragment.isAdded) return
+
+        val shouldRequest = shouldRequest(
+            isGranted = MediaLocationUtils.isAccessMediaLocationGranted(context),
+            alreadyRequested = preferencesProvider.getBoolean(PREFERENCE_MEDIA_LOCATION_PERMISSION_REQUESTED, false),
+            shouldShowRationale = fragment.shouldShowRequestPermissionRationale(Manifest.permission.ACCESS_MEDIA_LOCATION),
+            userInitiated = userInitiated,
+        )
+        if (!shouldRequest) return
+
+        preferencesProvider.putBoolean(PREFERENCE_MEDIA_LOCATION_PERMISSION_REQUESTED, true)
+        requestPermissionLauncher.launch(Manifest.permission.ACCESS_MEDIA_LOCATION)
+    }
+
+    companion object {
+        // Shared by pictures and videos: it is one permission, asked once.
+        internal const val PREFERENCE_MEDIA_LOCATION_PERMISSION_REQUESTED = "PREFERENCE_MEDIA_LOCATION_PERMISSION_REQUESTED"
+
+        /**
+         * - Never asked: ask.
+         * - Asked and denied once: Android reports a rationale and still shows the dialog. Ask again
+         *   only when the user just enabled uploads, not on every visit to the screen.
+         * - Asked and denied for good: Android answers "denied" by itself without showing anything,
+         *   so do not launch at all.
+         */
+        internal fun shouldRequest(
+            isGranted: Boolean,
+            alreadyRequested: Boolean,
+            shouldShowRationale: Boolean,
+            userInitiated: Boolean,
+        ): Boolean = !isGranted && (!alreadyRequested || (userInitiated && shouldShowRationale))
+    }
+}
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt
index e1b8a7d17a..54ef8cb99c 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt
@@ -93,6 +93,8 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
             picturesViewModel.handleSelectPictureUploadsSourcePath(contentUriForTree)
         }
 
+    private val mediaLocationPermissionRequester = MediaLocationPermissionRequester(this)
+
     override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
         setPreferencesFromResource(R.xml.settings_picture_uploads, rootKey)
 
@@ -149,6 +151,7 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
                         picturesViewModel.pictureUploads.collect { pictureUploadsConfiguration ->
                             enablePictureUploads(pictureUploadsConfiguration != null, false)
                             pictureUploadsConfiguration?.let {
+                                mediaLocationPermissionRequester.requestIfNeverAsked()
                                 prefPictureUploadsAccount?.value = it.accountName
                                 prefPictureUploadsPath?.summary = picturesViewModel.getUploadPathString()
                                 prefPictureUploadsSourcePath?.summary = DisplayUtils.getPathWithoutLastSlash(it.sourcePath.toUri().path)
@@ -170,10 +173,13 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
             val value = newValue as Boolean
 
             if (value) {
+                // Ask for the media location permission once this dialog is gone, not on top of it.
+                mediaLocationPermissionRequester.postpone()
                 picturesViewModel.enablePictureUploads(selectedAccount)
                 showAlertDialog(
                     title = getString(R.string.common_important),
-                    message = getString(R.string.proper_pics_folder_warning_camera_upload)
+                    message = getString(R.string.proper_pics_folder_warning_camera_upload),
+                    onDismissListener = { mediaLocationPermissionRequester.requestAfterEnabling() }
                 )
                 true
             } else {
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsVideoUploadsFragment.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsVideoUploadsFragment.kt
index 98b6dc0cfd..b1573caeed 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsVideoUploadsFragment.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsVideoUploadsFragment.kt
@@ -93,6 +93,8 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
             videosViewModel.handleSelectVideoUploadsSourcePath(contentUriForTree)
         }
 
+    private val mediaLocationPermissionRequester = MediaLocationPermissionRequester(this)
+
     override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
         setPreferencesFromResource(R.xml.settings_video_uploads, rootKey)
 
@@ -147,6 +149,7 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
                         videosViewModel.videoUploads.collect { videoUploadsConfiguration ->
                             enableVideoUploads(videoUploadsConfiguration != null, false)
                             videoUploadsConfiguration?.let {
+                                mediaLocationPermissionRequester.requestIfNeverAsked()
                                 prefVideoUploadsAccount?.value = it.accountName
                                 prefVideoUploadsPath?.summary = videosViewModel.getUploadPathString()
                                 prefVideoUploadsSourcePath?.summary = DisplayUtils.getPathWithoutLastSlash(it.sourcePath.toUri().path)
@@ -168,10 +171,13 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
             val value = newValue as Boolean
 
             if (value) {
+                // Ask for the media location permission once this dialog is gone, not on top of it.
+                mediaLocationPermissionRequester.postpone()
                 videosViewModel.enableVideoUploads(selectedAccount)
                 showAlertDialog(
                     title = getString(R.string.common_important),
-                    message = getString(R.string.proper_videos_folder_warning_camera_upload)
+                    message = getString(R.string.proper_videos_folder_warning_camera_upload),
+                    onDismissListener = { mediaLocationPermissionRequester.requestAfterEnabling() }
                 )
                 true
             } else {
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/ui/asynctasks/CopyAndUploadContentUrisTask.java b/opencloudApp/src/main/java/eu/opencloud/android/ui/asynctasks/CopyAndUploadContentUrisTask.java
index aee0a70d60..b16efee562 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/ui/asynctasks/CopyAndUploadContentUrisTask.java
+++ b/opencloudApp/src/main/java/eu/opencloud/android/ui/asynctasks/CopyAndUploadContentUrisTask.java
@@ -32,6 +32,7 @@
 import eu.opencloud.android.lib.common.operations.RemoteOperationResult.ResultCode;
 import eu.opencloud.android.usecases.transfers.uploads.UploadFilesFromSystemUseCase;
 import eu.opencloud.android.utils.FileStorageUtils;
+import eu.opencloud.android.utils.MediaLocationUtils;
 import eu.opencloud.android.utils.UriUtils;
 import kotlin.Lazy;
 import org.jetbrains.annotations.NotNull;
@@ -148,7 +149,7 @@ protected ResultCode doInBackground(Object[] params) {
                 currentRemotePath = uploadPath + UriUtils.getDisplayNameForUri(currentUri, mAppContext);
 
                 fullTempPath = FileStorageUtils.getTemporalPath(account.name, spaceId) + currentRemotePath;
-                inputStream = leakedContentResolver.openInputStream(currentUri);
+                inputStream = MediaLocationUtils.openInputStreamPreservingLocation(mAppContext, leakedContentResolver, currentUri);
                 File cacheFile = new File(fullTempPath);
                 File tempDir = cacheFile.getParentFile();
                 if (!tempDir.exists()) {
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/utils/MediaLocationUtils.kt b/opencloudApp/src/main/java/eu/opencloud/android/utils/MediaLocationUtils.kt
new file mode 100644
index 0000000000..b94d208a7a
--- /dev/null
+++ b/opencloudApp/src/main/java/eu/opencloud/android/utils/MediaLocationUtils.kt
@@ -0,0 +1,96 @@
+/**
+ * openCloud Android client application
+ *
+ * Copyright (C) 2026 OpenCloud GmbH.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.utils
+
+import android.Manifest
+import android.content.ContentResolver
+import android.content.Context
+import android.content.pm.PackageManager
+import android.net.Uri
+import android.os.Build
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import androidx.annotation.RequiresApi
+import androidx.core.content.ContextCompat
+import timber.log.Timber
+import java.io.InputStream
+
+/**
+ * Since Android 10 the system redacts location metadata (GPS EXIF) from photos and videos
+ * read through the media store or the storage access framework, unless the app holds
+ * [Manifest.permission.ACCESS_MEDIA_LOCATION] AND asks for the original via
+ * [MediaStore.setRequireOriginal]. Without this, uploads silently lose their location.
+ */
+object MediaLocationUtils {
+
+    @JvmStatic
+    fun isAccessMediaLocationGranted(context: Context): Boolean =
+        Build.VERSION.SDK_INT < Build.VERSION_CODES.Q || hasMediaLocationPermission(context)
+
+    /**
+     * Returns a URI that yields the unredacted original of [uri] (location metadata intact),
+     * or [uri] itself when that is not possible: older Android, permission not granted, or a
+     * content URI that has no media store counterpart (non-media documents, cloud providers...).
+     *
+     * SAF document URIs (what automatic uploads use) are translated to their media store URI
+     * with [MediaStore.getMediaUri]; access is granted through the same document grant.
+     */
+    @JvmStatic
+    fun getOriginalMediaUri(context: Context, uri: Uri): Uri =
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) getOriginalMediaUriApi29(context, uri) else uri
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    private fun hasMediaLocationPermission(context: Context): Boolean =
+        ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_MEDIA_LOCATION) == PackageManager.PERMISSION_GRANTED
+
+    @RequiresApi(Build.VERSION_CODES.Q)
+    private fun getOriginalMediaUriApi29(context: Context, uri: Uri): Uri {
+        if (!hasMediaLocationPermission(context)) return uri
+
+        val mediaUri: Uri = when {
+            uri.authority == MediaStore.AUTHORITY -> uri
+            DocumentsContract.isDocumentUri(context, uri) -> try {
+                MediaStore.getMediaUri(context, uri)
+            } catch (e: Exception) {
+                Timber.d(e, "No media store URI for %s, uploading it as is", uri)
+                null
+            } ?: return uri
+            else -> return uri
+        }
+        return MediaStore.setRequireOriginal(mediaUri)
+    }
+
+    /**
+     * Opens [uri] for reading, preferring the unredacted original (see [getOriginalMediaUri]).
+     * Falls back to opening [uri] directly if the original can't be opened, so an upload never
+     * fails because of the location metadata.
+     */
+    @JvmStatic
+    fun openInputStreamPreservingLocation(context: Context, contentResolver: ContentResolver, uri: Uri): InputStream? {
+        val originalUri = getOriginalMediaUri(context, uri)
+        if (originalUri != uri) {
+            try {
+                contentResolver.openInputStream(originalUri)?.let { return it }
+            } catch (e: Exception) {
+                Timber.w(e, "Could not open original media for %s, falling back to redacted copy", uri)
+            }
+        }
+        return contentResolver.openInputStream(uri)
+    }
+}
diff --git a/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromContentUriWorker.kt b/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromContentUriWorker.kt
index 661c9181c0..5569bfe5f9 100644
--- a/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromContentUriWorker.kt
+++ b/opencloudApp/src/main/java/eu/opencloud/android/workers/UploadFileFromContentUriWorker.kt
@@ -66,6 +66,7 @@ import eu.opencloud.android.lib.resources.files.ReadRemoteFileOperation
 import eu.opencloud.android.lib.resources.files.UploadFileFromFileSystemOperation
 import eu.opencloud.android.lib.resources.files.tus.TusChecksumHelper
 import eu.opencloud.android.presentation.authentication.AccountUtils
+import eu.opencloud.android.utils.MediaLocationUtils
 import eu.opencloud.android.utils.MimetypeIconUtil
 import eu.opencloud.android.utils.NotificationUtils
 import eu.opencloud.android.utils.UPLOAD_NOTIFICATION_CHANNEL_ID
@@ -251,7 +252,7 @@ class UploadFileFromContentUriWorker(
 
         // openInputStream can return null if the content provider is unavailable or permissions were revoked.
         // Failing here avoids silently uploading a 0-byte file.
-        val inputStream = appContext.contentResolver.openInputStream(contentUri)
+        val inputStream = MediaLocationUtils.openInputStreamPreservingLocation(appContext, appContext.contentResolver, contentUri)
         if (inputStream == null) {
             Timber.e("Failed to open input stream for %s — content provider unavailable or permissions revoked", contentUri)
             throw LocalFileNotFoundException()
@@ -395,7 +396,8 @@ class UploadFileFromContentUriWorker(
         }
         // Always have the whole-file checksum: TUS sends it in Upload-Metadata, plain PUTs
         // in the OC-Checksum header. Usually already persisted by copyFileToLocalStorage;
-        // this only reads the source again for cache-reuse runs of pre-checksum DB rows.
+        // this only hashes the cached copy again when it is reused without a stored checksum
+        // (pre-checksum DB rows, or TUS state cleared after a failed attempt).
         ensureOriginalTusChecksum()
 
         if (shouldTryTus) {
@@ -515,13 +517,16 @@ class UploadFileFromContentUriWorker(
     private fun ensureOriginalTusChecksum() {
         if (hasStoredSha1Checksum()) return
 
-        val inputStream = appContext.contentResolver.openInputStream(contentUri)
-        if (inputStream == null) {
-            Timber.e("Failed to open input stream for checksum source %s", contentUri)
+        // Hash the cached copy, not the content URI: the cache holds the bytes that are actually
+        // uploaded, and a second read of the source is not guaranteed to match them (the system
+        // redacts location metadata unless the unredacted original is requested and readable).
+        val cacheFile = File(cachePath)
+        if (!cacheFile.exists()) {
+            Timber.e("Cached upload file %s is missing, cannot compute its checksum", cachePath)
             throw LocalFileNotFoundException()
         }
 
-        val sha1Hex = inputStream.use { input ->
+        val sha1Hex = cacheFile.inputStream().use { input ->
             TusChecksumHelper.sha1Hex(input)
         }
         persistTusChecksum(sha1Hex)
diff --git a/opencloudApp/src/main/res/values/strings.xml b/opencloudApp/src/main/res/values/strings.xml
index 54d8a8894c..10b8353059 100644
--- a/opencloudApp/src/main/res/values/strings.xml
+++ b/opencloudApp/src/main/res/values/strings.xml
@@ -595,6 +595,7 @@
     <string name="prefs_camera_upload_behaviour_title">Original file will be</string>
     <string name="prefs_camera_upload_last_sync_title">Last synchronization</string>
     <string name="notifications_permission_denied">You can update your preferences in Settings</string>
+    <string name="media_location_permission_denied">Without location access, uploaded photos and videos will lose their GPS location. You can grant it in Settings.</string>
     <string name="upload_copy_files">Copy file</string>
     <string name="upload_move_files">Move file</string>
 
diff --git a/opencloudApp/src/test/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequesterTest.kt b/opencloudApp/src/test/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequesterTest.kt
new file mode 100644
index 0000000000..625cae30c2
--- /dev/null
+++ b/opencloudApp/src/test/java/eu/opencloud/android/presentation/settings/automaticuploads/MediaLocationPermissionRequesterTest.kt
@@ -0,0 +1,60 @@
+/**
+ * openCloud Android client application
+ *
+ * Copyright (C) 2026 OpenCloud GmbH.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.presentation.settings.automaticuploads
+
+import eu.opencloud.android.presentation.settings.automaticuploads.MediaLocationPermissionRequester.Companion.shouldRequest
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class MediaLocationPermissionRequesterTest {
+
+    @Test
+    fun `never requests when the permission is already granted`() {
+        for (alreadyRequested in listOf(false, true)) {
+            for (shouldShowRationale in listOf(false, true)) {
+                for (userInitiated in listOf(false, true)) {
+                    assertFalse(shouldRequest(isGranted = true, alreadyRequested, shouldShowRationale, userInitiated))
+                }
+            }
+        }
+    }
+
+    @Test
+    fun `requests the first time, whether the screen was opened or uploads were just enabled`() {
+        assertTrue(shouldRequest(isGranted = false, alreadyRequested = false, shouldShowRationale = false, userInitiated = false))
+        assertTrue(shouldRequest(isGranted = false, alreadyRequested = false, shouldShowRationale = false, userInitiated = true))
+    }
+
+    @Test
+    fun `does not request again on later visits to the screen`() {
+        assertFalse(shouldRequest(isGranted = false, alreadyRequested = true, shouldShowRationale = true, userInitiated = false))
+        assertFalse(shouldRequest(isGranted = false, alreadyRequested = true, shouldShowRationale = false, userInitiated = false))
+    }
+
+    @Test
+    fun `requests again after one denial when the user enables uploads`() {
+        assertTrue(shouldRequest(isGranted = false, alreadyRequested = true, shouldShowRationale = true, userInitiated = true))
+    }
+
+    @Test
+    fun `does not request once the system denies without showing the dialog`() {
+        assertFalse(shouldRequest(isGranted = false, alreadyRequested = true, shouldShowRationale = false, userInitiated = true))
+    }
+}
diff --git a/opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt b/opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt
new file mode 100644
index 0000000000..0505013209
--- /dev/null
+++ b/opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt
@@ -0,0 +1,222 @@
+/**
+ * openCloud Android client application
+ *
+ * Copyright (C) 2026 OpenCloud GmbH.
+ *
+ * This program is free software: you can redistribute it and/or modify
+ * it under the terms of the GNU General Public License version 2,
+ * as published by the Free Software Foundation.
+ *
+ * This program is distributed in the hope that it will be useful,
+ * but WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+ * GNU General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ */
+
+package eu.opencloud.android.utils
+
+import android.Manifest
+import android.app.Application
+import android.content.ContentResolver
+import android.net.Uri
+import android.provider.DocumentsContract
+import android.provider.MediaStore
+import androidx.test.core.app.ApplicationProvider
+import io.mockk.every
+import io.mockk.mockk
+import io.mockk.mockkStatic
+import io.mockk.unmockkAll
+import io.mockk.verify
+import org.junit.After
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertSame
+import org.junit.Assert.assertTrue
+import org.junit.Test
+import org.junit.runner.RunWith
+import org.robolectric.RobolectricTestRunner
+import org.robolectric.Shadows.shadowOf
+import org.robolectric.annotation.Config
+import java.io.ByteArrayInputStream
+import java.io.FileNotFoundException
+import java.io.InputStream
+
+@RunWith(RobolectricTestRunner::class)
+@Config(manifest = Config.NONE)
+class MediaLocationUtilsTest {
+
+    private val context: Application = ApplicationProvider.getApplicationContext()
+    private val mediaStoreUri: Uri = Uri.parse("content://${MediaStore.AUTHORITY}/external/images/media/42")
+    private val otherProviderUri: Uri = Uri.parse("content://com.example.provider/files/42")
+
+    // What automatic uploads read: a document inside the tree picked with the storage access framework.
+    private val safDocumentUri: Uri = Uri.parse(
+        "content://com.android.externalstorage.documents/tree/primary%3ADCIM/document/primary%3ADCIM%2FCamera%2FIMG_42.jpg"
+    )
+    private val originalMediaStoreUri: Uri by lazy { MediaStore.setRequireOriginal(mediaStoreUri) } // API >= 29 only
+
+    private val contentResolver: ContentResolver = mockk()
+    private val redactedStream: InputStream = ByteArrayInputStream(byteArrayOf(1))
+    private val originalStream: InputStream = ByteArrayInputStream(byteArrayOf(2))
+
+    @After
+    fun tearDown() {
+        unmockkAll()
+    }
+
+    private fun mockSafDocument(answerGetMediaUri: () -> Uri?) {
+        mockkStatic(DocumentsContract::class)
+        mockkStatic(MediaStore::class)
+        every { DocumentsContract.isDocumentUri(any(), safDocumentUri) } returns true
+        every { MediaStore.getMediaUri(any(), safDocumentUri) } answers { answerGetMediaUri() }
+    }
+
+    private fun grantMediaLocationPermission() {
+        shadowOf(context).grantPermissions(Manifest.permission.ACCESS_MEDIA_LOCATION)
+    }
+
+    @Test
+    @Config(sdk = [28])
+    fun permission_is_implicitly_granted_below_android_10() {
+        assertTrue(MediaLocationUtils.isAccessMediaLocationGranted(context))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun permission_is_not_granted_by_default_on_android_10() {
+        assertFalse(MediaLocationUtils.isAccessMediaLocationGranted(context))
+    }
+
+    @Test
+    @Config(sdk = [28])
+    fun original_uri_is_untouched_below_android_10() {
+        assertEquals(mediaStoreUri, MediaLocationUtils.getOriginalMediaUri(context, mediaStoreUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun original_uri_is_untouched_without_permission() {
+        assertEquals(mediaStoreUri, MediaLocationUtils.getOriginalMediaUri(context, mediaStoreUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun media_store_uri_requires_original_when_permission_granted() {
+        grantMediaLocationPermission()
+
+        val originalUri = MediaLocationUtils.getOriginalMediaUri(context, mediaStoreUri)
+
+        assertEquals(MediaStore.setRequireOriginal(mediaStoreUri), originalUri)
+        assertEquals("1", originalUri.getQueryParameter("requireOriginal"))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun non_media_uri_is_untouched_even_with_permission() {
+        grantMediaLocationPermission()
+
+        assertEquals(otherProviderUri, MediaLocationUtils.getOriginalMediaUri(context, otherProviderUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun saf_document_uri_is_translated_to_the_original_media_store_uri() {
+        grantMediaLocationPermission()
+        mockSafDocument { mediaStoreUri }
+
+        assertEquals(originalMediaStoreUri, MediaLocationUtils.getOriginalMediaUri(context, safDocumentUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun saf_document_uri_is_not_translated_without_permission() {
+        mockSafDocument { mediaStoreUri }
+
+        assertEquals(safDocumentUri, MediaLocationUtils.getOriginalMediaUri(context, safDocumentUri))
+        verify(exactly = 0) { MediaStore.getMediaUri(any(), any()) }
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun saf_document_uri_is_untouched_when_get_media_uri_throws() {
+        grantMediaLocationPermission()
+        mockSafDocument { throw IllegalArgumentException("Provider does not support media URIs") }
+
+        assertEquals(safDocumentUri, MediaLocationUtils.getOriginalMediaUri(context, safDocumentUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun saf_document_uri_is_untouched_when_it_has_no_media_store_counterpart() {
+        grantMediaLocationPermission()
+        mockSafDocument { null }
+
+        assertEquals(safDocumentUri, MediaLocationUtils.getOriginalMediaUri(context, safDocumentUri))
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun open_returns_the_original_when_it_can_be_opened() {
+        grantMediaLocationPermission()
+        mockSafDocument { mediaStoreUri }
+        every { contentResolver.openInputStream(originalMediaStoreUri) } returns originalStream
+
+        val stream = MediaLocationUtils.openInputStreamPreservingLocation(context, contentResolver, safDocumentUri)
+
+        assertSame(originalStream, stream)
+        verify(exactly = 0) { contentResolver.openInputStream(safDocumentUri) }
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun open_falls_back_to_the_given_uri_when_opening_the_original_throws() {
+        grantMediaLocationPermission()
+        mockSafDocument { mediaStoreUri }
+        every { contentResolver.openInputStream(originalMediaStoreUri) } throws SecurityException("No access to the original")
+        every { contentResolver.openInputStream(safDocumentUri) } returns redactedStream
+
+        val stream = MediaLocationUtils.openInputStreamPreservingLocation(context, contentResolver, safDocumentUri)
+
+        assertSame(redactedStream, stream)
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun open_falls_back_to_the_given_uri_when_the_original_is_not_found() {
+        grantMediaLocationPermission()
+        mockSafDocument { mediaStoreUri }
+        every { contentResolver.openInputStream(originalMediaStoreUri) } throws FileNotFoundException()
+        every { contentResolver.openInputStream(safDocumentUri) } returns redactedStream
+
+        val stream = MediaLocationUtils.openInputStreamPreservingLocation(context, contentResolver, safDocumentUri)
+
+        assertSame(redactedStream, stream)
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun open_falls_back_to_the_given_uri_when_opening_the_original_returns_null() {
+        grantMediaLocationPermission()
+        mockSafDocument { mediaStoreUri }
+        every { contentResolver.openInputStream(originalMediaStoreUri) } returns null
+        every { contentResolver.openInputStream(safDocumentUri) } returns redactedStream
+
+        val stream = MediaLocationUtils.openInputStreamPreservingLocation(context, contentResolver, safDocumentUri)
+
+        assertSame(redactedStream, stream)
+    }
+
+    @Test
+    @Config(sdk = [29])
+    fun open_reads_the_given_uri_directly_without_permission() {
+        every { contentResolver.openInputStream(mediaStoreUri) } returns redactedStream
+
+        val stream = MediaLocationUtils.openInputStreamPreservingLocation(context, contentResolver, mediaStoreUri)
+
+        assertSame(redactedStream, stream)
+        verify(exactly = 1) { contentResolver.openInputStream(any()) }
+    }
+}