@octane-xplat/camera 0.7.0

package/dist/native/CameraView.android.js

@@ -0,0 +1,165 @@
+import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
+import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
+import { cx } from "./cx.mobile.js";
+import { defineUniversalComponent, hookSlots, registerElement, universalPlan, universalProps, universalValue, useCallback, useEffect, useRef } from "@nativescript-community/octane";
+import { Application, View } from "@nativescript/core";
+//#region src/CameraView.android.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(4);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "host",
+	"type": "gridlayout",
+	"propsSlot": 0,
+	"children": [{
+		"kind": "host",
+		"type": "camerapreview",
+		"props": {
+			"row": 0,
+			"col": 0
+		},
+		"bindings": [["ref", 1]]
+	}]
+});
+var CameraPreview = class extends View {
+	createNativeView() {
+		const nativeClass = globalThis.com.octanexplat.camera.CameraPreviewView;
+		return new nativeClass(this._context);
+	}
+};
+registerElement("camerapreview", CameraPreview);
+var CameraView = defineUniversalComponent("nativescript", function CameraView(props) {
+	const host = useRef(null, _h$0);
+	const active = props.active !== false;
+	const facing = props.facing ?? "back";
+	const bindHost = useCallback((view) => {
+		host.current = view;
+	}, [], _h$1);
+	useEffect(() => {
+		const nativeView = host.current?.android;
+		if (!nativeView) return;
+		let disposed = false;
+		let provider;
+		let preview;
+		nativeView.setCameraActive(active);
+		if (!active) return () => nativeView.setCameraActive(false);
+		const fail = (message) => props.onError?.({ message });
+		if (!cameraHardwarePresent()) {
+			fail("camera unsupported");
+			return () => nativeView.setCameraActive(false);
+		}
+		ensureCameraPermission().then((granted) => {
+			if (disposed) return;
+			if (!granted) {
+				fail("camera permission denied");
+				return;
+			}
+			try {
+				const context = Application.android.context;
+				const cameraX = globalThis.androidx.camera;
+				const future = cameraX.lifecycle.ProcessCameraProvider.getInstance(context);
+				const executor = globalThis.androidx.core.content.ContextCompat.getMainExecutor(context);
+				future.addListener(new java.lang.Runnable({ run() {
+					if (disposed) return;
+					try {
+						provider = future.get();
+						const selectorClass = cameraX.core.CameraSelector;
+						const lens = facing === "front" ? selectorClass.LENS_FACING_FRONT : selectorClass.LENS_FACING_BACK;
+						const selector = new selectorClass.Builder().requireLensFacing(lens).build();
+						preview = new cameraX.core.Preview.Builder().build();
+						preview.setSurfaceProvider(nativeView.getSurfaceProvider());
+						provider.bindToLifecycle(nativeView, selector, preview);
+						props.onReady?.();
+					} catch (error) {
+						fail(error?.message ?? "camera error");
+					}
+				} }), executor);
+			} catch (error) {
+				fail(error?.message ?? "camera error");
+			}
+		});
+		return () => {
+			disposed = true;
+			nativeView.setCameraActive(false);
+			if (provider && preview) try {
+				provider.unbind(preview);
+			} catch {}
+		};
+	}, [active, facing], _h$2);
+	useEffect(() => {
+		const view = host.current;
+		if (!view) return;
+		applyEscapeProps(view.android, props);
+		props.bind?.({ native: view.android });
+	}, [props.bind, props.android], _h$3);
+	return universalValue(__octaneUniversalPlan0, [universalProps([
+		[
+			"set",
+			"id",
+			props.id
+		],
+		[
+			"set",
+			"rows",
+			"*"
+		],
+		[
+			"set",
+			"columns",
+			"*"
+		],
+		[
+			"set",
+			"className",
+			cx("vx-stack", "vx-cameraview", props.className)
+		],
+		[
+			"set",
+			"style",
+			{
+				backgroundColor: "#000",
+				...props.style
+			}
+		],
+		["spread", layoutChildProps(props)],
+		[
+			"set",
+			"accessible",
+			props.accessible
+		],
+		[
+			"set",
+			"accessibilityLabel",
+			props.accessibilityLabel
+		],
+		[
+			"set",
+			"accessibilityRole",
+			nativeAccessibilityRole(props.accessibilityRole)
+		],
+		[
+			"set",
+			"accessibilityHint",
+			props.accessibilityHint
+		],
+		[
+			"set",
+			"accessibilityValue",
+			props.accessibilityValue
+		],
+		[
+			"set",
+			"accessibilityState",
+			nativeAccessibilityState(props.accessibilityState)
+		],
+		[
+			"set",
+			"accessibilityLiveRegion",
+			props.accessibilityLiveRegion
+		]
+	]), bindHost]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { CameraView };

package/dist/native/CameraView.ios.js

@@ -0,0 +1,130 @@
+import { cameraHardwarePresent, ensureCameraPermission } from "./camera-permission.mobile.js";
+import { startCameraPreview } from "./camera-session.ios.js";
+import { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState } from "./layout-child.js";
+import { cx } from "./cx.mobile.js";
+import { defineUniversalComponent, hookSlots, universalPlan, universalProps, universalValue, useCallback, useEffect, useRef } from "@nativescript-community/octane";
+//#region src/CameraView.ios.tsrx
+var _hs$ = /* @__PURE__ */ hookSlots(4);
+var _h$0 = /* @__PURE__ */ Symbol(_hs$);
+var _h$1 = /* @__PURE__ */ Symbol(_hs$ + 1);
+var _h$2 = /* @__PURE__ */ Symbol(_hs$ + 2);
+var _h$3 = /* @__PURE__ */ Symbol(_hs$ + 3);
+var __octaneUniversalPlan0 = universalPlan("nativescript", {
+	"kind": "host",
+	"type": "gridlayout",
+	"propsSlot": 0
+});
+var CameraView = defineUniversalComponent("nativescript", function CameraView(props) {
+	const host = useRef(null, _h$0);
+	const active = props.active !== false;
+	const facing = props.facing ?? "back";
+	const bindHost = useCallback((view) => {
+		host.current = view;
+	}, [], _h$1);
+	useEffect(() => {
+		const view = host.current;
+		if (!view || !active) return;
+		let disposed = false;
+		let stopPreview;
+		const fail = (message) => props.onError?.({ message });
+		if (!cameraHardwarePresent()) {
+			fail("camera unsupported");
+			return;
+		}
+		ensureCameraPermission().then((granted) => {
+			if (disposed) return;
+			if (!granted) {
+				fail("camera permission denied");
+				return;
+			}
+			try {
+				stopPreview = startCameraPreview(view, facing, props.onReady);
+			} catch (error) {
+				fail(error?.message ?? "camera error");
+			}
+		});
+		return () => {
+			disposed = true;
+			stopPreview?.();
+		};
+	}, [active, facing], _h$2);
+	useEffect(() => {
+		const view = host.current;
+		if (!view) return;
+		applyEscapeProps(view.ios ?? view.nativeViewProtected, props);
+		props.bind?.({ native: view.ios ?? view.nativeViewProtected });
+	}, [props.bind, props.ios], _h$3);
+	return universalValue(__octaneUniversalPlan0, [universalProps([
+		[
+			"set",
+			"ref",
+			bindHost
+		],
+		[
+			"set",
+			"id",
+			props.id
+		],
+		[
+			"set",
+			"rows",
+			"*"
+		],
+		[
+			"set",
+			"columns",
+			"*"
+		],
+		[
+			"set",
+			"className",
+			cx("vx-stack", "vx-cameraview", props.className)
+		],
+		[
+			"set",
+			"style",
+			{
+				backgroundColor: "#000",
+				...props.style
+			}
+		],
+		["spread", layoutChildProps(props)],
+		[
+			"set",
+			"accessible",
+			props.accessible
+		],
+		[
+			"set",
+			"accessibilityLabel",
+			props.accessibilityLabel
+		],
+		[
+			"set",
+			"accessibilityRole",
+			nativeAccessibilityRole(props.accessibilityRole)
+		],
+		[
+			"set",
+			"accessibilityHint",
+			props.accessibilityHint
+		],
+		[
+			"set",
+			"accessibilityValue",
+			props.accessibilityValue
+		],
+		[
+			"set",
+			"accessibilityState",
+			nativeAccessibilityState(props.accessibilityState)
+		],
+		[
+			"set",
+			"accessibilityLiveRegion",
+			props.accessibilityLiveRegion
+		]
+	])]);
+}, { "module": "@nativescript-community/octane" });
+//#endregion
+export { CameraView };

package/dist/native/camera-permission.mobile.js

@@ -0,0 +1,45 @@
+import { Application, isAndroid, isIOS } from "@nativescript/core";
+//#region src/camera-permission.mobile.ts
+var requestCode = 7719;
+function cameraHardwarePresent() {
+	if (isIOS) return typeof globalThis.AVCaptureDevice !== "undefined";
+	if (!isAndroid) return false;
+	try {
+		return (Application.android?.context ?? Application.android?.startActivity)?.packageManager?.hasSystemFeature("android.hardware.camera.any") !== false;
+	} catch {
+		return true;
+	}
+}
+async function ensureCameraPermission() {
+	try {
+		if (isIOS) {
+			const av = globalThis.AVCaptureDevice;
+			const mediaType = globalThis.AVMediaTypeVideo ?? "vide";
+			const status = av?.authorizationStatusForMediaType?.(mediaType);
+			if (status === 3) return true;
+			if (status === 1 || status === 2) return false;
+			return await new Promise((resolve) => av.requestAccessForMediaTypeCompletionHandler(mediaType, resolve));
+		}
+		if (isAndroid) {
+			const permission = "android.permission.CAMERA";
+			const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+			if (activity?.checkSelfPermission?.(permission) === android.content.pm.PackageManager.PERMISSION_GRANTED) return true;
+			if (!activity) return false;
+			return await new Promise((resolve) => {
+				const currentRequest = requestCode++;
+				const onResult = (args) => {
+					if (args.requestCode !== currentRequest) return;
+					Application.android.off(Application.android.activityRequestPermissionsEvent, onResult);
+					resolve(args.grantResults?.[0] === android.content.pm.PackageManager.PERMISSION_GRANTED);
+				};
+				Application.android.on(Application.android.activityRequestPermissionsEvent, onResult);
+				activity.requestPermissions([permission], currentRequest);
+			});
+		}
+	} catch {
+		return false;
+	}
+	return false;
+}
+//#endregion
+export { cameraHardwarePresent, ensureCameraPermission };

package/dist/native/camera-session.ios.js

@@ -0,0 +1,45 @@
+//#region src/camera-session.ios.ts
+/** Attach an AVFoundation preview layer to a NativeScript UIView host. */
+function startCameraPreview(view, facing, onReady) {
+	const av = globalThis;
+	const mediaType = av.AVMediaTypeVideo ?? "vide";
+	const desiredPosition = facing === "front" ? av.AVCaptureDevicePositionFront ?? 2 : av.AVCaptureDevicePositionBack ?? 1;
+	const devices = av.AVCaptureDevice.devicesWithMediaType(mediaType);
+	let device = null;
+	for (let index = 0; index < devices.count; index++) {
+		const candidate = devices.objectAtIndex(index);
+		if (candidate.position === desiredPosition) {
+			device = candidate;
+			break;
+		}
+	}
+	if (!device) throw new Error("camera unavailable");
+	const session = av.AVCaptureSession.new();
+	const input = av.AVCaptureDeviceInput.deviceInputWithDeviceError(device);
+	if (!input || !session.canAddInput(input)) throw new Error("camera input unavailable");
+	session.addInput(input);
+	const layer = av.AVCaptureVideoPreviewLayer.layerWithSession(session);
+	layer.videoGravity = "resizeAspectFill";
+	const connection = layer.connection;
+	if (connection) {
+		connection.automaticallyAdjustsVideoMirroring = false;
+		if (connection.isVideoMirroringSupported) connection.isVideoMirrored = facing === "front";
+	}
+	const nativeView = view.ios ?? view.nativeViewProtected;
+	if (!nativeView?.layer) throw new Error("camera preview host unavailable");
+	nativeView.layer.addSublayer(layer);
+	const updateFrame = () => {
+		layer.frame = nativeView.bounds;
+	};
+	view.on?.("layoutChanged", updateFrame);
+	updateFrame();
+	session.startRunning();
+	onReady?.();
+	return () => {
+		view.off?.("layoutChanged", updateFrame);
+		session.stopRunning();
+		layer.removeFromSuperlayer();
+	};
+}
+//#endregion
+export { startCameraPreview };

package/dist/native/cx.mobile.js

@@ -0,0 +1,8 @@
+//#region src/cx.mobile.ts
+/** NativeScript's universal driver stringifies className values; normalize
+* arrays here so they stay space separated. */
+function cx(...parts) {
+	return parts.flat(Infinity).filter(Boolean).join(" ");
+}
+//#endregion
+export { cx };

package/dist/native/index.js

@@ -0,0 +1,2 @@
+import { CameraView } from "./src/CameraView";
+export { CameraView };

package/dist/native/layout-child.js

@@ -0,0 +1,53 @@
+import { isIOS } from "@nativescript/core";
+//#region src/layout-child.ts
+/** NativeScript reads layout fields from a child view during parent layout. */
+function layoutChildProps(props) {
+	const result = {};
+	for (const key of [
+		"row",
+		"col",
+		"rowSpan",
+		"colSpan",
+		"dock",
+		"left",
+		"top",
+		"flexGrow",
+		"flexShrink",
+		"alignSelf",
+		"order"
+	]) if (props[key] !== void 0) result[key] = props[key];
+	return result;
+}
+function applyEscapeProps(view, props) {
+	if (!view) return;
+	const bag = isIOS ? props.ios : props.android;
+	if (bag) Object.assign(view, bag);
+}
+var nativeRoles = {
+	button: "button",
+	link: "link",
+	search: "search",
+	image: "image",
+	heading: "header",
+	adjustable: "adjustable",
+	summary: "summary",
+	text: "text",
+	none: "none",
+	progressbar: "progressBar",
+	checkbox: "checkbox",
+	switch: "switch",
+	radio: "radioButton",
+	spinbutton: "spinButton",
+	tab: "button"
+};
+function nativeAccessibilityRole(role) {
+	return role ? nativeRoles[role] : void 0;
+}
+function nativeAccessibilityState(state) {
+	if (state?.disabled) return "disabled";
+	if (state?.selected) return "selected";
+	if (state?.checked === true) return "checked";
+	if (state?.checked === false) return "unchecked";
+}
+//#endregion
+export { applyEscapeProps, layoutChildProps, nativeAccessibilityRole, nativeAccessibilityState };

package/dist/native/octane-client-build.json

@@ -0,0 +1,8 @@
+{
+  "version": 1,
+  "buildId": "6078389e-4315-40ab-b7f8-31cd00bc0232",
+  "mode": "production",
+  "capabilities": {
+    "independentHydration": false
+  }
+}