From acd84de03da66680408c10a3b8d5ee2fac937420 Mon Sep 17 00:00:00 2001
From: bluecasita <154034577+bluecasita@users.noreply.github.com>
Date: Thu, 24 Sep 2026 21:38:16 -0500
Subject: [PATCH] fix: preserve GPS metadata in uploaded photos and videos

Since Android 10 the system redacts location EXIF from media read through
the media store or SAF unless the app holds ACCESS_MEDIA_LOCATION and asks
for the original with MediaStore.setRequireOriginal(). The app never
declared the permission, so automatic uploads (and uploads of shared or
picked media) lost their GPS tags while the rest of the EXIF survived.

- declare ACCESS_MEDIA_LOCATION in the manifest
- request it only from the picture/video automatic-uploads settings, when
  uploads are enabled (not on app start), with a snackbar on denial
- add MediaLocationUtils to resolve a content URI to its unredacted
  original (media store URIs directly, SAF document URIs via
  MediaStore.getMediaUri) and use it where upload sources are read:
  UploadFileFromContentUriWorker and CopyAndUploadContentUrisTask; any
  failure falls back to the previous behaviour
- Robolectric tests for MediaLocationUtils

Fixes #218

Co-Authored-By: Claude Fable 5.1 <noreply@anthropic.com>
---
 opencloudApp/src/main/AndroidManifest.xml     |  6 ++
 .../SettingsPictureUploadsFragment.kt         | 21 +++++
 .../SettingsVideoUploadsFragment.kt           | 21 +++++
 .../CopyAndUploadContentUrisTask.java         |  3 +-
 .../android/utils/MediaLocationUtils.kt       | 90 +++++++++++++++++++
 .../workers/UploadFileFromContentUriWorker.kt |  3 +-
 opencloudApp/src/main/res/values/strings.xml  |  1 +
 .../android/utils/MediaLocationUtilsTest.kt   | 89 ++++++++++++++++++
 8 files changed, 232 insertions(+), 2 deletions(-)
 create mode 100644 opencloudApp/src/main/java/eu/opencloud/android/utils/MediaLocationUtils.kt
 create mode 100644 opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt

diff --git a/opencloudApp/src/main/AndroidManifest.xml b/opencloudApp/src/main/AndroidManifest.xml
index 38c990ad1a..1ac899e3f2 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/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt b/opencloudApp/src/main/java/eu/opencloud/android/presentation/settings/automaticuploads/SettingsPictureUploadsFragment.kt
index e1b8a7d17a..0df9619216 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
@@ -22,6 +22,7 @@
 
 package eu.opencloud.android.presentation.settings.automaticuploads
 
+import android.Manifest
 import android.app.Activity
 import android.content.DialogInterface
 import android.content.Intent
@@ -55,6 +56,7 @@ import eu.opencloud.android.extensions.showMessageInSnackbar
 import eu.opencloud.android.presentation.accounts.ManageAccountsViewModel
 import eu.opencloud.android.ui.activity.FolderPickerActivity
 import eu.opencloud.android.utils.DisplayUtils
+import eu.opencloud.android.utils.MediaLocationUtils
 import kotlinx.coroutines.launch
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import java.io.File
@@ -93,6 +95,22 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
             picturesViewModel.handleSelectPictureUploadsSourcePath(contentUriForTree)
         }
 
+    // Without ACCESS_MEDIA_LOCATION, Android strips GPS EXIF from the pictures we read (API >= 29).
+    // Asked only here, when picture uploads are enabled, not on app start.
+    private var mediaLocationPermissionRequested = false
+    private val requestMediaLocationPermissionLauncher =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
+            if (!isGranted) {
+                showMessageInSnackbar(getString(R.string.media_location_permission_denied))
+            }
+        }
+
+    private fun requestMediaLocationPermissionIfNeeded() {
+        if (mediaLocationPermissionRequested || MediaLocationUtils.isAccessMediaLocationGranted(requireContext())) return
+        mediaLocationPermissionRequested = true
+        requestMediaLocationPermissionLauncher.launch(Manifest.permission.ACCESS_MEDIA_LOCATION)
+    }
+
     override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
         setPreferencesFromResource(R.xml.settings_picture_uploads, rootKey)
 
@@ -149,6 +167,7 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
                         picturesViewModel.pictureUploads.collect { pictureUploadsConfiguration ->
                             enablePictureUploads(pictureUploadsConfiguration != null, false)
                             pictureUploadsConfiguration?.let {
+                                requestMediaLocationPermissionIfNeeded()
                                 prefPictureUploadsAccount?.value = it.accountName
                                 prefPictureUploadsPath?.summary = picturesViewModel.getUploadPathString()
                                 prefPictureUploadsSourcePath?.summary = DisplayUtils.getPathWithoutLastSlash(it.sourcePath.toUri().path)
@@ -171,6 +190,8 @@ class SettingsPictureUploadsFragment : PreferenceFragmentCompat() {
 
             if (value) {
                 picturesViewModel.enablePictureUploads(selectedAccount)
+                mediaLocationPermissionRequested = false
+                requestMediaLocationPermissionIfNeeded()
                 showAlertDialog(
                     title = getString(R.string.common_important),
                     message = getString(R.string.proper_pics_folder_warning_camera_upload)
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..997c1af501 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
@@ -22,6 +22,7 @@
 
 package eu.opencloud.android.presentation.settings.automaticuploads
 
+import android.Manifest
 import android.app.Activity
 import android.content.DialogInterface
 import android.content.Intent
@@ -55,6 +56,7 @@ import eu.opencloud.android.extensions.showMessageInSnackbar
 import eu.opencloud.android.presentation.accounts.ManageAccountsViewModel
 import eu.opencloud.android.ui.activity.FolderPickerActivity
 import eu.opencloud.android.utils.DisplayUtils
+import eu.opencloud.android.utils.MediaLocationUtils
 import kotlinx.coroutines.launch
 import org.koin.androidx.viewmodel.ext.android.viewModel
 import java.io.File
@@ -93,6 +95,22 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
             videosViewModel.handleSelectVideoUploadsSourcePath(contentUriForTree)
         }
 
+    // Without ACCESS_MEDIA_LOCATION, Android strips GPS metadata from the videos we read (API >= 29).
+    // Asked only here, when video uploads are enabled, not on app start.
+    private var mediaLocationPermissionRequested = false
+    private val requestMediaLocationPermissionLauncher =
+        registerForActivityResult(ActivityResultContracts.RequestPermission()) { isGranted ->
+            if (!isGranted) {
+                showMessageInSnackbar(getString(R.string.media_location_permission_denied))
+            }
+        }
+
+    private fun requestMediaLocationPermissionIfNeeded() {
+        if (mediaLocationPermissionRequested || MediaLocationUtils.isAccessMediaLocationGranted(requireContext())) return
+        mediaLocationPermissionRequested = true
+        requestMediaLocationPermissionLauncher.launch(Manifest.permission.ACCESS_MEDIA_LOCATION)
+    }
+
     override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
         setPreferencesFromResource(R.xml.settings_video_uploads, rootKey)
 
@@ -147,6 +165,7 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
                         videosViewModel.videoUploads.collect { videoUploadsConfiguration ->
                             enableVideoUploads(videoUploadsConfiguration != null, false)
                             videoUploadsConfiguration?.let {
+                                requestMediaLocationPermissionIfNeeded()
                                 prefVideoUploadsAccount?.value = it.accountName
                                 prefVideoUploadsPath?.summary = videosViewModel.getUploadPathString()
                                 prefVideoUploadsSourcePath?.summary = DisplayUtils.getPathWithoutLastSlash(it.sourcePath.toUri().path)
@@ -169,6 +188,8 @@ class SettingsVideoUploadsFragment : PreferenceFragmentCompat() {
 
             if (value) {
                 videosViewModel.enableVideoUploads(selectedAccount)
+                mediaLocationPermissionRequested = false
+                requestMediaLocationPermissionIfNeeded()
                 showAlertDialog(
                     title = getString(R.string.common_important),
                     message = getString(R.string.proper_videos_folder_warning_camera_upload)
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..f10f9dffb0
--- /dev/null
+++ b/opencloudApp/src/main/java/eu/opencloud/android/utils/MediaLocationUtils.kt
@@ -0,0 +1,90 @@
+/**
+ * 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.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 ||
+                ContextCompat.checkSelfPermission(context, Manifest.permission.ACCESS_MEDIA_LOCATION) ==
+                PackageManager.PERMISSION_GRANTED
+
+    /**
+     * 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 || !isAccessMediaLocationGranted(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..6e81e523aa 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()
diff --git a/opencloudApp/src/main/res/values/strings.xml b/opencloudApp/src/main/res/values/strings.xml
index 0a4de8366d..b5f6b1cb5c 100644
--- a/opencloudApp/src/main/res/values/strings.xml
+++ b/opencloudApp/src/main/res/values/strings.xml
@@ -591,6 +591,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/utils/MediaLocationUtilsTest.kt b/opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt
new file mode 100644
index 0000000000..cdcbcd3eed
--- /dev/null
+++ b/opencloudApp/src/test/java/eu/opencloud/android/utils/MediaLocationUtilsTest.kt
@@ -0,0 +1,89 @@
+/**
+ * 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.net.Uri
+import android.provider.MediaStore
+import androidx.test.core.app.ApplicationProvider
+import org.junit.Assert.assertEquals
+import org.junit.Assert.assertFalse
+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
+
+@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")
+
+    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))
+    }
+}