@sigx/lynx-camera 0.1.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 Andreas Ekdahl
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,72 @@
+# @sigx/lynx-camera
+
+Photo capture via the system camera for sigx-lynx. iOS uses `UIImagePickerController`; Android uses an `ACTION_IMAGE_CAPTURE` intent fed by a `FileProvider` URI (the cache-path is wired by the app template's manifest).
+
+## Install
+
+```bash
+pnpm add @sigx/lynx-camera
+```
+
+```ts
+// sigx.lynx.config.ts
+export default defineLynxConfig({
+    modules: ['@sigx/lynx-camera'],
+});
+```
+
+`sigx prebuild` auto-links the native module, injects `android.permission.CAMERA`, and adds the iOS usage descriptions:
+
+- `NSCameraUsageDescription`
+- `NSMicrophoneUsageDescription`
+- `NSPhotoLibraryAddUsageDescription`
+
+Override the prompts in your `sigx.lynx.config.ts` under `ios.usageDescriptions` if you want app-specific copy.
+
+> **Android pairs with `@sigx/lynx-permissions`** — that's where the runtime permission prompt + Activity Result wiring lives. Add it to your modules list (or anything that depends on it does, transitively).
+
+## Usage
+
+```ts
+import { Camera } from '@sigx/lynx-camera';
+
+const { status } = await Camera.requestPermission();
+if (status === 'granted') {
+    const photo = await Camera.takePicture({ quality: 0.8, facing: 'back' });
+    console.log(photo.uri, photo.width, photo.height);
+}
+```
+
+## API
+
+| Method                                                    | Notes                                                                                                                |
+| --------------------------------------------------------- | -------------------------------------------------------------------------------------------------------------------- |
+| `takePicture(options?: CameraOptions): Promise<PhotoResult>` | Opens the system camera. Returns the captured photo's file URI + dimensions. Throws if cancelled or denied.       |
+| `requestPermission(): Promise<PermissionResponse>`        | Shows the OS permission dialog if needed. Re-call to surface the dialog again on first denial.                       |
+| `getPermissionStatus(): Promise<PermissionResponse>`      | Read-only check — no prompt.                                                                                         |
+| `isAvailable(): boolean`                                  | Whether the native module is registered in the current build.                                                        |
+
+```ts
+interface CameraOptions {
+    facing?: 'front' | 'back';   // default: 'back'
+    quality?: number;            // 0..1
+    maxWidth?: number;           // pixels
+    maxHeight?: number;          // pixels
+}
+
+interface PhotoResult {
+    uri: string;        // file:// URI
+    width: number;
+    height: number;
+    base64?: string;    // populated only if requested
+}
+```
+
+## Gotchas
+
+- **Android FileProvider** — the auto-injected `<provider>` in the app template's `AndroidManifest.xml` exposes the cache directory under `${applicationId}.fileprovider`. If you customize the manifest, keep that authority intact or the camera intent won't have a valid write target.
+- **iOS simulator camera** — the simulator has a synthetic camera feed, not a real one. Test capture on a physical device.
+
+## Reference app
+
+`examples/lynx-one/my-sigx-app/src/cards/CameraCard.tsx` covers permission + capture + display flows end-to-end.

package/android/com/sigx/camera/CameraModule.kt

@@ -0,0 +1,49 @@
+package com.sigx.camera
+
+import android.content.Context
+import android.util.Log
+import com.lynx.jsbridge.LynxMethod
+import com.lynx.jsbridge.LynxModule
+import com.lynx.react.bridge.Callback
+import com.lynx.react.bridge.JavaOnlyMap
+import com.sigx.permissions.PermissionHelper
+
+/**
+ * Camera capture module using system camera intent.
+ * JS usage: NativeModules.Camera.takePicture({ quality: 0.8 }, callback)
+ */
+class CameraModule(context: Context) : LynxModule(context) {
+
+    companion object {
+        private const val TAG = "CameraModule"
+        const val REQUEST_IMAGE_CAPTURE = 9001
+    }
+
+    @LynxMethod
+    fun takePicture(options: com.lynx.react.bridge.ReadableMap?, callback: Callback?) {
+        // Delegates to MediaCapture (in @sigx/lynx-permissions) which holds
+        // the ActivityResultContracts.TakePicture launcher registered at
+        // MainActivity.onCreate. On success, the JS callback receives
+        // { uri: "content://...", canceled: false } pointing at a JPEG in
+        // the app's cacheDir. Quality option is currently ignored — the
+        // system camera picks its own settings; we'll plumb it through
+        // when we add a CameraX-based custom-UI module.
+        com.sigx.permissions.MediaCapture.takePicture(mContext) { result ->
+            callback?.invoke(result)
+        }
+    }
+
+    @LynxMethod
+    fun requestPermission(callback: Callback?) {
+        PermissionHelper.requestPermission(mContext, "camera") { result ->
+            callback?.invoke(result)
+        }
+    }
+
+    @LynxMethod
+    fun getPermissionStatus(callback: Callback?) {
+        val result = PermissionHelper.checkPermission(mContext, "camera")
+        callback?.invoke(result)
+    }
+}
+

package/dist/camera.d.ts

@@ -0,0 +1,44 @@
+import type { PermissionResponse } from '@sigx/lynx-core';
+export interface CameraOptions {
+    /** 'front' or 'back' camera */
+    facing?: 'front' | 'back';
+    /** Image quality 0-1 */
+    quality?: number;
+    /** Max width in pixels */
+    maxWidth?: number;
+    /** Max height in pixels */
+    maxHeight?: number;
+}
+export interface PhotoResult {
+    /** File URI of the captured photo */
+    uri: string;
+    /** Width in pixels */
+    width: number;
+    /** Height in pixels */
+    height: number;
+    /** Base64-encoded image data (if requested) */
+    base64?: string;
+}
+/**
+ * Camera capture APIs.
+ *
+ * @example
+ * ```ts
+ * import { Camera } from '@sigx/lynx-camera';
+ *
+ * const { status } = await Camera.requestPermission();
+ * if (status === 'granted') {
+ *     const photo = await Camera.takePicture({ quality: 0.8 });
+ *     console.log(photo.uri);
+ * }
+ * ```
+ */
+export declare const Camera: {
+    readonly takePicture: (options?: CameraOptions) => Promise<PhotoResult>;
+    /** Request camera permission, showing the OS dialog if needed. */
+    readonly requestPermission: () => Promise<PermissionResponse>;
+    /** Check current camera permission status without prompting. */
+    readonly getPermissionStatus: () => Promise<PermissionResponse>;
+    readonly isAvailable: () => boolean;
+};
+//# sourceMappingURL=camera.d.ts.map

package/dist/camera.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.d.ts","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC;AAI1D,MAAM,WAAW,aAAa;IAC1B,+BAA+B;IAC/B,MAAM,CAAC,EAAE,OAAO,GAAG,MAAM,CAAC;IAC1B,wBAAwB;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,0BAA0B;IAC1B,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,2BAA2B;IAC3B,SAAS,CAAC,EAAE,MAAM,CAAC;CACtB;AAED,MAAM,WAAW,WAAW;IACxB,qCAAqC;IACrC,GAAG,EAAE,MAAM,CAAC;IACZ,sBAAsB;IACtB,KAAK,EAAE,MAAM,CAAC;IACd,uBAAuB;IACvB,MAAM,EAAE,MAAM,CAAC;IACf,+CAA+C;IAC/C,MAAM,CAAC,EAAE,MAAM,CAAC;CACnB;AAED;;;;;;;;;;;;;GAaG;AACH,eAAO,MAAM,MAAM;qCACM,aAAa,KAAQ,OAAO,CAAC,WAAW,CAAC;IAI9D,kEAAkE;sCAC7C,OAAO,CAAC,kBAAkB,CAAC;IAIhD,gEAAgE;wCACzC,OAAO,CAAC,kBAAkB,CAAC;gCAInC,OAAO;CAGhB,CAAC"}

package/dist/camera.js

@@ -0,0 +1,33 @@
+import { callAsync, isModuleAvailable } from '@sigx/lynx-core';
+const MODULE = 'Camera';
+/**
+ * Camera capture APIs.
+ *
+ * @example
+ * ```ts
+ * import { Camera } from '@sigx/lynx-camera';
+ *
+ * const { status } = await Camera.requestPermission();
+ * if (status === 'granted') {
+ *     const photo = await Camera.takePicture({ quality: 0.8 });
+ *     console.log(photo.uri);
+ * }
+ * ```
+ */
+export const Camera = {
+    takePicture(options = {}) {
+        return callAsync(MODULE, 'takePicture', options);
+    },
+    /** Request camera permission, showing the OS dialog if needed. */
+    requestPermission() {
+        return callAsync(MODULE, 'requestPermission');
+    },
+    /** Check current camera permission status without prompting. */
+    getPermissionStatus() {
+        return callAsync(MODULE, 'getPermissionStatus');
+    },
+    isAvailable() {
+        return isModuleAvailable(MODULE);
+    },
+};
+//# sourceMappingURL=camera.js.map

package/dist/camera.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"camera.js","sourceRoot":"","sources":["../src/camera.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,iBAAiB,CAAC;AAG/D,MAAM,MAAM,GAAG,QAAQ,CAAC;AAwBxB;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,MAAM,MAAM,GAAG;IAClB,WAAW,CAAC,UAAyB,EAAE;QACnC,OAAO,SAAS,CAAc,MAAM,EAAE,aAAa,EAAE,OAAO,CAAC,CAAC;IAClE,CAAC;IAED,kEAAkE;IAClE,iBAAiB;QACb,OAAO,SAAS,CAAqB,MAAM,EAAE,mBAAmB,CAAC,CAAC;IACtE,CAAC;IAED,gEAAgE;IAChE,mBAAmB;QACf,OAAO,SAAS,CAAqB,MAAM,EAAE,qBAAqB,CAAC,CAAC;IACxE,CAAC;IAED,WAAW;QACP,OAAO,iBAAiB,CAAC,MAAM,CAAC,CAAC;IACrC,CAAC;CACK,CAAC"}

package/dist/index.d.ts

@@ -0,0 +1,4 @@
+export { Camera } from './camera.js';
+export type { CameraOptions, PhotoResult } from './camera.js';
+export type { PermissionResponse } from '@sigx/lynx-core';
+//# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC;AACrC,YAAY,EAAE,aAAa,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAC9D,YAAY,EAAE,kBAAkB,EAAE,MAAM,iBAAiB,CAAC"}

package/dist/index.js

@@ -0,0 +1,2 @@
+export { Camera } from './camera.js';
+//# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAC"}

package/ios/CameraModule.swift

@@ -0,0 +1,127 @@
+import UIKit
+import AVFoundation
+import Lynx
+
+/// Camera capture module.
+/// JS usage: NativeModules.Camera.takePicture({ quality: 0.8 }, callback)
+class CameraModule: NSObject, LynxModule, UIImagePickerControllerDelegate, UINavigationControllerDelegate {
+
+    @objc static var name: String { "Camera" }
+
+    @objc static var methodLookup: [String: String] {
+        [
+            "takePicture": NSStringFromSelector(#selector(takePicture(_:callback:))),
+            "requestPermission": NSStringFromSelector(#selector(requestPermission(_:))),
+            "getPermissionStatus": NSStringFromSelector(#selector(getPermissionStatus(_:))),
+        ]
+    }
+
+    private var pendingCallback: LynxCallbackBlock?
+
+    required override init() { super.init() }
+    required init(param: Any) { super.init() }
+
+    @objc func takePicture(_ options: [String: Any]?, callback: LynxCallbackBlock?) {
+        guard UIImagePickerController.isSourceTypeAvailable(.camera) else {
+            callback?(["error": "Camera not available on this device"])
+            return
+        }
+
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        guard status == .authorized else {
+            if status == .notDetermined {
+                AVCaptureDevice.requestAccess(for: .video) { [weak self] granted in
+                    if granted {
+                        self?.presentCamera(options: options, callback: callback)
+                    } else {
+                        callback?(["error": "Camera permission denied"])
+                    }
+                }
+                return
+            }
+            callback?(["error": "Camera permission not granted"])
+            return
+        }
+
+        presentCamera(options: options, callback: callback)
+    }
+
+    @objc func requestPermission(_ callback: LynxCallbackBlock?) {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        if status == .notDetermined {
+            AVCaptureDevice.requestAccess(for: .video) { granted in
+                callback?(["status": granted ? "granted" : "denied"])
+            }
+        } else {
+            callback?(["status": permissionString(for: status)])
+        }
+    }
+
+    @objc func getPermissionStatus(_ callback: LynxCallbackBlock?) {
+        let status = AVCaptureDevice.authorizationStatus(for: .video)
+        callback?(["status": permissionString(for: status)])
+    }
+
+    private func presentCamera(options: [String: Any]?, callback: LynxCallbackBlock?) {
+        DispatchQueue.main.async { [weak self] in
+            guard let self = self else { return }
+            self.pendingCallback = callback
+
+            let picker = UIImagePickerController()
+            picker.sourceType = .camera
+            picker.delegate = self
+            picker.allowsEditing = false
+
+            UIApplication.shared.windows.first?.rootViewController?.present(picker, animated: true)
+        }
+    }
+
+    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
+        picker.dismiss(animated: true)
+
+        guard let image = info[.originalImage] as? UIImage else {
+            pendingCallback?(["error": "Failed to capture image"])
+            pendingCallback = nil
+            return
+        }
+
+        let quality: CGFloat = 0.8
+        guard let data = image.jpegData(compressionQuality: quality) else {
+            pendingCallback?(["error": "Failed to compress image"])
+            pendingCallback = nil
+            return
+        }
+
+        let fileName = "camera_\(UUID().uuidString).jpg"
+        let tempPath = NSTemporaryDirectory() + fileName
+        do {
+            try data.write(to: URL(fileURLWithPath: tempPath))
+            let result: [String: Any] = [
+                "uri": tempPath,
+                "width": Int(image.size.width),
+                "height": Int(image.size.height),
+                "fileSize": data.count,
+            ]
+            pendingCallback?(result)
+        } catch {
+            pendingCallback?(["error": error.localizedDescription])
+        }
+        pendingCallback = nil
+    }
+
+    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true)
+        pendingCallback?(["cancelled": true])
+        pendingCallback = nil
+    }
+
+    private func permissionString(for status: AVAuthorizationStatus) -> String {
+        switch status {
+        case .notDetermined: return "undetermined"
+        case .restricted:    return "restricted"
+        case .denied:        return "denied"
+        case .authorized:    return "granted"
+        @unknown default:    return "unknown"
+        }
+    }
+}

package/package.json

@@ -0,0 +1,33 @@
+{
+  "name": "@sigx/lynx-camera",
+  "version": "0.1.0",
+  "description": "Camera capture for sigx-lynx",
+  "type": "module",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/index.js",
+      "types": "./dist/index.d.ts"
+    },
+    "./sigx-module.json": "./sigx-module.json"
+  },
+  "files": [
+    "dist",
+    "ios",
+    "android",
+    "sigx-module.json"
+  ],
+  "dependencies": {
+    "@sigx/lynx-core": "^0.1.0"
+  },
+  "devDependencies": {
+    "typescript": "^5.9.3"
+  },
+  "author": "Andreas Ekdahl",
+  "license": "MIT",
+  "scripts": {
+    "build": "tsc",
+    "dev": "tsc --watch"
+  }
+}

package/sigx-module.json

@@ -0,0 +1,21 @@
+{
+    "name": "Camera",
+    "package": "@sigx/lynx-camera",
+    "description": "Photo/video capture",
+    "platforms": ["android", "ios"],
+    "ios": {
+        "moduleClass": "CameraModule",
+        "sourceDir": "ios",
+        "methods": ["takePicture","requestPermission","getPermissionStatus"],
+        "usageDescriptions": {
+            "NSCameraUsageDescription": "Allow camera access to take photos and videos.",
+            "NSMicrophoneUsageDescription": "Allow microphone access to record video with audio.",
+            "NSPhotoLibraryAddUsageDescription": "Allow access to save captured photos to your library."
+        }
+    },
+    "android": {
+        "moduleClass": "com.sigx.camera.CameraModule",
+        "sourceDir": "android",
+        "permissions": ["android.permission.CAMERA"]
+    }
+}