cordova-plugin-mserviceinterface-2.0 1.0.101 → 1.0.103

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "cordova-plugin-mserviceinterface-2.0",
-  "version": "1.0.101",
+  "version": "1.0.103",
   "description": "This plugin establishes the connection to the native interface and performs the requested task.",
   "main": "index.js",
   "scripts": {

package/plugin.xml

@@ -1,6 +1,6 @@
 <?xml version="1.0" encoding="UTF-8"?>
 <plugin xmlns="http://apache.org/cordova/ns/plugins/1.0"
-    xmlns:android="http://schemas.android.com/apk/res/android" id="cordova-plugin-mserviceinterface-2.0" version="1.0.101">
+    xmlns:android="http://schemas.android.com/apk/res/android" id="cordova-plugin-mserviceinterface-2.0" version="1.0.103">
     <name>mserviceinterface-2.0</name>
     <description>This plugin establishes the connection to the native interface and performs the requested task.</description>
     <author>selfservit@gmail.com</author>

package/src/android/AttachmentFileIO.java

@@ -0,0 +1,59 @@
+package com.selfservit.util;
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.IOException;
+import java.io.InputStream;
+import java.io.OutputStream;
+
+/** Copies a provider stream into an app-owned file without assuming a filesystem URI. */
+final class AttachmentFileIO {
+    private AttachmentFileIO() { }
+
+    static File copy(InputStream input, File directory, String displayName) throws IOException {
+        File outputFile = null;
+        boolean complete = false;
+        try {
+            try (InputStream source = input) {
+                if (source == null) {
+                    throw new IOException("The selected file is no longer available");
+                }
+                if (!directory.isDirectory() && !directory.mkdirs()) {
+                    throw new IOException("Cannot create attachment directory");
+                }
+                String name = displayName == null ? "attachment" : displayName;
+                // Provider display names are labels, never paths.
+                name = name.replaceAll("[\\\\/\\p{Cntrl}:*?\"<>|]", "_").trim();
+                if (name.isEmpty() || name.equals(".") || name.equals("..")) {
+                    name = "attachment";
+                }
+                int dot = name.lastIndexOf('.');
+                String stem = dot > 0 ? name.substring(0, dot) : name;
+                String suffix = dot > 0 ? name.substring(dot) : "";
+                // Bound provider-supplied names, retaining normal filename extensions.
+                stem = stem.substring(0, Math.min(stem.length(), 80));
+                suffix = suffix.substring(0, Math.min(suffix.length(), 20));
+                outputFile = File.createTempFile(stem + "_attachment_", suffix, directory);
+                try (OutputStream output = new FileOutputStream(outputFile)) {
+                    byte[] buffer = new byte[8192];
+                    int count;
+                    while ((count = source.read(buffer)) != -1) {
+                        if (count == 0) {
+                            int next = source.read();
+                            if (next == -1) break;
+                            output.write(next);
+                        } else {
+                            output.write(buffer, 0, count);
+                        }
+                    }
+                }
+            }
+            complete = true;
+        } finally {
+            if (!complete && outputFile != null && outputFile.exists()) {
+                outputFile.delete();
+            }
+        }
+        return outputFile;
+    }
+}

package/src/android/CameraActivity.java

@@ -3,14 +3,20 @@ package com.selfservit.util;
 import android.Manifest;
 import android.annotation.SuppressLint;
 import android.app.Activity;
+import android.content.Context;
 import android.content.Intent;
 import android.content.pm.PackageManager;
+import android.content.res.Configuration;
+import android.hardware.display.DisplayManager;
 import android.os.Bundle;
+import android.os.Handler;
+import android.os.Looper;
 import android.util.Log;
+import android.view.Display;
 import android.view.MotionEvent;
 import android.view.ScaleGestureDetector;
+import android.view.Surface;
 import android.view.View;
-import android.view.ViewGroup;
 import android.widget.ImageButton;
 import android.widget.Toast;
 
@@ -27,6 +33,10 @@ import androidx.camera.lifecycle.ProcessCameraProvider;
 import androidx.camera.view.PreviewView;
 import androidx.core.app.ActivityCompat;
 import androidx.core.content.ContextCompat;
+import androidx.core.graphics.Insets;
+import androidx.core.view.ViewCompat;
+import androidx.core.view.WindowCompat;
+import androidx.core.view.WindowInsetsCompat;
 
 import com.google.common.util.concurrent.ListenableFuture;
 
@@ -46,6 +56,26 @@ public class CameraActivity extends AppCompatActivity {
     private ImageButton torchButton;
     private ProcessCameraProvider cameraProvider;
     private Camera camera;
+    private View cameraControls;
+    private DisplayManager displayManager;
+    private int torchOnDrawable;
+    private int torchOffDrawable;
+
+    private final DisplayManager.DisplayListener displayListener = new DisplayManager.DisplayListener() {
+        @Override
+        public void onDisplayAdded(int displayId) {}
+
+        @Override
+        public void onDisplayRemoved(int displayId) {}
+
+        @Override
+        public void onDisplayChanged(int displayId) {
+            Display display = previewView == null ? null : previewView.getDisplay();
+            if (display != null && display.getDisplayId() == displayId) {
+                updateCaptureRotation();
+            }
+        }
+    };
 
     private int lensFacing = CameraSelector.LENS_FACING_BACK;
     private boolean isTorchOn = false;
@@ -57,6 +87,17 @@ public class CameraActivity extends AppCompatActivity {
     protected void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
+        // Let the system handle predictive Back while preserving the plugin's cancellation result.
+        Intent cancelled = new Intent();
+        cancelled.putExtra("result", "cancelled");
+        setResult(Activity.RESULT_CANCELED, cancelled);
+        if (savedInstanceState != null) {
+            lensFacing = savedInstanceState.getInt("lensFacing", CameraSelector.LENS_FACING_BACK);
+            isTorchOn = savedInstanceState.getBoolean("isTorchOn", false);
+        }
+        displayManager = (DisplayManager) getSystemService(Context.DISPLAY_SERVICE);
+        WindowCompat.setDecorFitsSystemWindows(getWindow(), false);
+
         // Dynamically inflate layout
         String pkg = getPackageName();
         int layoutId = getResources().getIdentifier("activity_camera", "layout", pkg);
@@ -68,10 +109,11 @@ public class CameraActivity extends AppCompatActivity {
         int switchId      = getResources().getIdentifier("switchCamera",   "id", pkg);
         int torchId       = getResources().getIdentifier("torchButton",    "id", pkg);
         int focusViewId       = getResources().getIdentifier("focusView",    "id", pkg);
+        int controlsId = getResources().getIdentifier("cameraControls", "id", pkg);
 
         // Resolve drawable IDs
-        final int torchOnDrawable  = getResources().getIdentifier("ic_flashlight_on",  "drawable", pkg);
-        final int torchOffDrawable = getResources().getIdentifier("ic_flashlight_off", "drawable", pkg);
+        torchOnDrawable  = getResources().getIdentifier("ic_flashlight_on",  "drawable", pkg);
+        torchOffDrawable = getResources().getIdentifier("ic_flashlight_off", "drawable", pkg);
 
         // Bind views to fields
         previewView   = findViewById(previewId);
@@ -79,6 +121,9 @@ public class CameraActivity extends AppCompatActivity {
         ImageButton switchButton  = findViewById(switchId);
          torchButton   = findViewById(torchId);
         focusView =  findViewById(focusViewId);
+        cameraControls = findViewById(controlsId);
+        applyControlInsets();
+        previewView.post(this::updateCaptureRotation);
 
         // Utility to add press animation to any view
         View.OnTouchListener pressAnim = (v, e) -> {
@@ -185,6 +230,7 @@ public class CameraActivity extends AppCompatActivity {
             lensFacing = (lensFacing == CameraSelector.LENS_FACING_BACK)
                     ? CameraSelector.LENS_FACING_FRONT
                     : CameraSelector.LENS_FACING_BACK;
+            isTorchOn = false;
             bindUseCases();
         });
 
@@ -198,11 +244,69 @@ public class CameraActivity extends AppCompatActivity {
         });
     }
 
+    private void applyControlInsets() {
+        final int left = cameraControls.getPaddingLeft();
+        final int top = cameraControls.getPaddingTop();
+        final int right = cameraControls.getPaddingRight();
+        final int bottom = cameraControls.getPaddingBottom();
+        ViewCompat.setOnApplyWindowInsetsListener(cameraControls, (view, windowInsets) -> {
+            Insets safeInsets = windowInsets.getInsets(
+                    WindowInsetsCompat.Type.systemBars() | WindowInsetsCompat.Type.displayCutout());
+            view.setPadding(left + safeInsets.left, top + safeInsets.top,
+                    right + safeInsets.right, bottom + safeInsets.bottom);
+            return windowInsets;
+        });
+        cameraControls.post(() -> ViewCompat.requestApplyInsets(cameraControls));
+    }
+
+    @Override
+    protected void onStart() {
+        super.onStart();
+        if (displayManager != null) {
+            displayManager.registerDisplayListener(displayListener, new Handler(Looper.getMainLooper()));
+        }
+        previewView.post(this::updateCaptureRotation);
+    }
+
+    @Override
+    protected void onStop() {
+        if (displayManager != null) {
+            displayManager.unregisterDisplayListener(displayListener);
+        }
+        super.onStop();
+    }
+
+    @Override
+    public void onConfigurationChanged(@NonNull Configuration newConfig) {
+        super.onConfigurationChanged(newConfig);
+        previewView.post(this::updateCaptureRotation);
+        ViewCompat.requestApplyInsets(cameraControls);
+    }
+
+    @Override
+    protected void onSaveInstanceState(@NonNull Bundle outState) {
+        outState.putInt("lensFacing", lensFacing);
+        outState.putBoolean("isTorchOn", isTorchOn);
+        super.onSaveInstanceState(outState);
+    }
+
+    private int getCaptureRotation() {
+        Display display = previewView == null ? null : previewView.getDisplay();
+        return display == null ? Surface.ROTATION_0 : display.getRotation();
+    }
+
+    private void updateCaptureRotation() {
+        if (imageCapture != null && previewView.getDisplay() != null) {
+            imageCapture.setTargetRotation(getCaptureRotation());
+        }
+    }
+
     private void startCamera() {
         ListenableFuture<ProcessCameraProvider> future =
                 ProcessCameraProvider.getInstance(this);
         future.addListener(() -> {
             try {
+                if (isFinishing() || isDestroyed()) return;
                 cameraProvider = future.get();
                 bindUseCases();
             } catch (ExecutionException | InterruptedException e) {
@@ -224,6 +328,7 @@ public class CameraActivity extends AppCompatActivity {
         // Image capture use-case
         imageCapture = new ImageCapture.Builder()
                 .setCaptureMode(ImageCapture.CAPTURE_MODE_MINIMIZE_LATENCY)
+                .setTargetRotation(getCaptureRotation())
                 .build();
 
         // Select camera
@@ -238,14 +343,17 @@ public class CameraActivity extends AppCompatActivity {
         boolean hasFlash = camera.getCameraInfo().hasFlashUnit();
         if (hasFlash) {
             torchButton.setVisibility(View.VISIBLE);
+            camera.getCameraControl().enableTorch(isTorchOn);
         } else {
             torchButton.setVisibility(View.GONE);
             // reset state in case you were mid-toggle
             isTorchOn = false;
         }
+        torchButton.setImageResource(isTorchOn ? torchOnDrawable : torchOffDrawable);
     }
     private void takePhoto() {
         if (imageCapture == null) return;
+        updateCaptureRotation();
 
         // Prepare output file
         File photoFile = new File(getCacheDir(),
@@ -316,13 +424,6 @@ public class CameraActivity extends AppCompatActivity {
         return true;
     }
     @Override
-    public void onBackPressed() {
-        Intent intent = new Intent();
-        intent.putExtra("result", "cancelled");
-        setResult(Activity.RESULT_CANCELED, intent);
-        finish();
-    }
-    @Override
     public void onRequestPermissionsResult(int rc, @NonNull String[] perms,
                                            @NonNull int[] results) {
         super.onRequestPermissionsResult(rc, perms, results);

package/src/android/GeofenceBroadcastReceiver.java

@@ -1,16 +1,19 @@
 package com.selfservit.util;
 
+import android.Manifest;
 import android.app.NotificationChannel;
 import android.app.NotificationManager;
 import android.app.PendingIntent;
 import android.content.BroadcastReceiver;
 import android.content.Context;
 import android.content.Intent;
+import android.content.pm.PackageManager;
 import android.os.Build;
 import android.util.Log;
 import android.widget.Toast;
 import androidx.core.app.NotificationCompat;
 import androidx.core.app.NotificationManagerCompat;
+import androidx.core.content.ContextCompat;
 
 import com.google.android.gms.location.Geofence;
 import com.google.android.gms.location.GeofencingEvent;
@@ -22,6 +25,7 @@ import java.io.FileOutputStream;
 import java.io.FileWriter;
 import java.io.IOException;
 import java.io.OutputStreamWriter;
+import java.util.List;
 import java.util.UUID;
 
 public class GeofenceBroadcastReceiver extends BroadcastReceiver {
@@ -31,29 +35,76 @@ public class GeofenceBroadcastReceiver extends BroadcastReceiver {
 
     @Override
     public void onReceive(Context context, Intent intent) {
-        GeofencingEvent geofencingEvent = GeofencingEvent.fromIntent(intent);
+        if (intent == null) {
+            Log.w(TAG, "Ignoring null geofence intent");
+            return;
+        }
+        GeofencingEvent geofencingEvent;
+        String enterMessage;
+        String exitMessage;
+        try {
+            geofencingEvent = GeofencingEvent.fromIntent(intent);
+            enterMessage = intent.getStringExtra("enterMessage");
+            exitMessage = intent.getStringExtra("exitMessage");
+        } catch (RuntimeException e) {
+            Log.e(TAG, "Ignoring malformed geofence intent", e);
+            return;
+        }
 
+        if (geofencingEvent == null) {
+            Log.w(TAG, "Ignoring intent without a geofencing event");
+            return;
+        }
         if (geofencingEvent.hasError()) {
             Log.e(TAG, "GeofencingEvent error: " + geofencingEvent.getErrorCode());
             return;
         }
-        String enterMessage = intent.getStringExtra("enterMessage");
-        String exitMessage = intent.getStringExtra("exitMessage");
         int geofenceTransition = geofencingEvent.getGeofenceTransition();
         if (geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ||
                 geofenceTransition == Geofence.GEOFENCE_TRANSITION_EXIT) {
             String transitionType = geofenceTransition == Geofence.GEOFENCE_TRANSITION_ENTER ? "enter" : "exit";
+            List<Geofence> triggeringGeofences = geofencingEvent.getTriggeringGeofences();
+            if (triggeringGeofences == null || triggeringGeofences.isEmpty()) {
+                Log.w(TAG, "Ignoring event without triggering geofences");
+                return;
+            }
 
-            for (Geofence geofence : geofencingEvent.getTriggeringGeofences()) {
+            for (Geofence geofence : triggeringGeofences) {
+                if (geofence == null) {
+                    Log.w(TAG, "Ignoring null triggering geofence");
+                    continue;
+                }
                 String geofenceId = geofence.getRequestId();
+                if (!isValidGeofenceId(geofenceId)) {
+                    Log.w(TAG, "Ignoring geofence with an invalid request ID");
+                    continue;
+                }
                 writeEventToJsonFile(context, geofenceId, transitionType);
-                createNotificationChannel(context);
                 String message = (transitionType.equals("enter") ? enterMessage : exitMessage);
                 sendNotification(context, "GeoFence", message);
 //                showToast(context, "Geofence " + transitionType + ": " + geofenceId);
             }
         }
     }
+
+    private static boolean isValidGeofenceId(String geofenceId) {
+        if (geofenceId == null) return false;
+        String[] parameters = geofenceId.split("--", -1);
+        if (parameters.length < 4) return false;
+        for (String parameter : parameters) {
+            if (parameter.isEmpty() || parameter.equals(".") || parameter.equals("..")) {
+                return false;
+            }
+            for (int i = 0; i < parameter.length(); i++) {
+                char character = parameter.charAt(i);
+                if (character == '/' || character == '\\' || Character.isISOControl(character)) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+
     private void showToast(Context context, String message) {
         //Toast.makeText(context.getApplicationContext(), message, Toast.LENGTH_LONG).show();
     }
@@ -63,18 +114,23 @@ public class GeofenceBroadcastReceiver extends BroadcastReceiver {
             JSONObject jsonObject = new JSONObject();
             jsonObject.put("eventName", eventType);
             jsonObject.put("geofenceID", geofenceId);
-            String[] parameters = geofenceId.split("--");
-            fileDirectory = new File(new File(context.getExternalFilesDir(""), "") + "/" + parameters[0] + "/" + parameters[1] + "/" + parameters[2] + "/" + parameters[3] + "/" + "geofence");
-            if (!fileDirectory.exists()) {
-                boolean success = fileDirectory.mkdirs();
-                if (!success) {
-                    System.out.println("Directory not created");
-                }
-            };
+            String[] parameters = geofenceId.split("--", -1);
+            fileDirectory = context.getExternalFilesDir("");
+            if (fileDirectory == null) {
+                Log.w(TAG, "External app storage is unavailable for geofence event");
+                return;
+            }
+            for (int i = 0; i < 4; i++) {
+                fileDirectory = new File(fileDirectory, parameters[i]);
+            }
+            fileDirectory = new File(fileDirectory, "geofence");
+            if (!fileDirectory.isDirectory() && !fileDirectory.mkdirs()) {
+                throw new IOException("Unable to create geofence event directory");
+            }
             notificationsFile = new File(fileDirectory, geofenceId + "--" + eventType + ".json");
-            FileWriter fw = new FileWriter(notificationsFile);
-            fw.write(mInterfaceUtil.encrypt(jsonObject.toString()));
-            fw.close();
+            try (FileWriter fw = new FileWriter(notificationsFile)) {
+                fw.write(mInterfaceUtil.encrypt(jsonObject.toString()));
+            }
             Log.i(TAG, "Event written to file: " + geofenceId + ".json");
         } catch (Exception e) {
             Log.e(TAG, "Error writing event to JSON file", e);
@@ -83,6 +139,26 @@ public class GeofenceBroadcastReceiver extends BroadcastReceiver {
 
     private void sendNotification(Context context, String title, String message) {
         try {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU
+                && ContextCompat.checkSelfPermission(context, Manifest.permission.POST_NOTIFICATIONS)
+                != PackageManager.PERMISSION_GRANTED) {
+            Log.i(TAG, "Skipping geofence notification; notification permission is not granted");
+            return;
+        }
+        if (!NotificationManagerCompat.from(context).areNotificationsEnabled()) {
+            Log.i(TAG, "Skipping geofence notification; notifications are disabled");
+            return;
+        }
+        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+        if (notificationManager == null) return;
+        createNotificationChannel(context);
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+            NotificationChannel channel = notificationManager.getNotificationChannel(CHANNEL_ID);
+            if (channel != null && channel.getImportance() == NotificationManager.IMPORTANCE_NONE) {
+                Log.i(TAG, "Skipping geofence notification; notification channel is disabled");
+                return;
+            }
+        }
         String notification_icon, notification_color, app_name;
         int imageResource,notification_color_id;
         String packageName = context.getPackageName();
@@ -104,15 +180,17 @@ public class GeofenceBroadcastReceiver extends BroadcastReceiver {
                 .setAutoCancel(true)
                 .setColor(context.getResources().getColor(notification_color_id))
                 .setContentIntent(pendingIntent);
-        NotificationManager notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
         if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
             NotificationChannel channel = new NotificationChannel(CHANNEL_ID, "Channel human readable title", NotificationManager.IMPORTANCE_DEFAULT);
             notificationManager.createNotificationChannel(channel);
-        };
+        }
         int notificationId = UUID.randomUUID().hashCode();
         notificationManager.notify(notificationId, notificationBuilder.build());
         } catch (ClassNotFoundException e) {
-            throw new RuntimeException(e);
+            Log.e(TAG, "Unable to open the app from geofence notification", e);
+        } catch (RuntimeException e) {
+            // Permission or notification settings can change after the checks above.
+            Log.e(TAG, "Unable to show geofence notification", e);
         }
     }
 
@@ -124,7 +202,9 @@ public class GeofenceBroadcastReceiver extends BroadcastReceiver {
             NotificationChannel channel = new NotificationChannel(CHANNEL_ID, name, importance);
             channel.setDescription(description);
             NotificationManager notificationManager = context.getSystemService(NotificationManager.class);
-            notificationManager.createNotificationChannel(channel);
+            if (notificationManager != null) {
+                notificationManager.createNotificationChannel(channel);
+            }
         }
     }
 }