drawdown-arcore-depth 0.1.4

package/android/src/main/java/org/drawdown/arcoredepth/DrawDownArCoreDepthPlugin.java

@@ -0,0 +1,567 @@
+package org.drawdown.arcoredepth;
+
+import android.Manifest;
+import android.content.pm.PackageManager;
+import android.graphics.Color;
+import android.os.Build;
+import android.os.Handler;
+import android.os.Looper;
+import android.view.Gravity;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.FrameLayout;
+import android.widget.TextView;
+
+import com.getcapacitor.JSArray;
+import com.getcapacitor.JSObject;
+import com.getcapacitor.Plugin;
+import com.getcapacitor.PermissionState;
+import com.getcapacitor.PluginCall;
+import com.getcapacitor.PluginMethod;
+import com.getcapacitor.annotation.CapacitorPlugin;
+import com.getcapacitor.annotation.Permission;
+import com.getcapacitor.annotation.PermissionCallback;
+import com.google.ar.core.ArCoreApk;
+import com.google.ar.core.Camera;
+import com.google.ar.core.Config;
+import com.google.ar.core.Frame;
+import com.google.ar.core.Session;
+import com.google.ar.core.exceptions.CameraNotAvailableException;
+import com.google.ar.core.exceptions.UnavailableApkTooOldException;
+import com.google.ar.core.exceptions.UnavailableArcoreNotInstalledException;
+import com.google.ar.core.exceptions.UnavailableDeviceNotCompatibleException;
+import com.google.ar.core.exceptions.UnavailableSdkTooOldException;
+import com.google.ar.core.exceptions.UnavailableUserDeclinedInstallationException;
+
+import android.opengl.GLSurfaceView;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@CapacitorPlugin(
+        name = "DrawDownArCoreDepth",
+        permissions = {
+                @Permission(alias = "camera", strings = { Manifest.permission.CAMERA })
+        })
+public class DrawDownArCoreDepthPlugin extends Plugin {
+    private static final String PLUGIN_VERSION = "0.1.4";
+    private static final long WARMUP_MS = 1200L;
+
+    private final Handler mainHandler = new Handler(Looper.getMainLooper());
+    private final DepthObservationSampler sampler = new DepthObservationSampler();
+    private final Object sweepLock = new Object();
+
+    private Session session;
+    private GLSurfaceView surfaceView;
+    private FrameLayout nativeOverlay;
+    private TextView instructionText;
+    private ArCameraRenderer renderer;
+    private PluginCall pendingStartCall;
+    private PluginCall pendingSweepCall;
+
+    private boolean sessionResumed = false;
+    private volatile boolean sweepActive = false;
+    private long sweepCollectionStartsAtMs = 0L;
+    private long sweepEndsAtMs = 0L;
+    private long lastSampleAtMs = 0L;
+    private long sampleIntervalMs = 250L;
+    private int maxObservations = 10;
+    private int minObservations = 5;
+    private final List<DepthObservation> sweepObservations = new ArrayList<>();
+
+    @PluginMethod
+    public void checkSupport(PluginCall call) {
+        getActivity().runOnUiThread(() -> {
+            JSObject result = new JSObject();
+            result.put("pluginVersion", PLUGIN_VERSION);
+
+            try {
+                ArCoreApk.Availability availability = ArCoreApk.getInstance().checkAvailability(getActivity());
+                if (availability.isTransient()) {
+                    result.put("isSupported", false);
+                    result.put("hasDepthApi", false);
+                    result.put("message", "ARCore support is still being checked. Retry in a moment.");
+                    call.resolve(result);
+                    return;
+                }
+
+                if (!availability.isSupported()) {
+                    result.put("isSupported", false);
+                    result.put("hasDepthApi", false);
+                    result.put("message", "This Android device is not supported by ARCore.");
+                    call.resolve(result);
+                    return;
+                }
+
+                boolean hasDepth = false;
+                Session probe = null;
+                try {
+                    probe = new Session(getActivity());
+                    hasDepth = probe.isDepthModeSupported(Config.DepthMode.AUTOMATIC);
+                } finally {
+                    if (probe != null) {
+                        probe.close();
+                    }
+                }
+
+                result.put("isSupported", true);
+                result.put("hasDepthApi", hasDepth);
+                result.put("message", hasDepth
+                        ? "ARCore Depth is available on this device."
+                        : "ARCore is available, but the Depth API is not supported on this device.");
+                call.resolve(result);
+            } catch (UnavailableArcoreNotInstalledException e) {
+                result.put("isSupported", true);
+                result.put("hasDepthApi", false);
+                result.put("message", "Google Play Services for AR is not installed.");
+                call.resolve(result);
+            } catch (UnavailableApkTooOldException e) {
+                result.put("isSupported", true);
+                result.put("hasDepthApi", false);
+                result.put("message", "Google Play Services for AR needs to be updated.");
+                call.resolve(result);
+            } catch (UnavailableSdkTooOldException e) {
+                result.put("isSupported", false);
+                result.put("hasDepthApi", false);
+                result.put("message", "This app's ARCore SDK is too old for the installed AR service.");
+                call.resolve(result);
+            } catch (UnavailableDeviceNotCompatibleException e) {
+                result.put("isSupported", false);
+                result.put("hasDepthApi", false);
+                result.put("message", "This device is not compatible with ARCore.");
+                call.resolve(result);
+            } catch (Exception e) {
+                result.put("isSupported", false);
+                result.put("hasDepthApi", false);
+                result.put("message", "Unable to check ARCore Depth support: " + safeMessage(e));
+                call.resolve(result);
+            }
+        });
+    }
+
+    @PluginMethod
+    public void startDbhSession(PluginCall call) {
+        // From v0.1.2 the RFID/NFC tree tag is the field anchor for the 1.3 m DBH plane.
+        // Legacy ArUco arguments are deliberately ignored for backward compatibility.
+        Double targetHeight = call.getDouble("targetHeightM", 1.3);
+
+        if (targetHeight == null || Math.abs(targetHeight - 1.3) > 0.01) {
+            call.reject("DrawDown DBH requires the RFID/NFC tag to identify the 1.3 m measurement plane.");
+            return;
+        }
+
+        if (!hasCameraPermission()) {
+            requestAllPermissions(call, "cameraPermissionResult");
+            return;
+        }
+
+        startSessionInternal(call);
+    }
+
+    @PermissionCallback
+    private void cameraPermissionResult(PluginCall call) {
+        if (!hasCameraPermission()) {
+            call.reject("Camera permission is required for ARCore DBH.");
+            return;
+        }
+        startSessionInternal(call);
+    }
+
+    private void startSessionInternal(PluginCall call) {
+        getActivity().runOnUiThread(() -> {
+            if (session != null) {
+                JSObject already = new JSObject();
+                already.put("started", true);
+                already.put("message", "ARCore DBH session is already running.");
+                call.resolve(already);
+                return;
+            }
+
+            try {
+                ArCoreApk.InstallStatus installStatus = ArCoreApk.getInstance().requestInstall(getActivity(), true);
+                if (installStatus == ArCoreApk.InstallStatus.INSTALL_REQUESTED) {
+                    JSObject install = new JSObject();
+                    install.put("started", false);
+                    install.put("installationRequested", true);
+                    install.put("message", "Google Play Services for AR installation was requested. Retry after installation completes.");
+                    call.resolve(install);
+                    return;
+                }
+
+                session = new Session(getActivity());
+                if (!session.isDepthModeSupported(Config.DepthMode.AUTOMATIC)) {
+                    session.close();
+                    session = null;
+                    call.reject("This ARCore device does not support the Depth API.");
+                    return;
+                }
+
+                Config config = session.getConfig();
+                config.setDepthMode(Config.DepthMode.AUTOMATIC);
+                config.setFocusMode(Config.FocusMode.AUTO);
+                config.setUpdateMode(Config.UpdateMode.LATEST_CAMERA_IMAGE);
+                config.setPlaneFindingMode(Config.PlaneFindingMode.DISABLED);
+                config.setLightEstimationMode(Config.LightEstimationMode.DISABLED);
+                session.configure(config);
+
+                pendingStartCall = call;
+                createNativeCameraOverlay();
+            } catch (UnavailableArcoreNotInstalledException
+                    | UnavailableUserDeclinedInstallationException e) {
+                cleanupSession();
+                call.reject("Google Play Services for AR is not installed or installation was declined.");
+            } catch (UnavailableApkTooOldException e) {
+                cleanupSession();
+                call.reject("Google Play Services for AR needs to be updated.");
+            } catch (UnavailableSdkTooOldException e) {
+                cleanupSession();
+                call.reject("The DrawDown ARCore SDK needs to be updated.");
+            } catch (UnavailableDeviceNotCompatibleException e) {
+                cleanupSession();
+                call.reject("This device is not compatible with ARCore.");
+            } catch (Exception e) {
+                cleanupSession();
+                call.reject("Unable to start ARCore DBH: " + safeMessage(e));
+            }
+        });
+    }
+
+    @PluginMethod
+    public void captureDbhSweep(PluginCall call) {
+        if (session == null || !sessionResumed || surfaceView == null) {
+            call.reject("ARCore DBH session is not running.");
+            return;
+        }
+
+        Boolean retainFrames = call.getBoolean("retainFrames", false);
+        if (Boolean.TRUE.equals(retainFrames)) {
+            call.reject("This plugin deliberately does not retain sweep frames.");
+            return;
+        }
+
+        int durationMs = intOption(call, "durationMs", 3000, 1000, 8000);
+        int requestedMin = intOption(call, "minObservations", 5, 3, 20);
+        int requestedMax = intOption(call, "maxObservations", 10, requestedMin, 30);
+
+        synchronized (sweepLock) {
+            if (pendingSweepCall != null) {
+                call.reject("A DBH sweep is already in progress.");
+                return;
+            }
+
+            pendingSweepCall = call;
+            sweepObservations.clear();
+            minObservations = requestedMin;
+            maxObservations = requestedMax;
+            sampleIntervalMs = Math.max(100L, durationMs / Math.max(1, requestedMax * 2));
+            long now = System.currentTimeMillis();
+            sweepCollectionStartsAtMs = now + WARMUP_MS;
+            sweepEndsAtMs = sweepCollectionStartsAtMs + durationMs;
+            lastSampleAtMs = 0L;
+            sweepActive = true;
+        }
+
+        updateInstruction("Use the RFID/NFC tag to locate 1.3 m • aim at bark beside the tag");
+        mainHandler.postDelayed(
+                () -> updateInstruction("Stand 1–1.5 m away • move slowly sideways • keep crosshair on bark"),
+                WARMUP_MS);
+        mainHandler.postDelayed(
+                () -> finishSweep(false),
+                WARMUP_MS + durationMs + 150L);
+    }
+
+    @PluginMethod
+    public void stopDbhSession(PluginCall call) {
+        getActivity().runOnUiThread(() -> {
+            finishSweep(true);
+            cleanupSession();
+            call.resolve();
+        });
+    }
+
+    private void createNativeCameraOverlay() {
+        if (session == null) {
+            return;
+        }
+
+        FrameLayout root = getActivity().findViewById(android.R.id.content);
+        nativeOverlay = new FrameLayout(getActivity());
+        nativeOverlay.setBackgroundColor(Color.BLACK);
+
+        surfaceView = new GLSurfaceView(getActivity());
+        surfaceView.setEGLContextClientVersion(2);
+        surfaceView.setPreserveEGLContextOnPause(true);
+        renderer = new ArCameraRenderer(session, new ArCameraRenderer.Callback() {
+            @Override
+            public void onRendererReady(int textureId) {
+                mainHandler.post(() -> {
+                    if (session == null) {
+                        rejectPendingStart("ARCore session was closed before the camera became ready.");
+                        return;
+                    }
+                    try {
+                        session.setCameraTextureName(textureId);
+                        updateDisplayGeometry();
+                        session.resume();
+                        sessionResumed = true;
+                        surfaceView.onResume();
+                        updateInstruction("Use the RFID/NFC tag to locate 1.3 m • aim at bark beside the tag");
+
+                        PluginCall start = pendingStartCall;
+                        pendingStartCall = null;
+                        if (start != null) {
+                            JSObject result = new JSObject();
+                            result.put("started", true);
+                            result.put("message", "ARCore Depth session started at the RFID/NFC tag height.");
+                            start.resolve(result);
+                        }
+                    } catch (CameraNotAvailableException e) {
+                        rejectPendingStart("Camera is not available for ARCore DBH.");
+                        cleanupSession();
+                    } catch (Exception e) {
+                        rejectPendingStart("Unable to resume ARCore DBH: " + safeMessage(e));
+                        cleanupSession();
+                    }
+                });
+            }
+
+            @Override
+            public void onFrame(Frame frame, int viewWidth, int viewHeight) {
+                handleArFrame(frame, viewWidth, viewHeight);
+            }
+
+            @Override
+            public int getDisplayRotation() {
+                return currentDisplayRotation();
+            }
+        });
+        surfaceView.setRenderer(renderer);
+        surfaceView.setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
+
+        nativeOverlay.addView(surfaceView, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT));
+
+        addCrosshair(nativeOverlay);
+        instructionText = createInstructionText();
+        FrameLayout.LayoutParams instructions = new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.WRAP_CONTENT);
+        instructions.gravity = Gravity.TOP;
+        instructions.setMargins(dp(20), dp(34), dp(20), 0);
+        nativeOverlay.addView(instructionText, instructions);
+
+        root.addView(nativeOverlay, new FrameLayout.LayoutParams(
+                ViewGroup.LayoutParams.MATCH_PARENT,
+                ViewGroup.LayoutParams.MATCH_PARENT));
+    }
+
+    private void handleArFrame(Frame frame, int viewWidth, int viewHeight) {
+        if (!sweepActive) {
+            return;
+        }
+
+        long now = System.currentTimeMillis();
+        if (now < sweepCollectionStartsAtMs || now > sweepEndsAtMs) {
+            return;
+        }
+        if (lastSampleAtMs > 0 && now - lastSampleAtMs < sampleIntervalMs) {
+            return;
+        }
+        lastSampleAtMs = now;
+
+        try {
+            Camera camera = frame.getCamera();
+            DepthObservation observation = sampler.sample(frame, camera, viewWidth, viewHeight);
+            if (observation == null) {
+                return;
+            }
+
+            boolean reachedMax = false;
+            synchronized (sweepLock) {
+                if (!sweepActive || pendingSweepCall == null) {
+                    return;
+                }
+                sweepObservations.add(observation);
+                reachedMax = sweepObservations.size() >= maxObservations;
+            }
+
+            if (reachedMax) {
+                mainHandler.post(() -> finishSweep(false));
+            }
+        } catch (Exception ignored) {
+            // Invalid frames are simply skipped; the app's aggregate QA rejects
+            // a sweep with too few valid observations.
+        }
+    }
+
+    private void finishSweep(boolean stoppedByCaller) {
+        PluginCall sweepCall;
+        List<DepthObservation> observations;
+        synchronized (sweepLock) {
+            sweepCall = pendingSweepCall;
+            if (sweepCall == null) {
+                sweepActive = false;
+                return;
+            }
+            pendingSweepCall = null;
+            sweepActive = false;
+            observations = new ArrayList<>(sweepObservations);
+            sweepObservations.clear();
+        }
+
+        JSArray observationArray = new JSArray();
+        for (DepthObservation observation : observations) {
+            observationArray.put(observation.toJsObject());
+        }
+
+        JSObject result = new JSObject();
+        result.put("observations", observationArray);
+        result.put("deviceModel", Build.MANUFACTURER + " " + Build.MODEL);
+        result.put("arcoreVersion", installedArcoreVersion());
+        result.put("minimumRequested", minObservations);
+        result.put("stoppedByCaller", stoppedByCaller);
+        sweepCall.resolve(result);
+
+        if (!stoppedByCaller) {
+            updateInstruction(observations.size() >= minObservations
+                    ? "Depth sweep complete"
+                    : "Depth sweep complete • too few valid observations");
+        }
+    }
+
+    private void cleanupSession() {
+        sweepActive = false;
+
+        if (surfaceView != null) {
+            try {
+                surfaceView.onPause();
+            } catch (Exception ignored) {
+            }
+        }
+
+        if (session != null) {
+            try {
+                if (sessionResumed) {
+                    session.pause();
+                }
+            } catch (Exception ignored) {
+            }
+            try {
+                session.close();
+            } catch (Exception ignored) {
+            }
+        }
+        sessionResumed = false;
+        session = null;
+        renderer = null;
+
+        if (nativeOverlay != null) {
+            ViewGroup parent = (ViewGroup) nativeOverlay.getParent();
+            if (parent != null) {
+                parent.removeView(nativeOverlay);
+            }
+        }
+        nativeOverlay = null;
+        surfaceView = null;
+        instructionText = null;
+
+        if (pendingStartCall != null) {
+            rejectPendingStart("ARCore DBH session was stopped.");
+        }
+    }
+
+    private void rejectPendingStart(String message) {
+        PluginCall start = pendingStartCall;
+        pendingStartCall = null;
+        if (start != null) {
+            start.reject(message);
+        }
+    }
+
+    private boolean hasCameraPermission() {
+        return getPermissionState("camera") == PermissionState.GRANTED;
+    }
+
+    private int currentDisplayRotation() {
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.R && getActivity().getDisplay() != null) {
+            return getActivity().getDisplay().getRotation();
+        }
+        return getActivity().getWindowManager().getDefaultDisplay().getRotation();
+    }
+
+    private void updateDisplayGeometry() {
+        if (session == null || surfaceView == null) {
+            return;
+        }
+        int width = Math.max(1, surfaceView.getWidth());
+        int height = Math.max(1, surfaceView.getHeight());
+        session.setDisplayGeometry(currentDisplayRotation(), width, height);
+    }
+
+    private TextView createInstructionText() {
+        TextView text = new TextView(getActivity());
+        text.setTextColor(Color.WHITE);
+        text.setTextSize(16f);
+        text.setGravity(Gravity.CENTER);
+        text.setPadding(dp(12), dp(10), dp(12), dp(10));
+        text.setBackgroundColor(0x99000000);
+        return text;
+    }
+
+    private void updateInstruction(String message) {
+        mainHandler.post(() -> {
+            if (instructionText != null) {
+                instructionText.setText(message);
+            }
+        });
+    }
+
+    private void addCrosshair(FrameLayout parent) {
+        View horizontal = new View(getActivity());
+        horizontal.setBackgroundColor(Color.WHITE);
+        FrameLayout.LayoutParams h = new FrameLayout.LayoutParams(dp(64), dp(2));
+        h.gravity = Gravity.CENTER;
+        parent.addView(horizontal, h);
+
+        View vertical = new View(getActivity());
+        vertical.setBackgroundColor(Color.WHITE);
+        FrameLayout.LayoutParams v = new FrameLayout.LayoutParams(dp(2), dp(64));
+        v.gravity = Gravity.CENTER;
+        parent.addView(vertical, v);
+
+        View center = new View(getActivity());
+        center.setBackgroundColor(0x00000000);
+        FrameLayout.LayoutParams c = new FrameLayout.LayoutParams(dp(18), dp(18));
+        c.gravity = Gravity.CENTER;
+        center.setBackgroundResource(android.R.drawable.presence_online);
+        parent.addView(center, c);
+    }
+
+    private int dp(int value) {
+        float density = getActivity().getResources().getDisplayMetrics().density;
+        return Math.round(value * density);
+    }
+
+    private String installedArcoreVersion() {
+        try {
+            return getActivity()
+                    .getPackageManager()
+                    .getPackageInfo("com.google.ar.core", 0)
+                    .versionName;
+        } catch (Exception e) {
+            return "unknown";
+        }
+    }
+
+    private static int intOption(PluginCall call, String key, int defaultValue, int min, int max) {
+        Integer value = call.getInt(key, defaultValue);
+        int resolved = value == null ? defaultValue : value;
+        return Math.max(min, Math.min(max, resolved));
+    }
+
+    private static String safeMessage(Exception e) {
+        String message = e.getMessage();
+        return message == null || message.trim().isEmpty() ? e.getClass().getSimpleName() : message;
+    }
+}

package/android/src/main/res/values/strings.xml

@@ -0,0 +1,3 @@
+<resources>
+    <string name="drawdown_arcore_depth_name">DrawDown ARCore Depth</string>
+</resources>

package/dist/esm/definitions.d.ts

@@ -0,0 +1,54 @@
+export type ArcoreRangeSource = 'arcore_depth16' | 'arcore_raw_depth' | 'arcore_surface_hit';
+export type BoundaryConfidence = 'high' | 'medium' | 'low';
+export interface SupportResult {
+    isSupported: boolean;
+    hasDepthApi: boolean;
+    pluginVersion?: string;
+    message?: string;
+}
+export interface StartDbhSessionOptions {
+    /** RFID/NFC tree tag is the field anchor that identifies the 1.3 m DBH plane. */
+    anchorType?: 'rfid_tag';
+    targetHeightM: 1.3;
+    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+    markerDictionary?: 'DICT_6X6_250';
+    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+    markerId?: 0;
+    /** @deprecated Ignored from v0.1.2; retained only for backward compatibility. */
+    markerSizeCm?: 10;
+}
+export interface StartDbhSessionResult {
+    started: boolean;
+    installationRequested?: boolean;
+    message?: string;
+}
+export interface CaptureDbhSweepOptions {
+    durationMs: number;
+    minObservations: number;
+    maxObservations: number;
+    retainFrames: false;
+}
+export interface DbhObservation {
+    frontSurfaceDepthM: number;
+    /** Effective focal length in pixels along the measured trunk-width axis. */
+    focalLengthXPx: number;
+    /** Trunk tangent-to-tangent apparent width in corresponding image pixels. */
+    trunkWidthPx: number;
+    rangeSource: ArcoreRangeSource;
+    trackingConfidence?: number;
+    boundaryConfidence?: BoundaryConfidence;
+    depthMadM?: number;
+    timestampMs?: number;
+}
+export interface CaptureDbhSweepResult {
+    observations: DbhObservation[];
+    deviceModel?: string;
+    arcoreVersion?: string;
+}
+export interface DrawDownArCoreDepthPlugin {
+    checkSupport(): Promise<SupportResult>;
+    startDbhSession(options: StartDbhSessionOptions): Promise<StartDbhSessionResult>;
+    captureDbhSweep(options: CaptureDbhSweepOptions): Promise<CaptureDbhSweepResult>;
+    stopDbhSession(): Promise<void>;
+}
+//# sourceMappingURL=definitions.d.ts.map

package/dist/esm/definitions.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.d.ts","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,iBAAiB,GAAG,gBAAgB,GAAG,kBAAkB,GAAG,oBAAoB,CAAC;AAC7F,MAAM,MAAM,kBAAkB,GAAG,MAAM,GAAG,QAAQ,GAAG,KAAK,CAAC;AAE3D,MAAM,WAAW,aAAa;IAC5B,WAAW,EAAE,OAAO,CAAC;IACrB,WAAW,EAAE,OAAO,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;IACvB,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,gBAAgB,EAAE,cAAc,CAAC;IACjC,QAAQ,EAAE,CAAC,CAAC;IACZ,YAAY,EAAE,EAAE,CAAC;IACjB,aAAa,EAAE,GAAG,CAAC;CACpB;AAED,MAAM,WAAW,qBAAqB;IACpC,OAAO,EAAE,OAAO,CAAC;IACjB,qBAAqB,CAAC,EAAE,OAAO,CAAC;IAChC,OAAO,CAAC,EAAE,MAAM,CAAC;CAClB;AAED,MAAM,WAAW,sBAAsB;IACrC,UAAU,EAAE,MAAM,CAAC;IACnB,eAAe,EAAE,MAAM,CAAC;IACxB,eAAe,EAAE,MAAM,CAAC;IACxB,YAAY,EAAE,KAAK,CAAC;CACrB;AAED,MAAM,WAAW,cAAc;IAC7B,kBAAkB,EAAE,MAAM,CAAC;IAC3B,4EAA4E;IAC5E,cAAc,EAAE,MAAM,CAAC;IACvB,6EAA6E;IAC7E,YAAY,EAAE,MAAM,CAAC;IACrB,WAAW,EAAE,iBAAiB,CAAC;IAC/B,kBAAkB,CAAC,EAAE,MAAM,CAAC;IAC5B,kBAAkB,CAAC,EAAE,kBAAkB,CAAC;IACxC,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,WAAW,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,qBAAqB;IACpC,YAAY,EAAE,cAAc,EAAE,CAAC;IAC/B,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAED,MAAM,WAAW,yBAAyB;IACxC,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC,CAAC;IACvC,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACjF,eAAe,CAAC,OAAO,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC,CAAC;IACjF,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC,CAAC;CACjC"}

package/dist/esm/definitions.js

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=definitions.js.map

package/dist/esm/definitions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"definitions.js","sourceRoot":"","sources":["../../src/definitions.ts"],"names":[],"mappings":""}

package/dist/esm/index.d.ts

@@ -0,0 +1,5 @@
+import type { DrawDownArCoreDepthPlugin } from './definitions';
+declare const DrawDownArCoreDepth: DrawDownArCoreDepthPlugin;
+export * from './definitions';
+export { DrawDownArCoreDepth };
+//# sourceMappingURL=index.d.ts.map

package/dist/esm/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,yBAAyB,EAAE,MAAM,eAAe,CAAC;AAE/D,QAAA,MAAM,mBAAmB,2BAEvB,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/esm/index.js

@@ -0,0 +1,7 @@
+import { registerPlugin } from '@capacitor/core';
+const DrawDownArCoreDepth = registerPlugin('DrawDownArCoreDepth', {
+    web: () => import('./web').then((m) => new m.DrawDownArCoreDepthWeb()),
+});
+export * from './definitions';
+export { DrawDownArCoreDepth };
+//# sourceMappingURL=index.js.map

package/dist/esm/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,iBAAiB,CAAC;AAGjD,MAAM,mBAAmB,GAAG,cAAc,CAA4B,qBAAqB,EAAE;IAC3F,GAAG,EAAE,GAAG,EAAE,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,IAAI,CAAC,CAAC,CAAC,EAAE,EAAE,CAAC,IAAI,CAAC,CAAC,sBAAsB,EAAE,CAAC;CACvE,CAAC,CAAC;AAEH,cAAc,eAAe,CAAC;AAC9B,OAAO,EAAE,mBAAmB,EAAE,CAAC"}

package/dist/esm/web.d.ts

@@ -0,0 +1,9 @@
+import { WebPlugin } from '@capacitor/core';
+import type { CaptureDbhSweepOptions, CaptureDbhSweepResult, DrawDownArCoreDepthPlugin, StartDbhSessionOptions, StartDbhSessionResult, SupportResult } from './definitions';
+export declare class DrawDownArCoreDepthWeb extends WebPlugin implements DrawDownArCoreDepthPlugin {
+    checkSupport(): Promise<SupportResult>;
+    startDbhSession(_options: StartDbhSessionOptions): Promise<StartDbhSessionResult>;
+    captureDbhSweep(_options: CaptureDbhSweepOptions): Promise<CaptureDbhSweepResult>;
+    stopDbhSession(): Promise<void>;
+}
+//# sourceMappingURL=web.d.ts.map

package/dist/esm/web.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"web.d.ts","sourceRoot":"","sources":["../../src/web.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAC;AAC5C,OAAO,KAAK,EACV,sBAAsB,EACtB,qBAAqB,EACrB,yBAAyB,EACzB,sBAAsB,EACtB,qBAAqB,EACrB,aAAa,EACd,MAAM,eAAe,CAAC;AAEvB,qBAAa,sBAAuB,SAAQ,SAAU,YAAW,yBAAyB;IAClF,YAAY,IAAI,OAAO,CAAC,aAAa,CAAC;IAStC,eAAe,CAAC,QAAQ,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIjF,eAAe,CAAC,QAAQ,EAAE,sBAAsB,GAAG,OAAO,CAAC,qBAAqB,CAAC;IAIjF,cAAc,IAAI,OAAO,CAAC,IAAI,CAAC;CAGtC"}