@woosmap/react-native-plugin-geofencing 1.0.0-beta.2 → 1.0.0-beta.3

package/android/src/main/java/com/woosmap/reactnativeplugingeofencing/WoosmapGeofencingTurboModule.java

@@ -0,0 +1,1025 @@
+package com.woosmap.reactnativeplugingeofencing;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.util.Log;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.annotation.RequiresApi;
+import androidx.core.app.ActivityCompat;
+import androidx.core.app.NotificationManagerCompat;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.LifecycleEventListener;
+import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.module.annotations.ReactModule;
+import com.facebook.react.modules.core.PermissionAwareActivity;
+import com.facebook.react.modules.core.PermissionListener;
+import com.webgeoservices.woosmapgeofencing.NotificationIconProvider;
+import com.webgeoservices.woosmapgeofencing.Woosmap;
+import com.webgeoservices.woosmapgeofencing.WoosmapSettings;
+import com.webgeoservices.woosmapgeofencingcore.database.Region;
+// NativeWoosmapGeofencingTurboSpec (codegen) now lives in this same package
+// (codegenJavaPackageName == this file's package), so no import is needed.
+
+import java.io.File;
+import java.io.FileOutputStream;
+import java.io.InputStream;
+import java.net.HttpURLConnection;
+import java.net.URL;
+import java.util.HashMap;
+import java.util.Iterator;
+import java.util.concurrent.ExecutorService;
+import java.util.concurrent.Executors;
+
+/**
+ * TurboModule implementation for all geofencing methods, including initialization,
+ * permissions, watch/clear, and data operations.
+ * Extends the codegen-generated {@code NativeWoosmapGeofencingTurboSpec} abstract class.
+ */
+@ReactModule(name = WoosmapGeofencingTurboModule.NAME)
+public class WoosmapGeofencingTurboModule extends NativeWoosmapGeofencingTurboSpec
+    implements PermissionListener, LifecycleEventListener {
+  public static final String NAME = "WoosmapGeofencingTurbo";
+
+  private final ReactApplicationContext reactContext;
+  private Woosmap woosmap;
+  private static final int PERMISSIONS_REQUEST_CODE = 150;
+  private static final int BLE_PERMISSIONS_REQUEST_CODE = 160;
+  private static final int NOTIF_PERMISSIONS_REQUEST_CODE = 170;
+  private Promise mPermissionsRequestPromise;
+  private Promise mBLEPermissionsRequestPromise;
+  private Promise mNotificationPermissionsRequestPromise;
+  private WoosLocationReadyListener locationReadyListener;
+  private WoosRegionReadyListener regionReadyListener;
+  private Woosmap.ProfileReadyListener profileReadyListener;
+  private final ExecutorService ioPool = Executors.newSingleThreadExecutor();
+
+  public WoosmapGeofencingTurboModule(ReactApplicationContext reactContext) {
+    super(reactContext);
+    this.reactContext = reactContext;
+    this.reactContext.addLifecycleEventListener(this);
+  }
+
+  @Override
+  @NonNull
+  public String getName() {
+    return NAME;
+  }
+
+  // ── Lifecycle ─────────────────────────────────────────────────────────────
+
+  @Override
+  public void onHostResume() {
+    if (woosmap != null) woosmap.onResume();
+  }
+
+  @Override
+  public void onHostPause() {
+    if (woosmap != null) woosmap.onPause();
+  }
+
+  @Override
+  public void onHostDestroy() {
+    if (profileReadyListener != null) {
+      woosmap.setProfileReadyListener(null);
+      profileReadyListener = null;
+    }
+    if (woosmap != null) woosmap.onDestroy();
+  }
+
+  // ── Event emitter stubs (required by NativeEventEmitter on JS side) ───────
+
+  @Override
+  public void addListener(String eventName) {}
+
+  @Override
+  public void removeListeners(double count) {}
+
+  // ── Helpers ───────────────────────────────────────────────────────────────
+
+  /**
+   * Returns whether {@link #initialize(ReadableMap, Promise)} has run. The
+   * {@code woosmap} instance field is assigned only inside initialize(), so it
+   * is the reliable readiness proxy. {@code Woosmap.getInstance()} must not be
+   * used here: it returns the lazily-created singleton even before
+   * initializeWoosmap() is called, which would make this guard always true and
+   * let callers reach an uninitialized SDK.
+   */
+  private boolean isWoosmapInitialized() {
+    return woosmap != null;
+  }
+
+  private boolean onlyContainsNumbers(String text) {
+    try {
+      Long.parseLong(text);
+      return true;
+    } catch (NumberFormatException ex) {
+      return false;
+    }
+  }
+
+  private boolean onlyContainsDouble(String text) {
+    try {
+      Double.parseDouble(text);
+      return true;
+    } catch (NumberFormatException ex) {
+      return false;
+    }
+  }
+
+  // ── Initialization ────────────────────────────────────────────────────────
+
+  @Override
+  public void initialize(ReadableMap options, Promise promise) {
+    String trackingProfile = "";
+    try {
+      if (options.hasKey(WoosmapMessageAndKey.profileTrackingKey)) {
+        String profile = options.getString(WoosmapMessageAndKey.profileTrackingKey);
+        if (profile.equals(Woosmap.ConfigurationProfile.liveTracking)) {
+          trackingProfile = Woosmap.ConfigurationProfile.liveTracking;
+        } else if (profile.equals(Woosmap.ConfigurationProfile.passiveTracking)) {
+          trackingProfile = Woosmap.ConfigurationProfile.passiveTracking;
+        } else if (profile.equals(Woosmap.ConfigurationProfile.optimalPassiveTracking)) {
+          trackingProfile = Woosmap.ConfigurationProfile.optimalPassiveTracking;
+        } else if (profile.equals(Woosmap.ConfigurationProfile.visitsTracking)) {
+          trackingProfile = Woosmap.ConfigurationProfile.visitsTracking;
+        } else if (profile.equals(Woosmap.ConfigurationProfile.beaconTracking)) {
+          trackingProfile = Woosmap.ConfigurationProfile.beaconTracking;
+        } else {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.invalidProfileTrackingError);
+          return;
+        }
+      }
+      woosmap = Woosmap.getInstance().initializeWoosmap(reactContext);
+      if (options.hasKey(WoosmapMessageAndKey.woosmapPrivateKeyString)) {
+        WoosmapSettings.privateKeyWoosmapAPI = options.getString(WoosmapMessageAndKey.woosmapPrivateKeyString);
+      }
+      if (options.hasKey(WoosmapMessageAndKey.androidNotificationText)) {
+        WoosmapSettings.updateServiceNotificationText = options.getString(WoosmapMessageAndKey.androidNotificationText);
+      }
+      if (options.hasKey(WoosmapMessageAndKey.androidNotificationTitle)) {
+        WoosmapSettings.updateServiceNotificationTitle = options.getString(WoosmapMessageAndKey.androidNotificationTitle);
+      }
+      if (options.hasKey(WoosmapMessageAndKey.enableAirshipConnectorKey)) {
+        WoosmapUtil.setEnableAishipConnector(
+          options.getBoolean(WoosmapMessageAndKey.enableAirshipConnectorKey), reactContext);
+      }
+      // Set the delay of duration data
+      WoosmapSettings.numberOfDayDataDuration = 30;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
+        this.woosmap.createWoosmapNotifChannel();
+      }
+      this.woosmap.onResume();
+      // Add region listener
+      regionReadyListener = new WoosRegionReadyListener(reactContext);
+      woosmap.setRegionLogReadyListener(regionReadyListener);
+      woosmap.setRegionReadyListener(regionReadyListener);
+      if (!trackingProfile.isEmpty()) {
+        woosmap.startTracking(trackingProfile);
+      }
+
+      // Notification-icon overrides settle the promise themselves, so resolve
+      // here only when no icon override is requested — otherwise the promise
+      // would be settled twice (the async URL path is the worst case). A
+      // remote URL takes precedence over a resource name when both are set,
+      // since both write the same single small-icon override.
+      if (options.hasKey(WoosmapMessageAndKey.androidNotificationIconUrl)) {
+        NotificationIconProvider.clearRuntimeOverrides(reactContext);
+        setNotificationSmallIconByUrl(options.getString(WoosmapMessageAndKey.androidNotificationIconUrl), promise);
+        return;
+      }
+      if (options.hasKey(WoosmapMessageAndKey.androidNotificationIconName)) {
+        NotificationIconProvider.clearRuntimeOverrides(reactContext);
+        setNotificationSmallIconByName(options.getString(WoosmapMessageAndKey.androidNotificationIconName), promise);
+        return;
+      }
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  private void setNotificationSmallIconByName(String name, Promise promise) {
+    try {
+      NotificationIconProvider.setRuntimeSmallIconByName(reactContext, name);
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Throwable ex) {
+      promise.reject("EICON", ex);
+    }
+  }
+
+  private void setNotificationSmallIconByUrl(String url, Promise promise) {
+    try {
+      ioPool.execute(() -> {
+        try {
+          Log.d(NAME, "Saving icon file to local file path");
+          String filePath = materializeToCache(url);
+          if (filePath == null) {
+            Log.e(NAME, "Failed to download/ copy icon");
+            promise.reject(WoosmapMessageAndKey.errorCode, "Failed to copy/download icon: " + url);
+            return;
+          }
+          Log.d(NAME, "Saved file path is: " + filePath);
+          NotificationIconProvider.setRuntimeSmallIconFromFile(reactContext, filePath);
+          promise.resolve(WoosmapMessageAndKey.successMessage);
+        } catch (Throwable t) {
+          promise.reject(WoosmapMessageAndKey.errorCode, t.toString());
+        }
+      });
+    } catch (Throwable ex) {
+      Log.e(NAME, ex.toString());
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.toString());
+    }
+  }
+
+  private String materializeToCache(String uriString) throws Exception {
+    if (uriString == null || uriString.trim().isEmpty()) return null;
+
+    File dest = new File(reactContext.getCacheDir(), "woosmap_notif_icon.png");
+
+    if (uriString.startsWith("http://") || uriString.startsWith("https://")) {
+      URL url = new URL(uriString);
+      HttpURLConnection conn = (HttpURLConnection) url.openConnection();
+      conn.setConnectTimeout(4000);
+      conn.setReadTimeout(4000);
+      conn.connect();
+      try (InputStream is = conn.getInputStream();
+           FileOutputStream os = new FileOutputStream(dest)) {
+        byte[] buf = new byte[8192];
+        int n;
+        while ((n = is.read(buf)) > 0) os.write(buf, 0, n);
+      } finally {
+        conn.disconnect();
+      }
+      return dest.getAbsolutePath();
+    }
+
+    if (uriString.startsWith("file://")) {
+      java.nio.file.Files.copy(
+        new File(uriString.substring("file://".length())).toPath(),
+        dest.toPath(),
+        java.nio.file.StandardCopyOption.REPLACE_EXISTING
+      );
+      return dest.getAbsolutePath();
+    }
+
+    // content:// and other schemes
+    android.net.Uri uri = android.net.Uri.parse(uriString);
+    try (InputStream is = reactContext.getContentResolver().openInputStream(uri);
+         FileOutputStream os = new FileOutputStream(dest)) {
+      if (is == null) return null;
+      byte[] buf = new byte[8192];
+      int n;
+      while ((n = is.read(buf)) > 0) os.write(buf, 0, n);
+      return dest.getAbsolutePath();
+    }
+  }
+
+  // ── Permissions request ───────────────────────────────────────────────────
+
+  @Override
+  public boolean onRequestPermissionsResult(int requestCode, String[] permissions, int[] grantResults) {
+    if (requestCode == PERMISSIONS_REQUEST_CODE && mPermissionsRequestPromise != null) {
+      providePermissionStatus(mPermissionsRequestPromise);
+      mPermissionsRequestPromise = null;
+    }
+    if (requestCode == BLE_PERMISSIONS_REQUEST_CODE && mBLEPermissionsRequestPromise != null) {
+      provideBLEPermissionStatus(mBLEPermissionsRequestPromise);
+      mBLEPermissionsRequestPromise = null;
+    }
+    if (requestCode == NOTIF_PERMISSIONS_REQUEST_CODE && mNotificationPermissionsRequestPromise != null) {
+      provideNotificationPermissionStatus(mNotificationPermissionsRequestPromise);
+      mNotificationPermissionsRequestPromise = null;
+    }
+    return true;
+  }
+
+  @Override
+  public void requestPermissions(boolean background, Promise promise) {
+    try {
+      Activity current = reactContext.getCurrentActivity();
+      // No foreground activity to request from: resolve instead of storing the
+      // promise, otherwise onRequestPermissionsResult never fires and the
+      // promise hangs forever.
+      if (!(current instanceof PermissionAwareActivity)) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      PermissionAwareActivity activity = (PermissionAwareActivity) current;
+      String[] permissions = (background && Build.VERSION.SDK_INT >= 29)
+        ? new String[]{
+            Manifest.permission.ACCESS_FINE_LOCATION,
+            Manifest.permission.ACCESS_BACKGROUND_LOCATION
+          }
+        : new String[]{Manifest.permission.ACCESS_FINE_LOCATION};
+      // Reject if a request is already pending so we don't overwrite (leak) it.
+      if (mPermissionsRequestPromise != null) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.permissionRequestInProgress);
+        return;
+      }
+      // Assign the pending promise only once a dispatch is guaranteed, so an
+      // overlapping call cannot overwrite (and leak) a still-pending promise.
+      mPermissionsRequestPromise = promise;
+      activity.requestPermissions(permissions, PERMISSIONS_REQUEST_CODE, this);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void requestBLEPermissions(Promise promise) {
+    try {
+      if (promise == null) {
+        return;
+      }
+      PermissionAwareActivity activity =
+        (PermissionAwareActivity) reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        // Reject if a request is already pending so we don't overwrite (leak) it.
+        if (mBLEPermissionsRequestPromise != null) {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.permissionRequestInProgress);
+          return;
+        }
+        mBLEPermissionsRequestPromise = promise;
+        activity.requestPermissions(
+          new String[]{
+            Manifest.permission.BLUETOOTH_SCAN,
+            Manifest.permission.BLUETOOTH_ADMIN,
+            Manifest.permission.BLUETOOTH
+          },
+          BLE_PERMISSIONS_REQUEST_CODE, this);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.backgroundPermissionGrantedMessage);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage(), ex);
+    }
+  }
+
+  @Override
+  public void requestNotificationPermissions(Promise promise) {
+    try {
+      Activity activity = reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      if (Build.VERSION.SDK_INT >= 33) {
+        boolean granted = ActivityCompat.checkSelfPermission(
+          activity, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
+        if (granted && NotificationManagerCompat.from(activity).areNotificationsEnabled()) {
+          promise.resolve(WoosmapMessageAndKey.grantedPermissionMessage);
+          return;
+        }
+        // Reject if a request is already pending so we don't overwrite (leak) it.
+        if (mNotificationPermissionsRequestPromise != null) {
+          promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.permissionRequestInProgress);
+          return;
+        }
+        mNotificationPermissionsRequestPromise = promise;
+        ((PermissionAwareActivity) activity).requestPermissions(
+          new String[]{Manifest.permission.POST_NOTIFICATIONS},
+          NOTIF_PERMISSIONS_REQUEST_CODE, this);
+      } else {
+        provideNotificationPermissionStatus(promise);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage(), ex);
+    }
+  }
+
+  // ── Permission status helpers ─────────────────────────────────────────────
+
+  private void providePermissionStatus(final Promise promise) {
+    try {
+      if (promise == null) {
+        return;
+      }
+      Activity activity = reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      boolean foreground = ActivityCompat.checkSelfPermission(
+        activity, Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+      boolean background = foreground;
+      boolean denied = ActivityCompat.shouldShowRequestPermissionRationale(
+        activity, Manifest.permission.ACCESS_FINE_LOCATION);
+      if (Build.VERSION.SDK_INT >= 29) {
+        background = ActivityCompat.checkSelfPermission(
+          activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+      }
+      if (background) {
+        promise.resolve(WoosmapMessageAndKey.backgroundPermissionGrantedMessage);
+      } else if (foreground) {
+        promise.resolve(WoosmapMessageAndKey.foregroundPermissionGrantedMessage);
+      } else if (denied) {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+      }
+    } catch (Exception ex) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+    }
+  }
+
+  private void provideBLEPermissionStatus(final Promise promise) {
+    if (promise == null) {
+      return;
+    }
+    Activity activity = reactContext.getCurrentActivity();
+    if (activity == null) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+      return;
+    }
+    boolean granted = true;
+    if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+      granted = ActivityCompat.checkSelfPermission(
+        activity, Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+    }
+    if (granted) {
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        granted = ActivityCompat.checkSelfPermission(
+          activity, Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED;
+      }
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        if (granted) {
+          granted = ActivityCompat.checkSelfPermission(
+            activity, Manifest.permission.BLUETOOTH_ADMIN) == PackageManager.PERMISSION_GRANTED;
+        }
+      }
+      if (granted) {
+        promise.resolve(WoosmapMessageAndKey.blePermissionGrantedMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      }
+    } else {
+      promise.resolve(WoosmapMessageAndKey.backgroundPermissionDeniedMessage);
+    }
+  }
+
+  private void provideNotificationPermissionStatus(final Promise promise) {
+    if (promise == null) return;
+    Activity activity = reactContext.getCurrentActivity();
+    if (activity == null) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+      return;
+    }
+    boolean enabled = NotificationManagerCompat.from(activity).areNotificationsEnabled();
+    if (Build.VERSION.SDK_INT >= 33) {
+      boolean granted = ActivityCompat.checkSelfPermission(
+        activity, Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
+      if (enabled && granted) {
+        promise.resolve(WoosmapMessageAndKey.grantedPermissionMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      }
+    } else {
+      if (enabled) {
+        promise.resolve(WoosmapMessageAndKey.grantedPermissionMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      }
+    }
+  }
+
+  // ── Region CRUD ───────────────────────────────────────────────────────────
+
+  @Override
+  public void setWoosmapApiKey(String apiKey, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (apiKey == null || apiKey.isEmpty()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapKeyNotProvide);
+        return;
+      }
+      WoosmapSettings.privateKeyWoosmapAPI = apiKey;
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void setPoiRadius(String radius, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (radius == null || radius.isEmpty()) {
+        throw new Exception(WoosmapMessageAndKey.radiusEmptyMessage);
+      }
+      if (onlyContainsNumbers(radius)) {
+        WoosmapSettings.poiRadius = Integer.parseInt(radius);
+      } else if (onlyContainsDouble(radius)) {
+        WoosmapSettings.poiRadius = (int) Math.round(Double.parseDouble(radius));
+      } else {
+        WoosmapSettings.poiRadiusNameFromResponse = radius;
+      }
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void addRegion(ReadableMap region, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (region == null || region.toHashMap().isEmpty()) {
+        throw new Exception(WoosmapMessageAndKey.regionInfoEmptyMessage);
+      }
+      Region woosRegion = new Region();
+      woosRegion.identifier = region.getString("regionId");
+      woosRegion.idStore = region.hasKey("idStore") ? region.getString("idStore") : "";
+      woosRegion.lat = region.getDouble("lat");
+      woosRegion.lng = region.getDouble("lng");
+      woosRegion.type = region.hasKey("type") ? region.getString("type") : "";
+      woosRegion.radius = region.getDouble("radius");
+
+      WoosmapTask.getInstance(reactContext).addRegion(woosRegion, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void getRegions(@Nullable String regionId, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).enqueGetRegionsAsArrayRequest(regionId, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void removeRegion(String regionId, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (regionId == null || regionId.isEmpty()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.requiredRegionid);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).removeRegion(regionId, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void removeAllRegions(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).removeRegion("", promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  // ── Tracking ──────────────────────────────────────────────────────────────
+
+  @Override
+  public void startTracking(String profile, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (profile == null || profile.isEmpty()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.trackingProfileNotProvided);
+        return;
+      }
+      if (profile.equals(Woosmap.ConfigurationProfile.liveTracking) ||
+          profile.equals(Woosmap.ConfigurationProfile.passiveTracking) ||
+          profile.equals(Woosmap.ConfigurationProfile.optimalPassiveTracking) ||
+          profile.equals(Woosmap.ConfigurationProfile.beaconTracking) ||
+          profile.equals(Woosmap.ConfigurationProfile.visitsTracking)) {
+        Woosmap.getInstance().startTracking(profile);
+        promise.resolve(WoosmapMessageAndKey.successMessage);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.invalidProfileTrackingError);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void stopTracking(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      Woosmap.getInstance().stopTracking();
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void startCustomTracking(String mode, String source, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (!mode.equalsIgnoreCase(WoosmapMessageAndKey.localMode) &&
+          !mode.equalsIgnoreCase(WoosmapMessageAndKey.externalMode)) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.invalidProfileSourceType);
+        return;
+      }
+      // Store in the field (not a local) so onHostDestroy can detach it from
+      // the Woosmap singleton, which outlives this module instance.
+      profileReadyListener = (status, errors) -> {
+        try {
+          if (status) {
+            promise.resolve(WoosmapMessageAndKey.successMessage);
+          } else {
+            promise.reject(WoosmapMessageAndKey.errorCode, errors.get(0));
+          }
+        } catch (Exception ex) {
+          promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+        }
+      };
+      Woosmap.getInstance().setProfileReadyListener(profileReadyListener);
+      Woosmap.getInstance().startCustomTracking(source);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  // ── Watch / clear ─────────────────────────────────────────────────────────
+
+  @Override
+  public void watchLocation(String watchID, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (locationReadyListener == null) {
+        locationReadyListener = new WoosLocationReadyListener(reactContext);
+        Woosmap.getInstance().setLocationReadyListener(locationReadyListener);
+        promise.resolve(watchID);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.locationWatchAlreadyStarted);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void clearLocationWatch(String watchID, Promise promise) {
+    try {
+      if (locationReadyListener != null) {
+        Woosmap.getInstance().setLocationReadyListener(null);
+        locationReadyListener = null;
+        promise.resolve(watchID);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.locationWatchNotStarted);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void clearAllLocationWatch(Promise promise) {
+    try {
+      Woosmap.getInstance().setLocationReadyListener(null);
+      locationReadyListener = null;
+      promise.resolve("00000-00000-0000");
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void watchRegions(String watchID, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (regionReadyListener == null) {
+        regionReadyListener = new WoosRegionReadyListener(reactContext);
+        Woosmap.getInstance().setRegionLogReadyListener(regionReadyListener);
+        Woosmap.getInstance().setRegionReadyListener(regionReadyListener);
+      }
+      if (!regionReadyListener.getIsRegionWatchEnabled()) {
+        regionReadyListener.setIsRegionWatchEnabled(true);
+        promise.resolve(watchID);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.regionWatchAlreadyStarted);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void clearRegionsWatch(String watchID, Promise promise) {
+    try {
+      if (regionReadyListener != null && regionReadyListener.getIsRegionWatchEnabled()) {
+        regionReadyListener.setIsRegionWatchEnabled(false);
+        promise.resolve(watchID);
+      } else {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.regionWatchNotStarted);
+      }
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void clearAllRegionsWatch(Promise promise) {
+    try {
+      if (regionReadyListener != null) {
+        regionReadyListener.setIsRegionWatchEnabled(false);
+      }
+      promise.resolve("00000-00000-0000");
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  // ── Permission status ─────────────────────────────────────────────────────
+
+  @Override
+  public void getPermissionsStatus(Promise promise) {
+    try {
+      Activity activity = reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      boolean foreground = ActivityCompat.checkSelfPermission(activity,
+        Manifest.permission.ACCESS_FINE_LOCATION) == PackageManager.PERMISSION_GRANTED;
+      boolean background = foreground;
+      boolean denied = ActivityCompat.shouldShowRequestPermissionRationale(activity,
+        Manifest.permission.ACCESS_FINE_LOCATION);
+
+      if (Build.VERSION.SDK_INT >= 29) {
+        background = ActivityCompat.checkSelfPermission(activity,
+          Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+      }
+
+      if (background) {
+        promise.resolve(WoosmapMessageAndKey.backgroundPermissionGrantedMessage);
+      } else if (foreground) {
+        promise.resolve(WoosmapMessageAndKey.foregroundPermissionGrantedMessage);
+      } else if (denied) {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+      }
+    } catch (Exception ex) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+    }
+  }
+
+  @Override
+  public void getBLEPermissionsStatus(Promise promise) {
+    try {
+      Activity activity = reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      boolean granted = true;
+      if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        granted = ActivityCompat.checkSelfPermission(activity,
+          Manifest.permission.ACCESS_BACKGROUND_LOCATION) == PackageManager.PERMISSION_GRANTED;
+      }
+      if (granted && Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+        granted = ActivityCompat.checkSelfPermission(activity,
+          Manifest.permission.BLUETOOTH_SCAN) == PackageManager.PERMISSION_GRANTED
+          && ActivityCompat.checkSelfPermission(activity,
+          Manifest.permission.BLUETOOTH_ADMIN) == PackageManager.PERMISSION_GRANTED;
+      }
+      if (granted) {
+        promise.resolve(WoosmapMessageAndKey.blePermissionGrantedMessage);
+      } else {
+        promise.resolve(WoosmapMessageAndKey.deniedPermissionMessage);
+      }
+    } catch (Exception ex) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+    }
+  }
+
+  @Override
+  public void getNotificationPermissionsStatus(Promise promise) {
+    try {
+      Activity activity = reactContext.getCurrentActivity();
+      if (activity == null) {
+        promise.resolve(WoosmapMessageAndKey.unknownMessage);
+        return;
+      }
+      boolean enabled = NotificationManagerCompat.from(activity).areNotificationsEnabled();
+      if (Build.VERSION.SDK_INT >= 33) {
+        boolean granted = ActivityCompat.checkSelfPermission(activity,
+          Manifest.permission.POST_NOTIFICATIONS) == PackageManager.PERMISSION_GRANTED;
+        promise.resolve((enabled && granted)
+          ? WoosmapMessageAndKey.grantedPermissionMessage
+          : WoosmapMessageAndKey.deniedPermissionMessage);
+      } else {
+        promise.resolve(enabled
+          ? WoosmapMessageAndKey.grantedPermissionMessage
+          : WoosmapMessageAndKey.deniedPermissionMessage);
+      }
+    } catch (Exception ex) {
+      promise.resolve(WoosmapMessageAndKey.unknownMessage);
+    }
+  }
+
+  // ── Configuration ─────────────────────────────────────────────────────────
+
+  @Override
+  public void setSFMCCredentials(ReadableMap credentials, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      if (credentials == null || credentials.toHashMap().isEmpty()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.credentialEmptyMessage);
+        return;
+      }
+      String[] required = {
+        WoosmapMessageAndKey.SMFCauthenticationBaseURIkey,
+        WoosmapMessageAndKey.SMFCrestBaseURIkey,
+        WoosmapMessageAndKey.SMFCclient_idkey,
+        WoosmapMessageAndKey.SMFCclient_secretkey,
+        WoosmapMessageAndKey.SMFCcontactKey
+      };
+      for (String key : required) {
+        if (!credentials.hasKey(key)) {
+          throw new Exception(WoosmapMessageAndKey.keyMissingMessage + ": " + key);
+        }
+      }
+      HashMap<String, String> sfmcInfo = new HashMap<>();
+      Iterator<String> keys = credentials.toHashMap().keySet().iterator();
+      while (keys.hasNext()) {
+        String key = keys.next();
+        sfmcInfo.put(key, credentials.getString(key));
+      }
+      WoosmapSettings.SFMCCredentials = sfmcInfo;
+      promise.resolve(WoosmapMessageAndKey.successMessage);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void setProtectedRegionSlot(double slots, Promise promise) {
+    // No-op on Android: protected region slots are an iOS-only concept.
+    promise.resolve(WoosmapMessageAndKey.successMessage);
+  }
+
+  // ── Data queries ──────────────────────────────────────────────────────────
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void getLocations(@Nullable String locationId, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).enqueueGetLocationsAsArrayRequest(locationId, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void getPois(@Nullable String poiId, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).enqueueGetPoisAsArrayRequest(poiId, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void getIndoorBeacons(@Nullable String venueId, Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).enqueueGetIndoorBeaconRequest(venueId, promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  // ── Data removal ──────────────────────────────────────────────────────────
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void removeLocations(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).removeAllLocation(promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void removePois(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).removeAllPois(promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @RequiresApi(api = Build.VERSION_CODES.N)
+  @Override
+  public void removeIndoorBeacons(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      WoosmapTask.getInstance(reactContext).removeAllBeacons(promise);
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+
+  @Override
+  public void refreshPois(Promise promise) {
+    try {
+      if (!isWoosmapInitialized()) {
+        promise.reject(WoosmapMessageAndKey.errorCode, WoosmapMessageAndKey.woosmapNotInitialized);
+        return;
+      }
+      Woosmap.getInstance().refreshPOIs(new Woosmap.POIRefreshCallback() {
+        @Override
+        public void onPOIsRefreshed() {
+          promise.resolve(WoosmapMessageAndKey.successMessage);
+        }
+
+        @Override
+        public void onError(String error) {
+          promise.reject(new Exception(error));
+        }
+      });
+    } catch (Exception ex) {
+      promise.reject(WoosmapMessageAndKey.errorCode, ex.getMessage());
+    }
+  }
+}