cordova-plugin-mserviceinterface-2.0 1.0.102 → 1.0.104

package/src/android/mInterface.java

@@ -9,7 +9,7 @@ import android.app.AlertDialog;
 import android.app.PendingIntent;
 import android.app.ProgressDialog;
 import android.content.ContentResolver;
-import android.content.ContentUris;
+import android.content.ActivityNotFoundException;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
@@ -26,6 +26,7 @@ import android.graphics.Color;
 import android.graphics.Matrix;
 import android.graphics.Paint;
 import android.location.Location;
+import android.location.LocationManager;
 import android.media.MediaMetadataRetriever;
 import android.media.ThumbnailUtils;
 import android.net.ConnectivityManager;
@@ -35,7 +36,9 @@ import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
-import android.provider.DocumentsContract;
+import android.os.Handler;
+import android.os.Looper;
+import android.os.SystemClock;
 import android.provider.MediaStore;
 import android.provider.OpenableColumns;
 import android.provider.Settings;
@@ -43,7 +46,6 @@ import android.text.TextUtils;
 import android.util.Base64;
 import android.util.Log;
 import android.util.Patterns;
-import android.view.KeyEvent;
 import android.webkit.MimeTypeMap;
 import android.widget.ProgressBar;
 import android.widget.Toast;
@@ -52,9 +54,13 @@ import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
 import androidx.annotation.RequiresApi;
 import androidx.core.app.ActivityCompat;
+import androidx.core.location.LocationManagerCompat;
 import androidx.exifinterface.media.ExifInterface;
 
 import com.google.android.gms.common.ConnectionResult;
+import com.google.android.gms.common.GoogleApiAvailability;
+import com.google.android.gms.location.CurrentLocationRequest;
+import com.google.android.gms.tasks.CancellationTokenSource;
 import com.google.android.gms.common.api.GoogleApiClient;
 import com.google.android.gms.common.api.PendingResult;
 import com.google.android.gms.common.api.ResultCallback;
@@ -102,6 +108,7 @@ import java.util.Arrays;
 import java.util.Collections;
 import java.util.Date;
 import java.util.List;
+import java.util.Locale;
 import java.util.Stack;
 import java.util.TimeZone;
 import java.util.zip.ZipEntry;
@@ -118,6 +125,11 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     public Stack<ProgressDialog> spinnerDialogStack = new Stack<ProgressDialog>();
     private static final int PICK_FILE_REQUEST = 1;
     public CallbackContext callback;
+    private CallbackContext permissionCallback;
+    private int pendingPermissionRequest = -1;
+    private static final int REQUEST_PERMISSIONS = 4101;
+    private static final int REQUEST_LOCATION_PERMISSION = 4102;
+    private static final int REQUEST_MEDIA_PERMISSION = 4103;
     private static JSONArray arguments = null;
     private String pictureFilePath;
     private String cameraAttachmentInd = "false";
@@ -136,7 +148,6 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     private static final String PORTRAIT = "portrait";
     private static final String LANDSCAPE = "landscape";
     private static final String ANDROID_PLATFORM = "Android";
-    String currentLocationInd = "";
     Location mCurrentLocation1;
     LocationRequest mLocationRequest1;
     GoogleApiClient mGoogleApiClient1;
@@ -155,15 +166,39 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             super.onResume(multitasking);
             //To avoid starting service after getting permissions initially.
             if (!mInterfaceUtil.deviceID.equalsIgnoreCase("")) {
-                if (!isServiceRunning(mInterfaceService.class) || !isProcessRunning()) {
-                    cordova.getActivity().startService(new Intent(cordova.getActivity().getApplicationContext(), mInterfaceService.class));
-                }
+                mInterfaceService.start(cordova.getActivity());
             }
         } catch (Exception e) {
             System.out.println("onResume: " + e.getMessage());
         }
     }
 
+    @Override
+    public void onPause(boolean multitasking) {
+        mInterfaceService.stopIfNotTracking(cordova.getActivity());
+        super.onPause(multitasking);
+    }
+
+    @Override
+    public void onDestroy() {
+        locationPluginDestroyed = true;
+        cancelCurrentLocationRequest();
+        mInterfaceService.stopIfNotTracking(cordova.getActivity());
+        if (mGoogleApiClient1 != null) {
+            if (mGoogleApiClient1.isConnected()) {
+                LocationServices.FusedLocationApi.removeLocationUpdates(mGoogleApiClient1, this);
+            }
+            mGoogleApiClient1.disconnect();
+        }
+        super.onDestroy();
+    }
+
+    @Override
+    public void onReset() {
+        cancelCurrentLocationRequest();
+        super.onReset();
+    }
+
     @RequiresApi(api = Build.VERSION_CODES.O)
     @Override
     public boolean execute(final String action, JSONArray args, final CallbackContext callbackContext) throws JSONException {
@@ -199,13 +234,11 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 try {
                     boolean appInfoUpdated = new mInterfaceUtil().updateAppInfo(args);
                     System.out.println("appInfoUpdated: " + appInfoUpdated);
-                    //if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
-                    if (!isServiceRunning(mInterfaceService.class)) {
-                        cordova.getActivity().startService(new Intent(cordova.getActivity().getApplicationContext(), mInterfaceService.class));
+                    if (mInterfaceService.start(cordova.getActivity())) {
+                        callbackContext.success("Success");
                     } else {
-                        System.out.println("Service is already running");
+                        callbackContext.error("Unable to start service while the app is in the background");
                     }
-                    callbackContext.success("Success");
                 } catch (Exception e) {
                     System.out.println("Unable to StartService, Exception is: " + e.getMessage());
                     callbackContext.error("Unable to StartService, Exception is: " + e.getMessage());
@@ -471,6 +504,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     String str = "false";
                     if (isServiceRunning(mInterfaceService.class)) {
                         str = "true";
+                        // Legacy JS skips StartService when this returns true.
+                        // Recheck an existing queue-only/tracking service here,
+                        // preserving the callback contract and eligibility guards.
+                        mInterfaceService.start(cordova.getActivity());
                         System.out.println("service check is: " + str + " " + isServiceRunning(mInterfaceService.class));
                     }
                     callbackContext.success(str);
@@ -604,19 +641,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     callbackContext.error(e.getMessage());
                 }
             } else if ("GetCurrentLocation".equals(action)) {
-                try {
-                    currentLocationInd = "true";
-                    callback = callbackContext;
-                    createLocationRequest1();
-                    this.mGoogleApiClient1 = new GoogleApiClient.Builder(cordova.getActivity())
-                            .addConnectionCallbacks(this)
-                            .addOnConnectionFailedListener(this)
-                            .addApi(LocationServices.API)
-                            .build();
-                    mGoogleApiClient1.connect();
-                } catch (Exception e) {
-                    callbackContext.error(e.getMessage());
-                }
+                getCurrentLocation(callbackContext);
+                return true;
             } else if (action.equals("GetSyncIndicator")) {
                 try {
                     File newQueueFolder, oldQueueFolder;
@@ -826,25 +852,14 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 builder.setNegativeButton("Not Now", new DialogInterface.OnClickListener() {
                     @Override
                     public void onClick(DialogInterface dialog, int which) {
-                        dialog.cancel();
+                        dialog.dismiss();
                         callbackContext.success("Success");
                     }
                 });
                 alertDialog = builder.create();
                 alertDialog.setCanceledOnTouchOutside(false);
                 alertDialog.show();
-                alertDialog.setOnKeyListener(new DialogInterface.OnKeyListener() {
-
-                    @Override
-                    public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
-                        if (keyCode == KeyEvent.KEYCODE_BACK) {
-                            dialog.dismiss();
-                            callbackContext.error("failure");
-                        }
-                        return true;
-                    }
-
-                });
+                alertDialog.setOnCancelListener(dialog -> callbackContext.error("failure"));
             } else if (action.equals("UpdateConfirm")) {
                 /* OPEN THE PLAYSTORE MSERVICE APP */
                 String appVersion, softwareProductVersion, softwareProductSubVersion;
@@ -867,17 +882,7 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 alertDialog = builder.create();
                 alertDialog.setCanceledOnTouchOutside(false);
                 alertDialog.show();
-                alertDialog.setOnKeyListener(new DialogInterface.OnKeyListener() {
-
-                    @Override
-                    public boolean onKey(DialogInterface dialog, int keyCode, KeyEvent event) {
-                        if (keyCode == KeyEvent.KEYCODE_BACK) {
-                            dialog.dismiss();
-                            callbackContext.error("failure");
-                        }
-                        return true;
-                    }
-                });
+                alertDialog.setOnCancelListener(dialog -> callbackContext.error("failure"));
             } else if (action.equals("UpdateNew")) {
                 try {
                     cordova.getActivity().startActivity(new Intent(Intent.ACTION_VIEW, Uri.parse("https://play.google.com/store/apps/details?id=" + cordova.getActivity().getApplicationContext().getPackageName())));
@@ -907,6 +912,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 }
             } else if (action.equals("CaptureImageFromCamera")) {
                 try {
+                    attachmentDestPath = "";
+                    cameraAttachmentInd = "false";
                     if (args.length() > 0) {
                         attachmentDestPath = args.optJSONObject(0).optString("destinationPath");
                         cameraAttachmentInd = args.getJSONObject(0).optString("attachmentInd");
@@ -918,6 +925,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 }
             } else if (action.equals("PickImageFromGallery")) {
                 try {
+                    attachmentDestPath = "";
+                    galleryAttachmentInd = "false";
                     if (args.length() > 0) {
                         attachmentDestPath = args.optJSONObject(0).optString("destinationPath");
                         galleryAttachmentInd = args.getJSONObject(0).optString("attachmentInd");
@@ -1493,6 +1502,122 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         return false;
     }
 
+    private static final long CURRENT_LOCATION_TIMEOUT_MS = 10_000L;
+    private static final String CURRENT_LOCATION_TIMEOUT_ERROR = "Unable to obtain current location within 10 seconds";
+    private final Handler currentLocationHandler = new Handler(Looper.getMainLooper());
+    private CurrentLocationOperation currentLocationOperation;
+    private volatile boolean locationPluginDestroyed;
+
+    private void getCurrentLocation(final CallbackContext resultCallback) {
+        final long deadline = SystemClock.elapsedRealtime() + CURRENT_LOCATION_TIMEOUT_MS;
+        currentLocationHandler.post(() -> {
+            if (locationPluginDestroyed) {
+                resultCallback.error("Current location request cancelled: plugin destroyed");
+                return;
+            }
+            if (currentLocationOperation != null) {
+                resultCallback.error("A current location request is already in progress");
+                return;
+            }
+            CurrentLocationOperation operation = new CurrentLocationOperation(resultCallback, deadline);
+            currentLocationOperation = operation;
+            operation.start();
+        });
+    }
+
+    private void cancelCurrentLocationRequest() {
+        currentLocationHandler.post(() -> {
+            if (currentLocationOperation != null) {
+                currentLocationOperation.finish(null, "Current location request cancelled");
+            }
+        });
+    }
+
+    // All request state and completion listeners run on the main looper. This
+    // callback is separate from the shared camera/scanner/GPS-settings callback.
+    private final class CurrentLocationOperation {
+        private final CallbackContext resultCallback;
+        private final long deadline;
+        private final CancellationTokenSource cancellation = new CancellationTokenSource();
+        private final Runnable timeout = () -> finish(null, CURRENT_LOCATION_TIMEOUT_ERROR);
+        private boolean completed;
+
+        CurrentLocationOperation(CallbackContext resultCallback, long deadline) {
+            this.resultCallback = resultCallback;
+            this.deadline = deadline;
+        }
+
+        void start() {
+            long remaining = deadline - SystemClock.elapsedRealtime();
+            if (remaining <= 0) {
+                finish(null, CURRENT_LOCATION_TIMEOUT_ERROR);
+                return;
+            }
+            currentLocationHandler.postDelayed(timeout, remaining);
+            try {
+                Context context = cordova.getActivity().getApplicationContext();
+                if (ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_FINE_LOCATION) != PackageManager.PERMISSION_GRANTED
+                        && ActivityCompat.checkSelfPermission(context, Manifest.permission.ACCESS_COARSE_LOCATION) != PackageManager.PERMISSION_GRANTED) {
+                    finish(null, "Location permission not granted");
+                    return;
+                }
+                LocationManager manager = (LocationManager) context.getSystemService(Context.LOCATION_SERVICE);
+                if (manager == null || !LocationManagerCompat.isLocationEnabled(manager)) {
+                    finish(null, "Device location is disabled");
+                    return;
+                }
+                if (GoogleApiAvailability.getInstance().isGooglePlayServicesAvailable(context) != ConnectionResult.SUCCESS) {
+                    finish(null, "Google Play services is unavailable");
+                    return;
+                }
+                remaining = deadline - SystemClock.elapsedRealtime();
+                if (remaining <= 0) {
+                    finish(null, CURRENT_LOCATION_TIMEOUT_ERROR);
+                    return;
+                }
+                CurrentLocationRequest request = new CurrentLocationRequest.Builder()
+                        .setPriority(Priority.PRIORITY_HIGH_ACCURACY)
+                        .setMaxUpdateAgeMillis(0)
+                        .setDurationMillis(remaining)
+                        .build();
+                // No network precondition: a satellite fix can be available offline.
+                LocationServices.getFusedLocationProviderClient(context)
+                        .getCurrentLocation(request, cancellation.getToken())
+                        .addOnSuccessListener(location -> finish(location,
+                                location == null ? "Current location is unavailable" : null))
+                        .addOnFailureListener(error -> finish(null,
+                                "Unable to obtain current location: " + error.getMessage()))
+                        .addOnCanceledListener(() -> finish(null, "Current location request cancelled"));
+            } catch (Exception error) {
+                finish(null, "Unable to obtain current location: " + error.getMessage());
+            }
+        }
+
+        void finish(Location location, String error) {
+            if (completed) return;
+            completed = true;
+            currentLocationHandler.removeCallbacks(timeout);
+            if (currentLocationOperation == this) currentLocationOperation = null;
+            // Cancels outstanding acquisition on timeout/reset and releases the
+            // one-shot request on every terminal path. Late results are ignored.
+            try {
+                cancellation.cancel();
+            } catch (RuntimeException cancellationError) {
+                Log.w(TAG, "Unable to cancel current location acquisition", cancellationError);
+            }
+            if (SystemClock.elapsedRealtime() >= deadline) {
+                location = null;
+                error = CURRENT_LOCATION_TIMEOUT_ERROR;
+            }
+            if (location != null) {
+                resultCallback.success(location.getLatitude() + "," + location.getLongitude());
+            } else {
+                resultCallback.error(error);
+            }
+        }
+    }
+
+
     public void createLocationRequest1() {
         try {
             mLocationRequest1 = new LocationRequest();
@@ -1577,7 +1702,6 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         boolean permissionGranted = true, checkPermission = true;
         List<String> list;
         try {
-            callback = callbackContext;
             Context context = cordova.getActivity().getApplicationContext();
             String[] permissions = args.optJSONObject(0).optString("permissions").split(",");
             if (permissions[0].equalsIgnoreCase("android.permission.ACCESS_BACKGROUND_LOCATION")) {
@@ -1595,12 +1719,12 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     }
                 }
                 if (!permissionGranted) {
-                    callback.error("failure");
+                    callbackContext.error("failure");
                 } else {
-                    callback.success("success");
+                    callbackContext.success("success");
                 }
             } else {
-                callback.success("success");
+                callbackContext.success("success");
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -1615,69 +1739,106 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     }
 
     private void getLocationPermission(JSONArray args, CallbackContext callbackContext) {
-        boolean permissionGranted = true;
-        List<String> list;
         try {
-            callback = callbackContext;
-            Context context = cordova.getActivity().getApplicationContext();
-            String[] permissions = args.optJSONObject(0).optString("permissions").split(",");
-            list = new ArrayList<String>(Arrays.asList(permissions));
-            permissions = list.toArray(new String[0]);
-
-            for (int i = 0; i < permissions.length; i++) {
-                if (ActivityCompat.checkSelfPermission(context, permissions[i]) != PackageManager.PERMISSION_GRANTED) {
-                    permissionGranted = false;
-                }
-            }
-            if (!permissionGranted) {
-                PermissionHelper.requestPermissions(this, 111, permissions);
-            } else {
-                callback.success("success");
-            }
+            requestPermissionsIfNeeded(normalizePermissions(args, false), REQUEST_LOCATION_PERMISSION, callbackContext);
         } catch (Exception e) {
-            e.printStackTrace();
+            callbackContext.error("getLocationPermission failed: " + e.getMessage());
         }
     }
    
     private void getPermissions(JSONArray args, CallbackContext callbackContext) {
-        boolean permissionGranted = true;
-        List<String> list;
         try {
-            callback = callbackContext;
-            Context context = cordova.getActivity().getApplicationContext();
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-                String[] permissions = args.optJSONObject(0).optString("permissions").split(",");
-                if (Build.VERSION.SDK_INT != Build.VERSION_CODES.Q) {
-                    list = new ArrayList<String>(Arrays.asList(permissions));
-                    list.remove("android.permission.ACCESS_BACKGROUND_LOCATION");
-                    if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-                        list.remove("android.permission.POST_NOTIFICATIONS");
-                    } else {
-                        list.remove("android.permission.WRITE_EXTERNAL_STORAGE");
-                        list.remove("android.permission.READ_EXTERNAL_STORAGE");
-                    }
-                    permissions = list.toArray(new String[0]);
-                }
-                for (int i = 0; i < permissions.length; i++) {
-                    if (ActivityCompat.checkSelfPermission(context, permissions[i]) != PackageManager.PERMISSION_GRANTED) {
-                        permissionGranted = false;
-                    }
-                }
-                if (!permissionGranted) {
-                    PermissionHelper.requestPermissions(this, 1, permissions);
-                } else {
-                    callback.success("success");
-                }
-            } else {
-                callback.success("success");
+            requestPermissionsIfNeeded(normalizePermissions(args, true), REQUEST_PERMISSIONS, callbackContext);
+        } catch (Exception e) {
+            callbackContext.error("getPermissions failed: " + e.getMessage());
+        }
+    }
+
+    private String[] normalizePermissions(JSONArray args, boolean initialRequest) throws JSONException {
+        List<String> permissions = new ArrayList<>();
+        for (String value : args.getJSONObject(0).getString("permissions").split(",")) {
+            String permission = value.trim();
+            if (permission.isEmpty()) continue;
+            // Files and photos are selected through URI grants into app-private storage.
+            if (Manifest.permission.READ_MEDIA_IMAGES.equals(permission)
+                    || Manifest.permission.READ_MEDIA_VIDEO.equals(permission)
+                    || Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED.equals(permission)
+                    || Manifest.permission.READ_EXTERNAL_STORAGE.equals(permission)
+                    || Manifest.permission.WRITE_EXTERNAL_STORAGE.equals(permission)) continue;
+            if (Manifest.permission.ACCESS_BACKGROUND_LOCATION.equals(permission)
+                    && (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+                    || (initialRequest && Build.VERSION.SDK_INT != Build.VERSION_CODES.Q))) continue;
+            if (Manifest.permission.POST_NOTIFICATIONS.equals(permission)
+                    && Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) continue;
+            if ((Manifest.permission.READ_MEDIA_IMAGES.equals(permission)
+                    || Manifest.permission.READ_MEDIA_VIDEO.equals(permission)
+                    || Manifest.permission.READ_MEDIA_AUDIO.equals(permission))
+                    && Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                permission = Manifest.permission.READ_EXTERNAL_STORAGE;
             }
+            if (Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED.equals(permission)
+                    && Build.VERSION.SDK_INT < Build.VERSION_CODES.UPSIDE_DOWN_CAKE) continue;
+            if (Manifest.permission.READ_EXTERNAL_STORAGE.equals(permission)
+                    && Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) continue;
+            if (Manifest.permission.WRITE_EXTERNAL_STORAGE.equals(permission)
+                    && Build.VERSION.SDK_INT >= Build.VERSION_CODES.Q) continue;
+            if (!permissions.contains(permission)) permissions.add(permission);
+        }
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE
+                && (permissions.contains(Manifest.permission.READ_MEDIA_IMAGES)
+                || permissions.contains(Manifest.permission.READ_MEDIA_VIDEO))
+                && !permissions.contains(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)) {
+            permissions.add(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED);
+        }
+        return permissions.toArray(new String[0]);
+    }
+
+    private boolean isPermissionSatisfied(String permission) {
+        Context context = cordova.getActivity();
+        if (ActivityCompat.checkSelfPermission(context, permission) == PackageManager.PERMISSION_GRANTED) return true;
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            if (Manifest.permission.READ_MEDIA_IMAGES.equals(permission) || Manifest.permission.READ_MEDIA_VIDEO.equals(permission)) {
+                return ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+                        == PackageManager.PERMISSION_GRANTED;
+            }
+            if (Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED.equals(permission)) {
+                return ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_MEDIA_IMAGES) == PackageManager.PERMISSION_GRANTED
+                        || ActivityCompat.checkSelfPermission(context, Manifest.permission.READ_MEDIA_VIDEO) == PackageManager.PERMISSION_GRANTED;
+            }
+        }
+        return false;
+    }
+
+    private boolean hasRequestedPermissions(String[] permissions) {
+        for (String permission : permissions) {
+            if (!isPermissionSatisfied(permission)) return false;
+        }
+        return true;
+    }
+
+    private void requestPermissionsIfNeeded(String[] permissions, int requestCode, CallbackContext callbackContext) {
+        if (hasRequestedPermissions(permissions)) {
+            callbackContext.success("success");
+            return;
+        }
+        if (permissionCallback != null) {
+            callbackContext.error("Another permission request is in progress");
+            return;
+        }
+        permissionCallback = callbackContext;
+        pendingPermissionRequest = requestCode;
+        try {
+            PermissionHelper.requestPermissions(this, requestCode, permissions);
         } catch (Exception e) {
-            callback.error("getPermissions failed, exception is : " + e.getMessage());
+            permissionCallback = null;
+            pendingPermissionRequest = -1;
+            callbackContext.error("Unable to request permission: " + e.getMessage());
         }
     }
 
     public void captureImageLiveCamera(CallbackContext callbackContext) {
         callback = callbackContext;
+        pictureFilePath = null;
         Context context = cordova.getActivity().getApplicationContext();
         Intent takePictureIntent = new Intent(MediaStore.ACTION_IMAGE_CAPTURE);
         File photoFile = null;
@@ -1685,6 +1846,7 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             photoFile = createImageFile();
         } catch (IOException ex) {
             callback.error("there is error in create image");
+            return;
         }
         //Continue only if the File was successfully created
         if (photoFile != null) {
@@ -1699,11 +1861,14 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             PluginResult pluginResult = new PluginResult(PluginResult.Status.NO_RESULT);
             pluginResult.setKeepCallback(true);
             callbackContext.sendPluginResult(pluginResult);
+        } else {
+            callbackContext.error("Unable to create the camera output file");
         }
     }
 
     public void captureImage(CallbackContext callbackContext) {
         callback = callbackContext;
+        pictureFilePath = null;
         Intent intent = new Intent(cordova.getActivity(), CameraActivity.class);
         cordova.startActivityForResult(this, intent, REQUEST_IMAGE_CAPTURE);
         PluginResult pluginResult = new PluginResult(PluginResult.Status.NO_RESULT);
@@ -1713,26 +1878,32 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     void pickImageFromGallery(CallbackContext callbackContext) {
         try {
-            Intent i;
-            if (android.os.Build.VERSION.SDK_INT >= android.os.Build.VERSION_CODES.TIRAMISU) {
-                i = new Intent(MediaStore.ACTION_PICK_IMAGES);
-                i.setType("image/*");
+            callback = callbackContext;
+            Intent intent;
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                intent = new Intent(MediaStore.ACTION_PICK_IMAGES);
+                intent.setType("image/*");
             } else {
-                i = new Intent(Intent.ACTION_OPEN_DOCUMENT);
-                i.addCategory(Intent.CATEGORY_OPENABLE);
-                i.setType("image/*");
-                i.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
+                intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+                intent.setType("image/*");
+                intent.addCategory(Intent.CATEGORY_OPENABLE);
             }
-            i.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
-            this.callback = callbackContext;
-            PluginResult pr = new PluginResult(PluginResult.Status.NO_RESULT);
-            pr.setKeepCallback(true);
-            callbackContext.sendPluginResult(pr);
-            cordova.startActivityForResult(this, i, PICK_IMAGE_FROM_GALLERY);
-
-
+            intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+            try {
+                cordova.startActivityForResult(this, intent, PICK_IMAGE_FROM_GALLERY);
+            } catch (ActivityNotFoundException unavailable) {
+                if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) throw unavailable;
+                Intent fallback = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+                fallback.setType("image/*");
+                fallback.addCategory(Intent.CATEGORY_OPENABLE);
+                fallback.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+                cordova.startActivityForResult(this, fallback, PICK_IMAGE_FROM_GALLERY);
+            }
+            PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
+            result.setKeepCallback(true);
+            callbackContext.sendPluginResult(result);
         } catch (Exception e) {
-            callbackContext.error("pickImageFromGallery failed, exception is : " + e.getMessage());
+            callbackContext.error("pickImageFromGallery failed: " + e.getMessage());
         }
     }
     
@@ -1923,10 +2094,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                         fileProperities.put("fileExtension", fileExtension);
                         fileProperities.put("thumbnail", thumbnail);
                         attachmentDestPath = "";
-                        callback.success(fileProperities);
+                        callbackContext.success(fileProperities);
                     } catch (Exception e) {
                         attachmentDestPath = "";
-                        callback.error("convertImageTo64BaseString failed, exception is : " + e.getMessage());
+                        callbackContext.error("convertImageTo64BaseString failed, exception is : " + e.getMessage());
                     }
                 }
             } catch (Exception e) {
@@ -1935,7 +2106,7 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             }
 
         } catch (Exception e) {
-            e.printStackTrace();
+            callbackContext.error("convertImageTo64BaseString failed: " + e.getMessage());
         }
 
     }
@@ -1970,23 +2141,11 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     }
 
     public Intent getPickImageChooserIntent() {
-        Intent openFile, selectFile;
-        try {
-            if (Build.MANUFACTURER.equals("samsung")) {
-                openFile = new Intent("com.sec.android.app.myfiles.PICK_DATA");
-                openFile.putExtra("CONTENT_TYPE", "*/*");
-            } else {
-                openFile = new Intent(Intent.ACTION_GET_CONTENT);
-                openFile.setType("*/*");
-                openFile.addCategory(Intent.CATEGORY_OPENABLE);
-                openFile.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
-            }
-            selectFile = Intent.createChooser(openFile, "Select File");
-            return selectFile;
-        } catch (Exception e) {
-            e.printStackTrace();
-        }
-        return null;
+        Intent intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+        intent.setType("*/*");
+        intent.addCategory(Intent.CATEGORY_OPENABLE);
+        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION);
+        return Intent.createChooser(intent, "Select File");
     }
 
     //App version plugin
@@ -2004,35 +2163,31 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     //Rotate Screen plugin
     public void rotateScreen(JSONArray args, CallbackContext callbackContext) {
-        try {
-            String orientation = args.optString(0);
-            String currentOrientation;
-            Activity activity = cordova.getActivity();
-            int orientation1 = activity.getResources().getConfiguration().orientation;
-            if (orientation1 == Configuration.ORIENTATION_LANDSCAPE) {
-                currentOrientation = "landscape";
-            } else {
-                currentOrientation = "portrait";
-            }
-            if (orientation.equals(ANY)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED);
-            } else if (orientation.equals(LANDSCAPE_PRIMARY)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE);
-            } else if (orientation.equals(PORTRAIT_PRIMARY)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_PORTRAIT);
-            } else if (orientation.equals(LANDSCAPE)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE);
-            } else if (orientation.equals(PORTRAIT)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT);
-            } else if (orientation.equals(LANDSCAPE_SECONDARY)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE);
-            } else if (orientation.equals(PORTRAIT_SECONDARY)) {
-                activity.setRequestedOrientation(ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT);
+        final String orientation = args.optString(0);
+        cordova.getActivity().runOnUiThread(() -> {
+            try {
+                Activity activity = cordova.getActivity();
+                String currentOrientation = activity.getResources().getConfiguration().orientation
+                        == Configuration.ORIENTATION_LANDSCAPE ? "landscape" : "portrait";
+                int requested;
+                switch (orientation) {
+                    case ANY: requested = ActivityInfo.SCREEN_ORIENTATION_UNSPECIFIED; break;
+                    case LANDSCAPE_PRIMARY: requested = ActivityInfo.SCREEN_ORIENTATION_LANDSCAPE; break;
+                    case PORTRAIT_PRIMARY: requested = ActivityInfo.SCREEN_ORIENTATION_PORTRAIT; break;
+                    case LANDSCAPE: requested = ActivityInfo.SCREEN_ORIENTATION_SENSOR_LANDSCAPE; break;
+                    case PORTRAIT: requested = ActivityInfo.SCREEN_ORIENTATION_SENSOR_PORTRAIT; break;
+                    case LANDSCAPE_SECONDARY: requested = ActivityInfo.SCREEN_ORIENTATION_REVERSE_LANDSCAPE; break;
+                    case PORTRAIT_SECONDARY: requested = ActivityInfo.SCREEN_ORIENTATION_REVERSE_PORTRAIT; break;
+                    default: callbackContext.error("Unsupported screen orientation"); return;
+                }
+                // A best-effort request: API 36 large screens can ignore fixed orientations.
+                // Return the previous orientation as before, not a claim that a lock was applied.
+                activity.setRequestedOrientation(requested);
+                callbackContext.success(currentOrientation);
+            } catch (Exception e) {
+                callbackContext.error("rotateScreen failed: " + e.getMessage());
             }
-            callbackContext.success(currentOrientation);
-        } catch (Exception e) {
-            callbackContext.success("rotateScreen failed, exception is : " + e.getMessage());
-        }
+        });
     }
 
     public void deviceInfo(CallbackContext callbackContext) {
@@ -2130,12 +2285,20 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                                                  final String imageSourcePath,
                                                  final String imgSrcType,
                                                  final String destinationPath) {
+        convertImageTo64BaseStringAsync(cb, imageSourcePath, imgSrcType, destinationPath, false);
+    }
+
+    private void convertImageTo64BaseStringAsync(final CallbackContext cb,
+                                                 final String imageSourcePath,
+                                                 final String imgSrcType,
+                                                 final String destinationPath,
+                                                 final boolean deleteImported) {
         cordova.getThreadPool().execute(new Runnable() {
             @Override public void run() {
-                InputStream srcFileReader = null;
-                OutputStream desFileWriter = null;
+
                 ByteArrayOutputStream baos = null;
                 Bitmap bitmap = null;
+                File compressedTemp = null;
                 try {
                     // Common bits
                     final String[] parts = imageSourcePath.split("/");
@@ -2154,33 +2317,20 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                                 .setCompressFormat(Bitmap.CompressFormat.JPEG)
                                 .compressToFile(fileToCompress);
 
+                        compressedTemp = compressedImageFile;
                         String timeStamp = new java.text.SimpleDateFormat("yyyyMMdd_HHmmss").format(new java.util.Date());
                         final String baseDir = (destinationPath != null && !destinationPath.isEmpty())
                                 ? (mInterfaceUtil.rootDirectory + "/" + destinationPath)
                                 : (mInterfaceUtil.rootDirectory + "/" + mInterfaceUtil.packageName + "/images");
                         final String outName = baseName + "_" + timeStamp + ".jpg";
-                        final String outFullPath = baseDir + "/" + outName;
-
                         File outDir = new File(baseDir);
-                        if (!outDir.exists()) outDir.mkdirs();
-
-                        // Copy compressed temp → final path
-                        if (compressedImageFile.exists()) {
-                            srcFileReader = new FileInputStream(compressedImageFile);
-                            desFileWriter = new FileOutputStream(new File(outFullPath));
-                            byte[] buf = new byte[64 * 1024];
-                            int n;
-                            while ((n = srcFileReader.read(buf)) > 0) {
-                                desFileWriter.write(buf, 0, n);
-                            }
-                            desFileWriter.flush();
+                        String rootPath = mInterfaceUtil.rootDirectory.getCanonicalPath() + File.separator;
+                        if (!outDir.getCanonicalPath().startsWith(rootPath)) {
+                            throw new IOException("Attachment destination must be inside app storage");
                         }
+                        File outFile = AttachmentFileIO.copy(
+                                new FileInputStream(compressedImageFile), outDir, outName);
 
-                        // (Optional) load to normalize EXIF rotation like the sync version did
-                        try { bitmap = handleImageRotation(outFullPath); } catch (Throwable ignore) {}
-
-                        // Build properties
-                        File outFile = new File(outFullPath);
                         org.json.JSONObject fileProps = new org.json.JSONObject();
                         fileProps.put("filePath", outFile.getParent());
                         fileProps.put("fileName", outFile.getName());
@@ -2189,25 +2339,37 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                         fileProps.put("thumbnail", thumbnail);
 
                         // Match original behavior: clear attachmentDestPath if you rely on that global
-                        try { attachmentDestPath = ""; } catch (Throwable ignore) {}
+
 
                         postSuccess(cb, fileProps);
                         return;
                     }
 
-                    // === CAMERA / GALLERY → return BASE64 string ===
+                    // === CAMERA / GALLERY → return BASE64 string ===
                     // Decode with downsampling and fix rotation
                     BitmapFactory.Options o = new BitmapFactory.Options();
                     o.inJustDecodeBounds = true; BitmapFactory.decodeFile(imageSourcePath, o);
                     o.inSampleSize = calcInSampleSize(o, 1920, 1920);
                     o.inJustDecodeBounds = false;
 
-                    // Prefer your rotation-aware helper (handles EXIF)
-                    try {
-                        bitmap = handleImageRotation(imageSourcePath);
-                        if (bitmap == null) bitmap = BitmapFactory.decodeFile(imageSourcePath, o);
-                    } catch (Throwable t) {
-                        bitmap = BitmapFactory.decodeFile(imageSourcePath, o);
+                    bitmap = BitmapFactory.decodeFile(imageSourcePath, o);
+                    if (bitmap != null) {
+                        try {
+                            ExifInterface exif = new ExifInterface(imageSourcePath);
+                            Matrix matrix = new Matrix();
+                            switch (exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)) {
+                                case ExifInterface.ORIENTATION_FLIP_HORIZONTAL: matrix.setScale(-1, 1); break;
+                                case ExifInterface.ORIENTATION_ROTATE_180: matrix.setRotate(180); break;
+                                case ExifInterface.ORIENTATION_FLIP_VERTICAL: matrix.setScale(1, -1); break;
+                                case ExifInterface.ORIENTATION_TRANSPOSE: matrix.setRotate(90); matrix.postScale(-1, 1); break;
+                                case ExifInterface.ORIENTATION_ROTATE_90: matrix.setRotate(90); break;
+                                case ExifInterface.ORIENTATION_TRANSVERSE: matrix.setRotate(270); matrix.postScale(-1, 1); break;
+                                case ExifInterface.ORIENTATION_ROTATE_270: matrix.setRotate(270); break;
+                            }
+                            Bitmap rotated = Bitmap.createBitmap(bitmap, 0, 0, bitmap.getWidth(), bitmap.getHeight(), matrix, true);
+                            if (rotated != bitmap) bitmap.recycle();
+                            bitmap = rotated;
+                        } catch (IOException ignored) { }
                     }
                     if (bitmap == null) {
                         postError(cb, "decode_failed");
@@ -2224,18 +2386,18 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                             File f = new File(imageSourcePath);
                             if (f.exists()) f.delete();
                         } catch (Throwable ignore) {}
-                        try { attachmentDestPath = ""; } catch (Throwable ignore) {}
+
                     } else if ("gallery".equalsIgnoreCase(imgSrcType)) {
-                        try { attachmentDestPath = ""; } catch (Throwable ignore) {}
+
                     }
 
                     postSuccess(cb, encodedImage);
                 } catch (Exception e) {
-                    try { attachmentDestPath = ""; } catch (Throwable ignore) {}
+
                     postError(cb, "convertImageTo64BaseStringAsync failed: " + e.getMessage());
                 } finally {
-                    try { if (srcFileReader != null) srcFileReader.close(); } catch (Exception ignore) {}
-                    try { if (desFileWriter != null) desFileWriter.close(); } catch (Exception ignore) {}
+                    if (compressedTemp != null && !compressedTemp.getAbsolutePath().equals(imageSourcePath)) compressedTemp.delete();
+                    if (deleteImported) new File(imageSourcePath).delete();
                     try { if (baos != null) baos.close(); } catch (Exception ignore) {}
                     try { if (bitmap != null) bitmap.recycle(); } catch (Exception ignore) {}
                 }
@@ -2245,19 +2407,9 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
 
     private String copyFileFromUriFast(Context ctx, Uri uri, String destName, String destDir) {
-        java.io.File dir = (destDir!=null && !destDir.isEmpty())
-                ? new java.io.File(ctx.getFilesDir(), destDir)
-                : ctx.getFilesDir();
-        if (!dir.exists() && !dir.mkdirs()) return null;
-        java.io.File out = new java.io.File(dir, destName);
-        try (java.io.InputStream in = ctx.getContentResolver().openInputStream(uri);
-             java.io.OutputStream os = new java.io.FileOutputStream(out)) {
-            if (in == null) return null;
-            byte[] buf = new byte[64 * 1024];
-            int n; while ((n = in.read(buf)) != -1) os.write(buf, 0, n);
-            os.flush();
-            return out.getAbsolutePath();
-        } catch (Exception e) {
+        try {
+            return copySelectedFile(ctx, uri, destName, destDir);
+        } catch (IOException e) {
             android.util.Log.e("mInterface", "copyFileFromUriFast", e);
             return null;
         }
@@ -2270,15 +2422,17 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 case LOCATION_ACCURACY_REQUEST_NEW:
                     switch (resultCode) {
                         case Activity.RESULT_OK:
-                            mInterfaceService mInterfaceService = new mInterfaceService();
-                            mInterfaceService.startLocationUpdates(cordova.getContext());
-                            callback.success();
+                            if (mInterfaceService.start(cordova.getActivity())) {
+                                callback.success();
+                            } else {
+                                callback.error("Unable to resume location service");
+                            }
                             break;
                         case Activity.RESULT_CANCELED:
                             callback.error("oops! you have cancelled...");
                             break;
                     }
-                    break;
+                    return;
             }
             if (SCANCODEINT == 118 && callback != null) {
                 if (resultCode == RESULT_OK) {
@@ -2304,176 +2458,12 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     SCANCODEINT = 0;
                     callback.error(resultCode);
                 }
-            }else if (requestCode == PICK_IMAGE_FROM_GALLERY) {
-                final CallbackContext cb = this.callback;
-                this.callback = null;
-                if (cb == null) return;
-
-                try {
-                    if (resultCode != RESULT_OK || data == null) {
-                        cb.error("canceled");
-                        return;
-                    }
-
-                    // Photo Picker may return via getData() or ClipData
-                    Uri uri = data.getData();
-                    if (uri == null && data.getClipData() != null && data.getClipData().getItemCount() > 0) {
-                        uri = data.getClipData().getItemAt(0).getUri();
-                    }
-                    if (uri == null) {
-                        cb.error("no_file_selected");
-                        return;
-                    }
-
-                    final Uri selectedUri = uri;
-                    final String destPath = attachmentDestPath;                 // capture current dest
-                    final String galleryInd = String.valueOf(galleryAttachmentInd);
-
-                    // Offload ALL heavy work (resolver, copy, bitmap/encode) to Cordova thread pool
-                    cordova.getThreadPool().execute(new Runnable() {
-                        @Override public void run() {
-                            try {
-                                ContentResolver cr = cordova.getActivity().getContentResolver();
-
-                                String mime = null;
-                                try { mime = cr.getType(selectedUri); } catch (Throwable ignore) {}
-
-                                String defExt = (mime != null && mime.contains("/"))
-                                        ? mime.substring(mime.indexOf('/') + 1).toLowerCase()
-                                        : "jpg";
-
-                                // Get a display name if provider allows; otherwise build a sane fallback
-                                String fileName = safeGetDisplayName(cr, selectedUri, defExt);
-                                String ext = fileName.contains(".")
-                                        ? fileName.substring(fileName.lastIndexOf('.')).toLowerCase()
-                                        : ("." + defExt);
-
-                                // Copy the user-selected URI into app-private storage (no READ_MEDIA_* needed)
-                                String localPath = copyFileFromUriFast(
-                                        cordova.getActivity().getApplicationContext(),
-                                        selectedUri, fileName, destPath);
-
-                                if (localPath == null) {
-                                    cb.error("copy_failed");
-                                    return;
-                                }
-
-                                // Accept only image-like picks (by MIME or extension)
-                                boolean imageLike =
-                                        (mime != null && mime.startsWith("image/")) ||
-                                                ext.equals(".jpg") || ext.equals(".jpeg") ||
-                                                ext.equals(".png") || ext.equals(".heic");
-
-                                if (!imageLike) {
-                                    cb.error("Only JPEG/PNG/HEIC images are allowed.");
-                                    return;
-                                }
-
-                                // Run your existing conversion on a worker too (non-blocking)
-                                if ("true".equals(galleryInd)) {
-                                    convertImageTo64BaseStringAsync(cb, localPath, "compress", destPath);
-                                } else {
-                                    convertImageTo64BaseStringAsync(cb, localPath, "gallery", "");
-                                }
-                            } catch (Exception e) {
-                                cb.error("PICK_IMAGE_FROM_GALLERY: " + e.getMessage());
-                            }
-                        }
-                    });
-                    return; // IMPORTANT: stop here so no other branch falls through
-                } catch (Exception e) {
-                    cb.error("PICK_IMAGE_FROM_GALLERY dispatch failed: " + e.getMessage());
-                    return;
-                }
-            }
-            else if (requestCode == NEW_FILE_PICK_REQUEST && callback != null) {
-                try {
-                    Uri uri = data.getData();
-                    String fileName, extension, filePath;
-                    JSONObject fileProperities;
-                    Cursor cursor = null;
-                    if (uri.getScheme().equals("file")) {
-                        fileName = uri.getLastPathSegment();
-                        if (fileName.indexOf(".") > 0) {
-                            fileName = fileName.substring(0, fileName.lastIndexOf("."));
-                            String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
-                            extension = "." + fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
-                            fileName = fileName + "_" + timeStamp + extension;
-                        }
-                    } else {
-                        try {
-                            cursor = cordova.getActivity().getApplicationContext().getContentResolver().query(uri, new String[]{MediaStore.Images.ImageColumns.DISPLAY_NAME}, null, null, null);
-                            if (cursor != null && cursor.moveToFirst()) {
-                                int displayNameIndex = cursor.getColumnIndex(MediaStore.Images.ImageColumns.DISPLAY_NAME);
-                                if (displayNameIndex != -1) {
-                                    fileName = cursor.getString(displayNameIndex);
-                                } else {
-                                    fileName = "";
-                                }
-                                extension = "." + fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
-                                if (!extension.equals(".jpeg") && !extension.equals(".jpg") && !extension.equals(".png")) {
-                                    String timeStamp = new SimpleDateFormat("yyyyMMdd_HHmmss").format(new Date());
-                                    fileName = fileName.substring(0, fileName.lastIndexOf("."));
-                                    fileName = fileName + "_" + timeStamp + extension;
-                                }
-
-                            } else {
-                                fileName = uri.getLastPathSegment();
-                            }
-                        } finally {
-                            if (cursor != null) {
-                                cursor.close();
-                            }
-                        }
-                    }
-
-                    extension = "." + fileName.substring(fileName.lastIndexOf(".") + 1).toLowerCase();
-
-                    filePath = copyFileFromUri(cordova.getActivity().getApplicationContext(), uri, fileName, attachmentDestPath, callback);
-                    File file = new File(filePath);
-                    String mimeType = getMimeType(filePath, uri);
-                    System.out.println("Mime type is: " + mimeType);
-                    double fileSize = file.length();
-                    if (filePath != null) {
-                        try {
-                            if (requestCode == NEW_FILE_PICK_REQUEST) {
-                                if (extension.equals(".heic")) {
-                                    convertImageTo64BaseString(callback, filePath, "compress", attachmentDestPath);
-                                } else if (mimeType != null) {
-                                    if (mimeType.contains("image")) {
-                                        convertImageTo64BaseString(callback, filePath, "compress", attachmentDestPath);
-                                    } else {
-                                        fileProperities = new JSONObject();
-                                        fileProperities.put("filePath", filePath.substring(0, filePath.lastIndexOf(File.separator)));
-                                        fileProperities.put("fileName", fileName);
-                                        fileProperities.put("fileSize", fileSize);
-                                        fileProperities.put("fileExtension", extension);
-                                        fileProperities.put("thumbnail", getFileThumbnail(filePath, extension));
-                                        attachmentDestPath = "";
-                                        callback.success(fileProperities);
-                                    }
-                                } else {
-                                    fileProperities = new JSONObject();
-                                    fileProperities.put("filePath", filePath.substring(0, filePath.lastIndexOf(File.separator)));
-                                    fileProperities.put("fileName", fileName);
-                                    fileProperities.put("fileSize", fileSize);
-                                    fileProperities.put("fileExtension", extension);
-                                    fileProperities.put("thumbnail", getFileThumbnail(filePath, extension));
-                                    callback.success(fileProperities);
-                                }
-                            }
-                        } catch (Exception e) {
-                            callback.error("onActivityResult failed, exception is : " + e.getMessage());
-                        }
-                    } else {
-                        callback.error("onActivityResult: Selected file path is null");
-                    }
-                } catch (Exception e) {
-                    callback.error("onActivityResult failed, exception is : " + e.getMessage());
-                }
+            } else if ((requestCode == PICK_IMAGE_FROM_GALLERY || requestCode == NEW_FILE_PICK_REQUEST
+                    || requestCode == PICK_FILE_REQUEST) && callback != null) {
+                handlePickedFile(requestCode, resultCode, data);
             } else if (requestCode == REQUEST_IMAGE_CAPTURE && callback != null) {
                 if (resultCode == RESULT_OK) {
-                    String imagePath = data.getStringExtra("imagePath");
+                    String imagePath = data == null ? null : data.getStringExtra("imagePath");
                     if (imagePath != null && !imagePath.isEmpty()) {
                         pictureFilePath = imagePath;
                         if (cameraAttachmentInd.equals("true")) {
@@ -2485,12 +2475,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                         callback.error("failure");
                     }
                 } else if (resultCode == Activity.RESULT_CANCELED) {
-                   if (pictureFilePath != null && !pictureFilePath.isEmpty()) {
-						File file = new File(pictureFilePath);
-						if (file.exists()) {
-							file.delete();
-						}
-					}
+                    if (pictureFilePath != null && !pictureFilePath.isEmpty()) {
+                        File file = new File(pictureFilePath);
+                        if (file.exists()) file.delete();
+                    }
                     callback.error("failure");
                 } else {
                     callback.error(resultCode);
@@ -2499,158 +2487,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 if (resultCode == RESULT_OK) {
                     convertImageTo64BaseString(callback, pictureFilePath, "compress", attachmentDestPath);
                 } else if (resultCode == Activity.RESULT_CANCELED) {
-                    File file = new File(pictureFilePath);
-                    if (file.exists()) {
-                        file.delete();
-                    }
-                    callback.error("failure");
-                } else {
-                    callback.error(resultCode);
-                }
-            } else if (requestCode == PICK_FILE_REQUEST && callback != null) {
-                if (resultCode == RESULT_OK) {
-                    String fileName = null,
-                            getfilePath = null,
-                            filePath,
-                            fileExtension,
-                            fileType,
-                            fileSize = null,
-                            storageDefinition;
-                    final String docId,
-                            type,
-                            id;
-                    final String[] split;
-                    final String tag,
-                            path;
-                    final int splitIndex;
-                    Cursor cursor;
-                    long getSize;
-                    JSONObject fileProperities;
-                    Uri uri = data.getData(); //get uri for selected file
-                    fileType = this.cordova.getActivity().getContentResolver().getType(uri); // get mimeType for selected file
-                    File getFileName,
-                            file;
-                    try {
-                        //API LEVEL 19 AND ABOVE (TO GET FILEPATH)
-                        if (Build.VERSION.SDK_INT >= 19 && !Build.MANUFACTURER.equals("samsung") && DocumentsContract.isDocumentUri(cordova.getActivity(), uri)) {
-                            if ("com.android.externalstorage.documents".equals(uri.getAuthority())) { // ExternalStorageProvider
-                                docId = DocumentsContract.getDocumentId(uri);
-                                split = docId.split(":");
-                                type = split[0];
-                                if ("primary".equalsIgnoreCase(type)) {
-                                    getfilePath = mInterfaceUtil.rootDirectory + "/" + split[1];
-                                } else {
-                                    if (Environment.isExternalStorageRemovable()) {
-                                        storageDefinition = System.getenv("EXTERNAL_STORAGE");
-                                        getfilePath = storageDefinition;
-                                    } else {
-                                        splitIndex = docId.indexOf(':', 1);
-                                        tag = docId.substring(0, splitIndex);
-                                        path = docId.substring(splitIndex + 1);
-                                        if (new mInterfaceUtil().getPathToNonPrimaryVolume(cordova.getActivity(), tag) != null) {
-                                            storageDefinition = new mInterfaceUtil().getPathToNonPrimaryVolume(cordova.getActivity(), tag) + "/" + path;
-                                            file = new File(storageDefinition);
-                                            if (file.exists() && file.canRead()) {
-                                                getfilePath = storageDefinition;
-                                            }
-                                        }
-                                    }
-                                }
-                            } else if ("com.android.providers.downloads.documents".equals(uri.getAuthority())) { // DownloadsProvider
-                                id = DocumentsContract.getDocumentId(uri);
-                                final Uri contentUri = ContentUris.withAppendedId(
-                                        Uri.parse("content://downloads/public_downloads"), Long.valueOf(id));
-                                getfilePath = new mInterfaceUtil().getDataColumn(cordova.getActivity(), contentUri, null, null);
-
-                            } else if ("com.android.providers.media.documents".equals(uri.getAuthority())) { // MediaProvider
-                                docId = DocumentsContract.getDocumentId(uri);
-                                split = docId.split(":");
-                                type = split[0];
-                                Uri contentUri = null;
-                                if ("image".equals(type)) {
-                                    contentUri = MediaStore.Images.Media.EXTERNAL_CONTENT_URI;
-                                } else if ("video".equals(type)) {
-                                    contentUri = MediaStore.Video.Media.EXTERNAL_CONTENT_URI;
-                                } else if ("audio".equals(type)) {
-                                    contentUri = MediaStore.Audio.Media.EXTERNAL_CONTENT_URI;
-                                }
-                                final String selection = "_id=?";
-                                final String[] selectionArgs = new String[]{
-                                        split[1]
-                                };
-                                getfilePath = new mInterfaceUtil().getDataColumn(cordova.getActivity(), contentUri, selection, selectionArgs);
-                            }
-                            // *** API Level 19 and Above (To Get FileName,FileExtension and FileSize)**** //
-                            cursor = cordova.getActivity().getContentResolver().query(uri, null, null, null, null, null);
-                            try {
-                                if (cursor != null && cursor.moveToFirst()) {
-                                    int displayNameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
-                                    if (displayNameIndex != -1) {
-                                        fileName = cursor.getString(displayNameIndex);
-                                    } else {
-                                        fileName = "";
-                                    }
-
-                                    int fileSizeIndex = cursor.getColumnIndex(OpenableColumns.SIZE);
-                                    if (!cursor.isNull(fileSizeIndex) && fileSizeIndex != -1) {
-                                        fileSize = cursor.getString(fileSizeIndex);
-                                    } else {
-                                        fileSize = "0";
-                                    }
-                                }
-                            } finally {
-                                cursor.close();
-                            }
-                            // *** API Level 19 below and SAMSUNG (To Get FileProperties of MediaFiles)**** //
-                        } else {
-                            if (fileType != null) {
-                                String[] projection = {
-                                        MediaStore.Images.Media.DATA,
-                                        MediaStore.Images.Media.SIZE,
-                                        MediaStore.Images.Media.DISPLAY_NAME
-                                };
-                                cursor = cordova.getActivity().getContentResolver().query(uri, projection, null, null, null);
-                                if (cursor.moveToFirst()) {
-                                    getfilePath = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DATA));
-                                    fileName = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.DISPLAY_NAME));
-                                    fileSize = cursor.getString(cursor.getColumnIndexOrThrow(MediaStore.Images.Media.SIZE));
-                                }
-                                cursor.close();
-                                // API LEVEL 19 BELOW AND SAMSUNG (TO GET FILEPROPERTIES OF NORMAL FILES(EX:txt,.pdf,etc..,))
-                            } else {
-                                getfilePath = data.getData().getPath();
-                                filePath = getfilePath.substring(0, getfilePath.lastIndexOf(File.separator));
-                                getFileName = new File(getfilePath);
-                                fileName = getFileName.getName();
-                                getSize = getFileName.length();
-                                fileSize = String.valueOf(getSize);
-                            }
-                        }
-                        filePath = getfilePath.substring(0, getfilePath.lastIndexOf(File.separator));
-                        fileExtension = "." + getfilePath.substring(getfilePath.lastIndexOf(".") + 1).toLowerCase();
-                        // SEND BELOW JSON OBJECT TO PLUGIN CALLBACK
-                        if (filePath != null) {
-                            try {
-                                if (fileExtension.equals(".jpeg") || fileExtension.equals(".jpg") || fileExtension.equals(".png")) {
-                                    convertImageTo64BaseString(callback, filePath + "/" + fileName, "compress", attachmentDestPath);
-                                } else {
-                                    fileProperities = new JSONObject();
-                                    fileProperities.put("filePath", filePath);
-                                    fileProperities.put("fileName", fileName);
-                                    fileProperities.put("fileSize", fileSize);
-                                    fileProperities.put("fileExtension", fileExtension);
-                                    callback.success(fileProperities);
-                                }
-                            } catch (Exception e) {
-                                callback.error("Failed to process PICK_FILE_REQUEST");
-                            }
-                        } else {
-                            callback.error("File path was null");
-                        }
-                    } catch (Exception e) {
-                        e.printStackTrace();
+                    if (pictureFilePath != null && !pictureFilePath.isEmpty()) {
+                        File file = new File(pictureFilePath);
+                        if (file.exists()) file.delete();
                     }
-                } else if (resultCode == Activity.RESULT_CANCELED) {
                     callback.error("failure");
                 } else {
                     callback.error(resultCode);
@@ -2665,62 +2505,130 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     @Override
     public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
-        try {
-            boolean indicator = true;
-            String failedPermission = "failure";
-            for (int i = 0; i < grantResults.length; i++) {
-                if (grantResults[i] != 0) {
-                    if (permissions[i].equalsIgnoreCase("android.permission.ACCESS_BACKGROUND_LOCATION")) {
-                        failedPermission = "background_location";
-                    }
-                    indicator = false;
-                    break;
-                }
-            }
-            if (indicator) {
-                callback.success("success");
-            } else {
-                callback.error(failedPermission);
+        if (requestCode != pendingPermissionRequest || permissionCallback == null) return;
+        CallbackContext resultCallback = permissionCallback;
+        permissionCallback = null;
+        pendingPermissionRequest = -1;
+        if (grantResults.length == 0) {
+            resultCallback.error("failure");
+            return;
+        }
+        for (String permission : permissions) {
+            if (!isPermissionSatisfied(permission)) {
+                resultCallback.error(Manifest.permission.ACCESS_BACKGROUND_LOCATION.equals(permission)
+                        ? "background_location" : "failure");
+                return;
             }
-        } catch (Exception e) {
-            e.printStackTrace();
         }
+        resultCallback.success("success");
     }
 
-    public String copyFileFromUri(Context context, Uri fileUri, String fileName, String destinationPath, CallbackContext callback) {
-        InputStream inputStream;
-        OutputStream outputStream;
-        String outPutFilePath = null;
-        File saveDirectory;
-        try {
-            ContentResolver content = context.getContentResolver();
-            inputStream = content.openInputStream(fileUri);
-            File root = mInterfaceUtil.rootDirectory;
-            if (root == null) {
-                System.out.println("Failed to get root");
-            }
-            if (!destinationPath.equalsIgnoreCase("")) {
-                saveDirectory = new File(mInterfaceUtil.rootDirectory + "/" + destinationPath);
-            } else {
-                saveDirectory = new File(mInterfaceUtil.rootDirectory + "/" + mInterfaceUtil.packageName + "/" + "images");
+    private void handlePickedFile(int requestCode, int resultCode, Intent data) {
+        final CallbackContext resultCallback = callback;
+        callback = null;
+        if (resultCallback == null) return;
+        if (resultCode != RESULT_OK) {
+            attachmentDestPath = "";
+            if (resultCode == Activity.RESULT_CANCELED) resultCallback.error(requestCode == PICK_IMAGE_FROM_GALLERY ? "canceled" : "failure");
+            else resultCallback.error(resultCode);
+            return;
+        }
+        Uri selected = data == null ? null : data.getData();
+        if (selected == null && data != null && data.getClipData() != null
+                && data.getClipData().getItemCount() > 0) {
+            selected = data.getClipData().getItemAt(0).getUri();
+        }
+        final Uri uri = selected;
+        if (uri == null) {
+            attachmentDestPath = "";
+            resultCallback.error("No file was selected");
+            return;
+        }
+        final String destination = attachmentDestPath;
+        final boolean gallery = requestCode == PICK_IMAGE_FROM_GALLERY;
+        final boolean compressGallery = "true".equals(galleryAttachmentInd);
+        attachmentDestPath = "";
+        // Copy cloud/document content immediately while the picker URI grant is valid.
+        cordova.getThreadPool().execute(() -> {
+            try {
+                Context context = cordova.getActivity().getApplicationContext();
+                ContentResolver resolver = context.getContentResolver();
+                String mimeType = null;
+                try { mimeType = resolver.getType(uri); } catch (RuntimeException ignored) { }
+                String displayName = getSelectedDisplayName(resolver, uri, mimeType);
+                String extension = getExtension(displayName);
+                if (gallery && !("image/jpeg".equals(mimeType) || "image/png".equals(mimeType)
+                        || "image/heic".equals(mimeType) || "image/heif".equals(mimeType)
+                        || ".jpg".equals(extension) || ".jpeg".equals(extension)
+                        || ".png".equals(extension) || ".heic".equals(extension) || ".heif".equals(extension))) {
+                    resultCallback.error("Only JPEG, PNG or HEIC images are allowed to attach.");
+                    return;
+                }
+                // A gallery import is an intermediate file, never the user's original photo.
+                String path = copySelectedFile(context, uri, displayName, gallery ? "" : destination);
+                File imported = new File(path);
+                boolean image = gallery || (mimeType != null && mimeType.startsWith("image/"))
+                        || ".heic".equals(extension) || ".heif".equals(extension);
+                if (image) {
+                    convertImageTo64BaseStringAsync(resultCallback, path,
+                            gallery && !compressGallery ? "gallery" : "compress", destination, true);
+                } else {
+                    JSONObject properties = new JSONObject();
+                    properties.put("filePath", imported.getParent());
+                    properties.put("fileName", imported.getName());
+                    properties.put("fileSize", imported.length());
+                    properties.put("fileExtension", getExtension(imported.getName()));
+                    properties.put("thumbnail", getFileThumbnail(path, getExtension(imported.getName())));
+                    resultCallback.success(properties);
+                }
+            } catch (Exception e) {
+                resultCallback.error("Unable to read the selected file: " + e.getMessage());
             }
+        });
+    }
 
-            saveDirectory.mkdirs();
-            outPutFilePath = saveDirectory + "/" + fileName;
-            outputStream = new FileOutputStream(outPutFilePath);
-            if (outputStream != null) {
-                byte[] buffer = new byte[1000];
-                int bytesRead = 0;
-                while ((bytesRead = inputStream.read(buffer, 0, buffer.length)) >= 0) {
-                    outputStream.write(buffer, 0, buffer.length);
-                }
-            } else {
-                callback.error("Error occurred in opening outputStream");
+    private String getSelectedDisplayName(ContentResolver resolver, Uri uri, String mimeType) {
+        String name = null;
+        try (Cursor cursor = resolver.query(uri, new String[]{OpenableColumns.DISPLAY_NAME}, null, null, null)) {
+            if (cursor != null && cursor.moveToFirst()) {
+                int column = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME);
+                if (column >= 0) name = cursor.getString(column);
             }
+        } catch (RuntimeException ignored) {
+            // Providers are not required to supply a display name.
+        }
+        if (name == null || name.trim().isEmpty()) name = "attachment";
+        if (getExtension(name).isEmpty() && mimeType != null) {
+            String extension = MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType);
+            if (extension != null) name += "." + extension;
+        }
+        return name;
+    }
+
+    private String getExtension(String name) {
+        int dot = name.lastIndexOf('.');
+        return dot > 0 ? name.substring(dot).toLowerCase(Locale.ROOT) : "";
+    }
+
+    private String copySelectedFile(Context context, Uri uri, String fileName, String destinationPath) throws IOException {
+        File root = mInterfaceUtil.rootDirectory;
+        if (root == null) throw new IOException("App storage is unavailable");
+        File directory = new File(root, TextUtils.isEmpty(destinationPath)
+                ? mInterfaceUtil.packageName + "/images" : destinationPath);
+        String rootPath = root.getCanonicalPath() + File.separator;
+        if (!directory.getCanonicalPath().startsWith(rootPath)) {
+            throw new IOException("Attachment destination must be inside app storage");
+        }
+        return AttachmentFileIO.copy(context.getContentResolver().openInputStream(uri), directory, fileName).getAbsolutePath();
+    }
+
+    public String copyFileFromUri(Context context, Uri uri, String fileName, String destinationPath, CallbackContext resultCallback) {
+        try {
+            return copySelectedFile(context, uri, fileName, destinationPath);
         } catch (Exception e) {
-            callback.error("copyFileFromUri failed, exception is : " + e.getMessage());
+            resultCallback.error("copyFileFromUri failed: " + e.getMessage());
+            return null;
         }
-        return outPutFilePath;
     }
 
     /* CHECKING THE BACKGROUND SERVICE RUNNING OR NOT */
@@ -2801,36 +2709,31 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             final Status status = locationSettingsResult.getStatus();
             switch (status.getStatusCode()) {
                 case LocationSettingsStatusCodes.SUCCESS:
+                    callback.success();
                     break;
                 case LocationSettingsStatusCodes.RESOLUTION_REQUIRED:
                     try {
                         this.cordova.setActivityResultCallback(this);
                         status.startResolutionForResult(this.cordova.getActivity(), LOCATION_ACCURACY_REQUEST_NEW);
                     } catch (IntentSender.SendIntentException e) {
-                        System.out.println("PendingIntent unable to execute request: ");
+                        callback.error("Unable to open location settings: " + e.getMessage());
                     }
                     break;
                 case LocationSettingsStatusCodes.SETTINGS_CHANGE_UNAVAILABLE:
-                    System.out.println("Location settings are inadequate, and cannot be fixed here. Dialog not created.");
+                    callback.error("Location settings cannot be changed on this device");
+                    break;
+                default:
+                    callback.error("Unable to check location settings: " + status.getStatusCode());
                     break;
             }
         } catch (Exception e) {
-            System.out.println("LocationSettingsResult failed, exception is : " + e.getMessage());
+            callback.error("LocationSettingsResult failed, exception is : " + e.getMessage());
         }
     }
 
     @Override
     public void onLocationChanged(@NonNull Location location) {
         mCurrentLocation1 = location;
-        try {
-            System.out.println(mCurrentLocation1.getLatitude() + "," + mCurrentLocation1.getLongitude());
-            if (currentLocationInd.equals("true")) {
-                currentLocationInd = "";
-                callback.success(mCurrentLocation1.getLatitude() + "," + mCurrentLocation1.getLongitude());
-            }
-        } catch (Exception e) {
-            callback.error("onLocationChanged failed, exception is : " + e.getMessage());
-        }
     }
 
     private class DownloadTask extends AsyncTask<String, Integer, String> {