5196: Fix in-app camera location loss

app/src/main/java/fr/free/nrw/commons/contributions/ContributionController.java

@@ -3,18 +3,24 @@
 import static fr.free.nrw.commons.wikidata.WikidataConstants.PLACE_OBJECT;
 
 import android.Manifest;
+import android.Manifest.permission;
 import android.app.Activity;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.provider.Settings;
 import androidx.annotation.NonNull;
 import fr.free.nrw.commons.R;
 import fr.free.nrw.commons.filepicker.DefaultCallback;
 import fr.free.nrw.commons.filepicker.FilePicker;
 import fr.free.nrw.commons.filepicker.FilePicker.ImageSource;
 import fr.free.nrw.commons.filepicker.UploadableFile;
 import fr.free.nrw.commons.kvstore.JsonKvStore;
+import fr.free.nrw.commons.location.LatLng;
+import fr.free.nrw.commons.location.LocationServiceManager;
 import fr.free.nrw.commons.nearby.Place;
 import fr.free.nrw.commons.upload.UploadActivity;
+import fr.free.nrw.commons.utils.DialogUtil;
 import fr.free.nrw.commons.utils.PermissionUtils;
 import fr.free.nrw.commons.utils.ViewUtil;
 import java.util.ArrayList;
@@ -28,7 +34,10 @@ public class ContributionController {
 
     public static final String ACTION_INTERNAL_UPLOADS = "internalImageUploads";
     private final JsonKvStore defaultKvStore;
+    private LatLng locationBeforeImageCapture;
 
+    @Inject
+    LocationServiceManager locationManager;
     @Inject
     public ContributionController(@Named("default_preferences") JsonKvStore defaultKvStore) {
         this.defaultKvStore = defaultKvStore;
@@ -46,11 +55,112 @@ public void initiateCameraPick(Activity activity) {
 
         PermissionUtils.checkPermissionsAndPerformAction(activity,
                 Manifest.permission.WRITE_EXTERNAL_STORAGE,
-                () -> initiateCameraUpload(activity),
+                () -> {
+                    if (!(PermissionUtils.hasPermission(activity, Manifest.permission.ACCESS_FINE_LOCATION)
+                         && isLocationAccessToAppsTurnedOn())) {
+                        askUserToAllowLocationAccess(activity);
+                    } else {
+                        initiateCameraUpload(activity);
+                    }
+                },
                 R.string.storage_permission_title,
                 R.string.write_storage_permission_rationale);
     }
 
+    /**
+     * Suggest user to attach location information with pictures.
+     * If the user selects "Yes", then:
+     *
+     * Location is taken from the EXIF if the default camera application
+     * does not redact location tags.
+     *
+     * Otherwise, if the EXIF metadata does not have location information,
+     * then location captured by the app is used
+     *
+     * @param activity
+     */
+    private void askUserToAllowLocationAccess(Activity activity) {
+        DialogUtil.showAlertDialog(activity,
+            activity.getString(R.string.location_permission_title),
+            activity.getString(R.string.in_app_camera_location_access_explanation),
+            activity.getString(R.string.option_allow),
+            activity.getString(R.string.option_dismiss),
+            ()-> requestForLocationAccess(activity),
+            () -> initiateCameraUpload(activity),
+            null,
+            true);
+    }
+
+    /**
+     * Ask for location permission if the user agrees on attaching location with pictures
+     * and the app does not have the access to location
+     *
+     * @param activity
+     */
+
+    private void requestForLocationAccess(Activity activity) {
+        PermissionUtils.checkPermissionsAndPerformAction(activity,
+            permission.ACCESS_FINE_LOCATION,
+            () -> onLocationPermissionGranted(activity),
+            () -> {},
+            R.string.ask_to_turn_location_on,
+            R.string.in_app_camera_location_permission_rationale);
+    }
+
+    /**
+     * Check if apps have access to location even after having individual access
+     *
+     * @return
+     */
+    private boolean isLocationAccessToAppsTurnedOn() {
+        return (locationManager.isNetworkProviderEnabled() || locationManager.isGPSProviderEnabled());
+    }
+
+    /**
+     * Initiate in-app camera if apps have access to location.
+     * Otherwise, show location-off dialog.
+     *
+     * @param activity
+     */
+    private void onLocationPermissionGranted(Activity activity) {
+        if (!isLocationAccessToAppsTurnedOn()) {
+            showLocationOffDialog(activity);
+        } else {
+            initiateCameraUpload(activity);
+        }
+    }
+
+    /**
+     * Ask user to grant location access to apps
+     *
+     * @param activity
+     */
+
+    private void showLocationOffDialog(Activity activity) {
+        DialogUtil
+            .showAlertDialog(activity,
+                activity.getString(R.string.location_permission_title),
+                activity.getString(R.string.in_app_camera_needs_location),
+                activity.getString(R.string.title_app_shortcut_setting),
+                () -> openLocationSettings(activity),
+                true);
+    }
+
+    /**
+     * Open location source settings so that apps with location access can access it
+     *
+     * @param activity
+     */
+
+    private void openLocationSettings(Activity activity) {
+        final Intent intent = new Intent(Settings.ACTION_LOCATION_SOURCE_SETTINGS);
+        final PackageManager packageManager = activity.getPackageManager();
+
+        if (intent.resolveActivity(packageManager)!= null) {
+            activity.startActivity(intent);
+        }
+    }
+
     /**
      * Initiate gallery picker
      */
@@ -99,6 +209,7 @@ private void setPickerConfiguration(Activity activity,
      */
     private void initiateCameraUpload(Activity activity) {
         setPickerConfiguration(activity, false);
+        locationBeforeImageCapture = locationManager.getLastLocation();
         FilePicker.openCameraForImage(activity, 0);
     }
 
@@ -134,7 +245,8 @@ public List<UploadableFile> handleExternalImagesPicked(Activity activity,
 
     /**
      * Returns intent to be passed to upload activity
-     * Attaches place object for nearby uploads
+     * Attaches place object for nearby uploads and
+     * location before image capture if in-app camera is used
      */
     private Intent handleImagesPicked(Context context,
         List<UploadableFile> imagesFiles) {
@@ -148,6 +260,12 @@ private Intent handleImagesPicked(Context context,
             shareIntent.putExtra(PLACE_OBJECT, place);
         }
 
+        if (locationBeforeImageCapture != null) {
+            shareIntent.putExtra(
+                UploadActivity.LOCATION_BEFORE_IMAGE_CAPTURE,
+                locationBeforeImageCapture);
+        }
+
         return shareIntent;
     }
 

app/src/main/java/fr/free/nrw/commons/repository/UploadRepository.java

@@ -188,9 +188,9 @@ public int getCount() {
      * @return
      */
     public Observable<UploadItem> preProcessImage(UploadableFile uploadableFile, Place place,
-        SimilarImageInterface similarImageInterface) {
+        SimilarImageInterface similarImageInterface, LatLng location) {
         return uploadModel.preProcessImage(uploadableFile, place,
-            similarImageInterface);
+            similarImageInterface, location);
     }
 
     /**
@@ -199,8 +199,8 @@ public Observable<UploadItem> preProcessImage(UploadableFile uploadableFile, Pla
      * @param uploadItem
      * @return
      */
-    public Single<Integer> getImageQuality(UploadItem uploadItem) {
-        return uploadModel.getImageQuality(uploadItem);
+    public Single<Integer> getImageQuality(UploadItem uploadItem, LatLng location) {
+        return uploadModel.getImageQuality(uploadItem, location);
     }
 
     /**

app/src/main/java/fr/free/nrw/commons/upload/FileProcessor.kt

@@ -6,6 +6,7 @@ import android.net.Uri
 import androidx.exifinterface.media.ExifInterface
 import fr.free.nrw.commons.R
 import fr.free.nrw.commons.kvstore.JsonKvStore
+import fr.free.nrw.commons.location.LatLng
 import fr.free.nrw.commons.mwapi.CategoryApi
 import fr.free.nrw.commons.mwapi.OkHttpJsonApiClient
 import fr.free.nrw.commons.settings.Prefs
@@ -48,7 +49,8 @@ class FileProcessor @Inject constructor(
     /**
      * Processes filePath coordinates, either from EXIF data or user location
      */
-    fun processFileCoordinates(similarImageInterface: SimilarImageInterface, filePath: String?)
+    fun processFileCoordinates(similarImageInterface: SimilarImageInterface,
+                               filePath: String?, location: LatLng?)
             : ImageCoordinates {
         val exifInterface: ExifInterface? = try {
             ExifInterface(filePath!!)
@@ -59,7 +61,7 @@ class FileProcessor @Inject constructor(
         // Redact EXIF data as indicated in preferences.
         redactExifTags(exifInterface, getExifTagsToRedact())
         Timber.d("Calling GPSExtractor")
-        val originalImageCoordinates = ImageCoordinates(exifInterface)
+        val originalImageCoordinates = ImageCoordinates(exifInterface, location)
         if (originalImageCoordinates.decimalCoords == null) {
             //Find other photos taken around the same time which has gps coordinates
             findOtherImages(
@@ -82,6 +84,13 @@ class FileProcessor @Inject constructor(
             defaultKvStore.getStringSet(Prefs.MANAGED_EXIF_TAGS) ?: emptySet()
         val redactTags: Set<String> =
             context.resources.getStringArray(R.array.pref_exifTag_values).toSet()
+        // This will be useful when implementing https://github.com/commons-app/apps-android-commons/issues/5247
+        /* Remove EXIF location if user has chosen
+           "No, do not attach location" while using in-app camera */
+        /*if (!defaultKvStore.getBoolean("locationInfoPref")) {
+            val locationTag: String = context.getString(R.string.exif_tag_location)
+            return redactTags - prefManageEXIFTags.minus(locationTag)
+        }*/
         return redactTags - prefManageEXIFTags
     }
 
@@ -156,11 +165,13 @@ class FileProcessor @Inject constructor(
 
     private fun readImageCoordinates(file: File) =
         try {
-            ImageCoordinates(contentResolver.openInputStream(Uri.fromFile(file))!!)
+            /* Used null location as location for similar images captured before is not available
+               in case it is not present in the EXIF. */
+            ImageCoordinates(contentResolver.openInputStream(Uri.fromFile(file))!!, null)
         } catch (e: IOException) {
             Timber.e(e)
             try {
-                ImageCoordinates(file.absolutePath)
+                ImageCoordinates(file.absolutePath, null)
             } catch (ex: IOException) {
                 Timber.e(ex)
                 null

app/src/main/java/fr/free/nrw/commons/upload/FileUtils.java

@@ -7,6 +7,7 @@
 
 import androidx.exifinterface.media.ExifInterface;
 
+import fr.free.nrw.commons.location.LatLng;
 import java.io.BufferedReader;
 import java.io.File;
 import java.io.FileInputStream;
@@ -64,11 +65,11 @@ static String getSHA1(InputStream is) {
     /**
      * Get Geolocation of filePath from input filePath path
      */
-    static String getGeolocationOfFile(String filePath) {
+    static String getGeolocationOfFile(String filePath, LatLng location) {
 
         try {
             ExifInterface exifInterface = new ExifInterface(filePath);
-            ImageCoordinates imageObj = new ImageCoordinates(exifInterface);
+            ImageCoordinates imageObj = new ImageCoordinates(exifInterface, location);
             if (imageObj.getDecimalCoords() != null) { // If image has geolocation information in its EXIF
                 return imageObj.getDecimalCoords();
             } else {

app/src/main/java/fr/free/nrw/commons/upload/FileUtilsWrapper.java

@@ -1,6 +1,7 @@
 package fr.free.nrw.commons.upload;
 
 import android.content.Context;
+import fr.free.nrw.commons.location.LatLng;
 import io.reactivex.Observable;
 import java.io.BufferedInputStream;
 import java.io.File;
@@ -37,8 +38,8 @@ public FileInputStream getFileInputStream(String filePath) throws FileNotFoundEx
         return FileUtils.getFileInputStream(filePath);
     }
 
-    public String getGeolocationOfFile(String filePath) {
-        return FileUtils.getGeolocationOfFile(filePath);
+    public String getGeolocationOfFile(String filePath, LatLng location) {
+        return FileUtils.getGeolocationOfFile(filePath, location);
     }
 
 

app/src/main/java/fr/free/nrw/commons/upload/ImageCoordinates.kt

@@ -9,8 +9,10 @@ import java.io.InputStream
 /**
  * Extracts geolocation to be passed to API for category suggestions. If a picture with geolocation
  * is uploaded, extract latitude and longitude from EXIF data of image.
+ * Otherwise, if current user location is available while using the in-app camera,
+ * use it to set image coordinates
  */
-class ImageCoordinates internal constructor(exif: ExifInterface?) {
+class ImageCoordinates internal constructor(exif: ExifInterface?, location: LatLng?) {
     var decLatitude = 0.0
     var decLongitude = 0.0
     var imageCoordsExists = false
@@ -26,13 +28,13 @@ class ImageCoordinates internal constructor(exif: ExifInterface?) {
     /**
      * Construct from a stream.
      */
-    internal constructor(stream: InputStream) : this(ExifInterface(stream))
+    internal constructor(stream: InputStream, location: LatLng?) : this(ExifInterface(stream), location)
     /**
      * Construct from the file path of the image.
      * @param path file path of the image
      */
     @Throws(IOException::class)
-    internal constructor(path: String) : this(ExifInterface(path))
+    internal constructor(path: String, location: LatLng?) : this(ExifInterface(path), location)
 
     init {
         //If image has no EXIF data and user has enabled GPS setting, get user's location
@@ -61,6 +63,14 @@ class ImageCoordinates internal constructor(exif: ExifInterface?) {
                 //If image has EXIF data, extract image coords
                 imageCoordsExists = true
                 Timber.d("EXIF data has location info")
+            } else if (location != null) {
+                decLatitude = location.latitude
+                decLongitude = location.longitude
+                if (!(decLatitude == 0.0 && decLongitude == 0.0)) {
+                    decimalCoords = "$decLatitude|$decLongitude"
+                    imageCoordsExists = true
+                    Timber.d("Image coordinates recorded while using in-app camera")
+                }
             }
         }
     }

app/src/main/java/fr/free/nrw/commons/upload/ImageProcessingService.java

@@ -5,6 +5,7 @@
 import static fr.free.nrw.commons.utils.ImageUtils.IMAGE_OK;
 
 import android.content.Context;
+import fr.free.nrw.commons.location.LatLng;
 import fr.free.nrw.commons.media.MediaClient;
 import fr.free.nrw.commons.nearby.Place;
 import fr.free.nrw.commons.utils.ImageUtils;
@@ -46,7 +47,7 @@ public ImageProcessingService(FileUtilsWrapper fileUtilsWrapper,
      * Check image quality before upload - checks duplicate image - checks dark image - checks
      * geolocation for image - check for valid title
      */
-    Single<Integer> validateImage(UploadItem uploadItem) {
+    Single<Integer> validateImage(UploadItem uploadItem, LatLng location) {
         int currentImageQuality = uploadItem.getImageQuality();
         Timber.d("Current image quality is %d", currentImageQuality);
         if (currentImageQuality == ImageUtils.IMAGE_KEEP) {
@@ -57,7 +58,7 @@ Single<Integer> validateImage(UploadItem uploadItem) {
 
         return Single.zip(
             checkDuplicateImage(filePath),
-            checkImageGeoLocation(uploadItem.getPlace(), filePath),
+            checkImageGeoLocation(uploadItem.getPlace(), filePath, location),
             checkDarkImage(filePath),
             validateItemTitle(uploadItem),
             checkFBMD(filePath),
@@ -148,13 +149,13 @@ private Single<Integer> checkDarkImage(String filePath) {
      * @param filePath file to be checked
      * @return IMAGE_GEOLOCATION_DIFFERENT or IMAGE_OK
      */
-    private Single<Integer> checkImageGeoLocation(Place place, String filePath) {
+    private Single<Integer> checkImageGeoLocation(Place place, String filePath, LatLng location) {
         Timber.d("Checking for image geolocation %s", filePath);
         if (place == null || StringUtils.isBlank(place.getWikiDataEntityId())) {
             return Single.just(ImageUtils.IMAGE_OK);
         }
         return Single.fromCallable(() -> filePath)
-            .map(fileUtilsWrapper::getGeolocationOfFile)
+            .flatMap(path -> Single.just(fileUtilsWrapper.getGeolocationOfFile(path, location)))
             .flatMap(geoLocation -> {
                 if (StringUtils.isBlank(geoLocation)) {
                     return Single.just(ImageUtils.IMAGE_OK);