@octane-xplat/camera 0.12.0 → 0.14.0

package/dist/native/session-backend.android.js

@@ -0,0 +1,234 @@
+import { CameraCaptureError } from "./types.js";
+import { Application } from "@nativescript/core";
+//#region src/session-backend.android.ts
+var requestCode = 7820;
+var permissionChain = Promise.resolve();
+var owner;
+var nativeBridge = () => globalThis.com?.octanexplat?.camera?.CameraSessionBridge;
+var permissionName = (kind) => kind === "camera" ? "android.permission.CAMERA" : "android.permission.RECORD_AUDIO";
+var error = (kind, operation, message, cause) => new CameraCaptureError({
+	kind,
+	operation,
+	message,
+	cause
+});
+var context = () => Application.android.context;
+var preferences = () => context().getSharedPreferences("octane-camera-permissions", 0);
+async function checkPermission(kind) {
+	const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+	if (!activity) return "unavailable";
+	const permission = permissionName(kind);
+	if (activity.checkSelfPermission(permission) === 0) return "granted";
+	return preferences().getBoolean(kind, false) ? activity.shouldShowRequestPermissionRationale(permission) ? "denied" : "blocked" : "notDetermined";
+}
+function requestPermission(kind) {
+	const result = permissionChain.then(async () => {
+		const status = await checkPermission(kind);
+		if (status !== "notDetermined") return status;
+		const activity = Application.android.foregroundActivity ?? Application.android.startActivity;
+		if (!activity) return "unavailable";
+		return new Promise((resolve) => {
+			const code = requestCode++;
+			const finish = (value) => {
+				clearTimeout(timer);
+				Application.android.off(Application.android.activityRequestPermissionsEvent, onResult);
+				resolve(value);
+			};
+			const onResult = (args) => {
+				if (args.requestCode !== code) return;
+				if (!args.grantResults?.length) {
+					finish("unknown");
+					return;
+				}
+				preferences().edit().putBoolean(kind, true).apply();
+				finish(args.grantResults[0] === 0 ? "granted" : activity.shouldShowRequestPermissionRationale(permissionName(kind)) ? "denied" : "blocked");
+			};
+			const timer = setTimeout(() => finish("unknown"), 12e4);
+			Application.android.on(Application.android.activityRequestPermissionsEvent, onResult);
+			try {
+				activity.requestPermissions([permissionName(kind)], code);
+			} catch {
+				finish("unavailable");
+			}
+		});
+	});
+	permissionChain = result.catch(() => {});
+	return result;
+}
+function createSessionBackend(config) {
+	let currentConfig = { ...config };
+	let observer;
+	let bridge;
+	let host;
+	let listener;
+	let sink;
+	let released = false;
+	const lease = {};
+	const selected = () => typeof currentConfig.camera === "object" ? `id:${currentConfig.camera.deviceId}` : currentConfig.camera ?? "default";
+	const releaseLease = () => {
+		if (owner === lease) owner = void 0;
+	};
+	const onSuspend = () => bridge?.background();
+	const onResume = () => bridge?.foreground();
+	const ensureBridge = () => {
+		if (bridge) return;
+		const Bridge = nativeBridge();
+		if (!Bridge) throw error("unsupportedPlatform", "preview", "CameraX video bridge is missing from the native build");
+		bridge = new Bridge(context(), new Bridge.Listener({ event(type, payload) {
+			if (type === "ready") {
+				observer?.previewReady(payload === "true");
+				if (payload === "true") listener?.onReady?.();
+			} else if (type === "availability") observer?.availability(payload === "true");
+			else if (type === "interruption") observer?.interruption("began", payload);
+			else if (type === "recovered") observer?.interruption("ended", payload);
+			else if (type === "previewError") {
+				observer?.availability(false);
+				listener?.onError?.(error("unavailable", "preview", payload));
+				if (!host) releaseLease();
+			} else if (type === "finishing") sink?.finishing(payload ? payload : void 0);
+			else if (type === "started") sink?.started(JSON.parse(payload));
+			else if (type === "finished" || type === "failed") {
+				const target = sink;
+				sink = void 0;
+				if (!host) releaseLease();
+				const result = JSON.parse(payload);
+				target?.settled(type === "finished" ? result : {
+					kind: "failed",
+					stage: result.stage,
+					issue: error(result.kind, result.stage, result.message)
+				});
+			}
+		} }));
+		Application.on(Application.suspendEvent, onSuspend);
+		Application.on(Application.resumeEvent, onResume);
+	};
+	return {
+		platform: "android",
+		get supported() {
+			return !!nativeBridge();
+		},
+		checkPermission,
+		requestPermission: async (kind) => {
+			const status = await requestPermission(kind);
+			if (kind === "camera" && status === "granted" && host && !sink && !released && !bridge?.isReady()) try {
+				ensureBridge();
+				bridge.attach(host, selected());
+			} catch (cause) {
+				observer?.availability(false);
+				listener?.onError?.(error("unavailable", "preview", "Could not activate CameraX after permission approval", cause));
+			}
+			return status;
+		},
+		getCapabilities: async () => {
+			const value = bridge ? JSON.parse(bridge.capabilities()) : {
+				cameras: [],
+				profiles: []
+			};
+			const supported = !!nativeBridge();
+			return {
+				supported,
+				available: !!bridge?.isReady(),
+				reason: !supported ? "CameraX video bridge is missing from the native build" : !bridge?.isReady() ? "An active permitted preview is required" : void 0,
+				cameras: value.cameras,
+				profiles: value.profiles,
+				audio: context().getPackageManager().hasSystemFeature("android.hardware.microphone"),
+				orientations: [],
+				durationLimit: "native",
+				elapsedTime: "nativeMedia",
+				output: {
+					mimeType: "video/mp4",
+					container: "mp4",
+					storage: "appPrivateFile",
+					destinationFileUrl: true
+				}
+			};
+		},
+		previewReady: () => !!bridge?.isReady(),
+		validateStart: (options) => {
+			if (options.maximumDurationMs !== void 0 && options.maximumDurationMs > 9223372036854) throw error("unsupportedConfiguration", "startRecording", "The duration exceeds CameraX media-time range");
+			if (options.orientation && options.orientation !== "unspecified") throw error("unsupportedConfiguration", "startRecording", "Fixed cardinal orientation has not been qualified on this Android source");
+		},
+		attachPreview: (target, callbacks) => {
+			if (released || sink) throw error("invalidState", "attachPreview", "The camera is disposed or finalizing");
+			if (owner && owner !== lease) throw error("busy", "attachPreview", "Another camera session is still finalizing");
+			owner = lease;
+			host = target;
+			listener = callbacks;
+			try {
+				ensureBridge();
+			} catch (cause) {
+				host = void 0;
+				listener = void 0;
+				releaseLease();
+				throw error("unavailable", "attachPreview", "Could not construct the CameraX native bridge", cause);
+			}
+			checkPermission("camera").then((status) => {
+				if (released || !host) return;
+				if (status !== "granted") {
+					listener?.onError?.(error("permissionDenied", "preview", "Request camera permission before activating this preview"));
+					return;
+				}
+				try {
+					bridge.attach(host, selected());
+				} catch (cause) {
+					listener?.onError?.(error("unavailable", "preview", "Could not bind shared CameraX preview", cause));
+				}
+			});
+			return () => {
+				host = void 0;
+				listener = void 0;
+				bridge.detach();
+				if (!sink) releaseLease();
+			};
+		},
+		configure: (next) => {
+			const sourceChanged = JSON.stringify(next.camera) !== JSON.stringify(currentConfig.camera) || next.profile !== currentConfig.profile;
+			currentConfig = { ...next };
+			if (host && sourceChanged) {
+				bridge.detach();
+				bridge.attach(host, selected());
+			}
+		},
+		startCapture: (request, target) => {
+			sink = target;
+			try {
+				bridge.start(request.audio, request.destinationPath ?? "", request.maximumDurationMs === void 0 ? 0 : Math.max(1, Math.ceil(request.maximumDurationMs)));
+			} catch (cause) {
+				sink = void 0;
+				target.settled({
+					kind: "failed",
+					stage: "preparation",
+					issue: error("captureFailed", "startRecording", "CameraX could not begin recording", cause)
+				});
+			}
+		},
+		stopCapture: () => bridge?.stop(),
+		elapsedMs: () => Number(bridge?.elapsedMs() ?? 0),
+		openOutput: async (output) => {
+			if (output.kind !== "nativeFile" || output.synthetic) throw error("invalidArgument", "openOutput", "Expected a native Android movie reference");
+			try {
+				const url = nativeBridge().openOutput(output.resourceId, output.fileUrl);
+				return {
+					url,
+					fileUrl: url,
+					release: () => {}
+				};
+			} catch (cause) {
+				throw error("destinationUnavailable", "openOutput", "The stored Android movie cannot be reopened", cause);
+			}
+		},
+		release: async () => {
+			released = true;
+			Application.off(Application.suspendEvent, onSuspend);
+			Application.off(Application.resumeEvent, onResume);
+			bridge?.release();
+			host = void 0;
+			releaseLease();
+		},
+		setObserver: (value) => {
+			observer = value;
+		}
+	};
+}
+//#endregion
+export { createSessionBackend };