cordova-plugin-mserviceinterface-2.0 1.0.103 → 1.0.105

package/src/android/mInterface.java

@@ -1,5 +1,21 @@
 package com.selfservit.util;
 
+import com.google.android.gms.tasks.CancellationTokenSource;
+
+import com.google.android.gms.location.CurrentLocationRequest;
+
+import com.google.android.gms.common.GoogleApiAvailability;
+
+import androidx.core.location.LocationManagerCompat;
+
+import android.os.SystemClock;
+
+import android.os.Looper;
+
+import android.os.Handler;
+
+import android.location.LocationManager;
+
 import static android.app.Activity.RESULT_OK;
 
 import android.Manifest;
@@ -9,7 +25,7 @@ import android.app.AlertDialog;
 import android.app.PendingIntent;
 import android.app.ProgressDialog;
 import android.content.ContentResolver;
-import android.content.ActivityNotFoundException;
+import android.content.ContentUris;
 import android.content.Context;
 import android.content.DialogInterface;
 import android.content.Intent;
@@ -35,6 +51,7 @@ import android.os.AsyncTask;
 import android.os.Build;
 import android.os.Bundle;
 import android.os.Environment;
+import android.provider.DocumentsContract;
 import android.provider.MediaStore;
 import android.provider.OpenableColumns;
 import android.provider.Settings;
@@ -42,6 +59,7 @@ 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;
@@ -100,7 +118,6 @@ 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;
@@ -117,11 +134,6 @@ 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";
@@ -140,7 +152,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;
@@ -158,7 +169,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         try {
             super.onResume(multitasking);
             //To avoid starting service after getting permissions initially.
-            if (!mInterfaceUtil.deviceID.equalsIgnoreCase("")) {
+            if (!mInterfaceUtil.deviceID.equalsIgnoreCase("") || isServiceRunning(mInterfaceService.class)) {
+                // Re-evaluate an existing service too: legacy JS may skip StartService.
                 mInterfaceService.start(cordova.getActivity());
             }
         } catch (Exception e) {
@@ -174,6 +186,8 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     @Override
     public void onDestroy() {
+        locationPluginDestroyed = true;
+        cancelCurrentLocationRequest();
         mInterfaceService.stopIfNotTracking(cordova.getActivity());
         if (mGoogleApiClient1 != null) {
             if (mGoogleApiClient1.isConnected()) {
@@ -184,6 +198,12 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
         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 {
@@ -219,11 +239,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 try {
                     boolean appInfoUpdated = new mInterfaceUtil().updateAppInfo(args);
                     System.out.println("appInfoUpdated: " + appInfoUpdated);
-                    if (mInterfaceService.start(cordova.getActivity())) {
-                        callbackContext.success("Success");
-                    } else {
-                        callbackContext.error("Unable to start service while the app is in the background");
+                    if (!mInterfaceService.start(cordova.getActivity())) {
+                        throw new IllegalStateException("Service start deferred until the app is visible or permitted");
                     }
+                    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());
@@ -491,6 +510,7 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                         str = "true";
                         System.out.println("service check is: " + str + " " + isServiceRunning(mInterfaceService.class));
                     }
+                    mInterfaceService.start(cordova.getActivity());
                     callbackContext.success(str);
                 } catch (Exception e) {
                     callbackContext.error(e.getMessage());
@@ -622,19 +642,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;
@@ -904,8 +913,6 @@ 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");
@@ -917,8 +924,6 @@ 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");
@@ -1494,6 +1499,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();
@@ -1578,6 +1699,7 @@ 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 +1717,12 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     }
                 }
                 if (!permissionGranted) {
-                    callbackContext.error("failure");
+                    callback.error("failure");
                 } else {
-                    callbackContext.success("success");
+                    callback.success("success");
                 }
             } else {
-                callbackContext.success("success");
+                callback.success("success");
             }
         } catch (Exception e) {
             e.printStackTrace();
@@ -1615,106 +1737,69 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     }
 
     private void getLocationPermission(JSONArray args, CallbackContext callbackContext) {
+        boolean permissionGranted = true;
+        List<String> list;
         try {
-            requestPermissionsIfNeeded(normalizePermissions(args, false), REQUEST_LOCATION_PERMISSION, callbackContext);
+            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");
+            }
         } catch (Exception e) {
-            callbackContext.error("getLocationPermission failed: " + e.getMessage());
+            e.printStackTrace();
         }
     }
    
     private void getPermissions(JSONArray args, CallbackContext callbackContext) {
+        boolean permissionGranted = true;
+        List<String> list;
         try {
-            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;
+            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");
             }
-        }
-        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) {
-            permissionCallback = null;
-            pendingPermissionRequest = -1;
-            callbackContext.error("Unable to request permission: " + e.getMessage());
+            callback.error("getPermissions failed, exception is : " + 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;
@@ -1722,7 +1807,6 @@ 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) {
@@ -1737,14 +1821,11 @@ 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);
@@ -1754,32 +1835,26 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     void pickImageFromGallery(CallbackContext callbackContext) {
         try {
-            callback = callbackContext;
-            Intent intent;
-            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
-                intent = new Intent(MediaStore.ACTION_PICK_IMAGES);
-                intent.setType("image/*");
+            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/*");
             } else {
-                intent = new Intent(Intent.ACTION_OPEN_DOCUMENT);
-                intent.setType("image/*");
-                intent.addCategory(Intent.CATEGORY_OPENABLE);
-            }
-            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);
+                i = new Intent(Intent.ACTION_OPEN_DOCUMENT);
+                i.addCategory(Intent.CATEGORY_OPENABLE);
+                i.setType("image/*");
+                i.putExtra(Intent.EXTRA_LOCAL_ONLY, true);
             }
-            PluginResult result = new PluginResult(PluginResult.Status.NO_RESULT);
-            result.setKeepCallback(true);
-            callbackContext.sendPluginResult(result);
+            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);
+
+
         } catch (Exception e) {
-            callbackContext.error("pickImageFromGallery failed: " + e.getMessage());
+            callbackContext.error("pickImageFromGallery failed, exception is : " + e.getMessage());
         }
     }
     
@@ -1970,10 +2045,10 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                         fileProperities.put("fileExtension", fileExtension);
                         fileProperities.put("thumbnail", thumbnail);
                         attachmentDestPath = "";
-                        callbackContext.success(fileProperities);
+                        callback.success(fileProperities);
                     } catch (Exception e) {
                         attachmentDestPath = "";
-                        callbackContext.error("convertImageTo64BaseString failed, exception is : " + e.getMessage());
+                        callback.error("convertImageTo64BaseString failed, exception is : " + e.getMessage());
                     }
                 }
             } catch (Exception e) {
@@ -1982,7 +2057,7 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
             }
 
         } catch (Exception e) {
-            callbackContext.error("convertImageTo64BaseString failed: " + e.getMessage());
+            e.printStackTrace();
         }
 
     }
@@ -2017,11 +2092,23 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
     }
 
     public Intent getPickImageChooserIntent() {
-        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");
+        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;
     }
 
     //App version plugin
@@ -2039,31 +2126,35 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     //Rotate Screen plugin
     public void rotateScreen(JSONArray args, CallbackContext callbackContext) {
-        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());
+        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);
+            }
+            callbackContext.success(currentOrientation);
+        } catch (Exception e) {
+            callbackContext.success("rotateScreen failed, exception is : " + e.getMessage());
+        }
     }
 
     public void deviceInfo(CallbackContext callbackContext) {
@@ -2161,20 +2252,12 @@ 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("/");
@@ -2193,20 +2276,33 @@ 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);
-                        String rootPath = mInterfaceUtil.rootDirectory.getCanonicalPath() + File.separator;
-                        if (!outDir.getCanonicalPath().startsWith(rootPath)) {
-                            throw new IOException("Attachment destination must be inside app storage");
+                        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();
                         }
-                        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());
@@ -2215,37 +2311,25 @@ 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;
 
-                    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) { }
+                    // 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);
                     }
                     if (bitmap == null) {
                         postError(cb, "decode_failed");
@@ -2262,18 +2346,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 {
-                    if (compressedTemp != null && !compressedTemp.getAbsolutePath().equals(imageSourcePath)) compressedTemp.delete();
-                    if (deleteImported) new File(imageSourcePath).delete();
+                    try { if (srcFileReader != null) srcFileReader.close(); } catch (Exception ignore) {}
+                    try { if (desFileWriter != null) desFileWriter.close(); } catch (Exception ignore) {}
                     try { if (baos != null) baos.close(); } catch (Exception ignore) {}
                     try { if (bitmap != null) bitmap.recycle(); } catch (Exception ignore) {}
                 }
@@ -2283,10 +2367,12 @@ 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();
         try {
-            return copySelectedFile(ctx, uri, destName, destDir);
-        } catch (IOException e) {
-            android.util.Log.e("mInterface", "copyFileFromUriFast", e);
+            return AttachmentFileIO.copy(ctx.getContentResolver().openInputStream(uri), dir, destName).getAbsolutePath();
+        } catch (Exception e) {
+            android.util.Log.w("mInterface", "Unable to import selected attachment");
             return null;
         }
     }
@@ -2298,17 +2384,15 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                 case LOCATION_ACCURACY_REQUEST_NEW:
                     switch (resultCode) {
                         case Activity.RESULT_OK:
-                            if (mInterfaceService.start(cordova.getActivity())) {
-                                callback.success();
-                            } else {
-                                callback.error("Unable to resume location service");
-                            }
+                            mInterfaceService mInterfaceService = new mInterfaceService();
+                            mInterfaceService.startLocationUpdates(cordova.getContext());
+                            callback.success();
                             break;
                         case Activity.RESULT_CANCELED:
                             callback.error("oops! you have cancelled...");
                             break;
                     }
-                    return;
+                    break;
             }
             if (SCANCODEINT == 118 && callback != null) {
                 if (resultCode == RESULT_OK) {
@@ -2334,12 +2418,177 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
                     SCANCODEINT = 0;
                     callback.error(resultCode);
                 }
-            } 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 == 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);
+                    if (filePath == null) return;
+                    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 == REQUEST_IMAGE_CAPTURE && callback != null) {
                 if (resultCode == RESULT_OK) {
-                    String imagePath = data == null ? null : data.getStringExtra("imagePath");
+                    String imagePath = data.getStringExtra("imagePath");
                     if (imagePath != null && !imagePath.isEmpty()) {
                         pictureFilePath = imagePath;
                         if (cameraAttachmentInd.equals("true")) {
@@ -2351,10 +2600,12 @@ 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);
@@ -2363,10 +2614,158 @@ 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) {
-                    if (pictureFilePath != null && !pictureFilePath.isEmpty()) {
-                        File file = new File(pictureFilePath);
-                        if (file.exists()) file.delete();
+                    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();
                     }
+                } else if (resultCode == Activity.RESULT_CANCELED) {
                     callback.error("failure");
                 } else {
                     callback.error(resultCode);
@@ -2381,128 +2780,36 @@ public class mInterface extends CordovaPlugin implements com.google.android.gms.
 
     @Override
     public void onRequestPermissionResult(int requestCode, String[] permissions, int[] grantResults) {
-        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;
-            }
-        }
-        resultCallback.success("success");
-    }
-
-    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);
+        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;
                 }
-            } catch (Exception e) {
-                resultCallback.error("Unable to read the selected file: " + e.getMessage());
             }
-        });
-    }
-
-    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);
+            if (indicator) {
+                callback.success("success");
+            } else {
+                callback.error(failedPermission);
             }
-        } 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");
+        } catch (Exception e) {
+            e.printStackTrace();
         }
-        return AttachmentFileIO.copy(context.getContentResolver().openInputStream(uri), directory, fileName).getAbsolutePath();
     }
 
-    public String copyFileFromUri(Context context, Uri uri, String fileName, String destinationPath, CallbackContext resultCallback) {
+    public String copyFileFromUri(Context context, Uri fileUri, String fileName, String destinationPath, CallbackContext callback) {
         try {
-            return copySelectedFile(context, uri, fileName, destinationPath);
+            File saveDirectory = destinationPath != null && !destinationPath.isEmpty()
+                    ? new File(mInterfaceUtil.rootDirectory, destinationPath)
+                    : new File(mInterfaceUtil.rootDirectory, mInterfaceUtil.packageName + "/images");
+            return AttachmentFileIO.copy(context.getContentResolver().openInputStream(fileUri), saveDirectory, fileName).getAbsolutePath();
         } catch (Exception e) {
-            resultCallback.error("copyFileFromUri failed: " + e.getMessage());
+            callback.error("copyFileFromUri failed, exception is : " + e.getMessage());
             return null;
         }
     }
@@ -2585,36 +2892,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> {