react-native-ensys-camera-x 1.0.7

package/src/NativeCustomCamera.ts

@@ -0,0 +1,305 @@
+import { TurboModuleRegistry, type TurboModule } from 'react-native';
+
+const createStubModule = (): Spec => ({
+  openCamera: async () => '',
+  openCameraPicker: async () => ({ cancelled: true, assets: [] }),
+  openDocumentPicker: async () => ({ cancelled: true, assets: [] }),
+  openAudioPicker: async () => ({ cancelled: true, assets: [] }),
+  openImageVideoPicker: async () => ({ cancelled: true, assets: [] }),
+  openMediaEditor: async () => ({ cancelled: true, assets: [] }),
+  openDocument: async () => false,
+  startUpload: async () => undefined,
+  getUploadState: async () => '[]',
+  getNotificationHistory: async () => '[]',
+  clearNotificationHistory: async () => undefined,
+  getDeviceCapabilities: async () => ({}),
+  cropImage: async () => '',
+  rotateImage: async () => '',
+  applyFilter: async () => '',
+  createAlbum: async () => false,
+  moveMediaToAlbum: async () => false,
+  deleteMedia: async () => false,
+  secureDeleteMedia: async () => ({
+    deleted: false,
+    securelyOverwritten: false,
+    fullySecure: false,
+    originalBytes: 0,
+    overwrittenBytes: 0,
+    derivedFilesErased: 0,
+    derivedFilesFailed: 0,
+  }),
+  deleteStoredMedia: async () => false,
+  shareMedia: async () => false,
+  setCameraFlash: async () => undefined,
+  setCameraTimer: async () => undefined,
+  enableCameraGrid: async () => undefined,
+  setMediaCaption: async () => false,
+  getMediaMetadata: async () => ({}),
+  getRecordedOriginalSize: async () => 0,
+  trimVideo: async () => '',
+  compressVideo: async () => '',
+  compressImage: async () => '',
+  scanQRCode: async () => '',
+  enableFaceDetection: async () => undefined,
+  setFaceEffect: async () => undefined,
+  setCameraTheme: async () => undefined,
+  setCameraConfig: async () => undefined,
+  // Media Storage Features
+  initializeMediaStorage: async () => ({ success: true }),
+  publishMedia: async () => ({ success: false }),
+  publishBatch: async () => ({
+    totalCount: 0,
+    successCount: 0,
+    failureCount: 0,
+  }),
+  getCachedMedia: async () => [],
+  getPublishedMedia: async () => [],
+  getStorageStats: async () => ({}),
+  cleanupOldCache: async () => ({
+    success: false,
+    filesRemoved: 0,
+    spaceFreedMB: 0,
+  }),
+  getFailedTransfers: async () => [],
+  retryFailedTransfers: async () => [],
+  playAudio: async () => undefined,
+  pauseAudio: async () => undefined,
+  resumeAudio: async () => undefined,
+  seekAudio: async () => undefined,
+  stopAudio: async () => undefined,
+  setLocalization: () => undefined,
+  // Audio Recording Features
+  startAudioRecording: async () => ({ filePath: '', mimeType: '' }),
+  stopAudioRecording: async () => ({
+    filePath: '',
+    durationMs: 0,
+    fileSizeBytes: 0,
+    mimeType: '',
+  }),
+  cancelAudioRecording: async () => ({ deleted: false }),
+  stopAndPublishAudioRecording: async () => ({
+    id: '',
+    uri: '',
+    documentUri: '',
+    type: 'audio',
+    fileName: '',
+    mimeType: '',
+    size: 0,
+    duration: 0,
+    dateTaken: 0,
+  }),
+  pauseAudioRecording: async () => undefined,
+  resumeAudioRecording: async () => undefined,
+  getAudioRecordingState: async () => ({
+    state: 'idle',
+    filePath: '',
+    durationMs: 0,
+    isPauseSupported: false,
+  }),
+  getAudioAmplitude: async () => 0,
+});
+
+export interface Spec extends TurboModule {
+  openCamera(): Promise<string>;
+  openCameraPicker(options: Object): Promise<Object>;
+  openDocumentPicker(options: Object): Promise<Object>;
+  openAudioPicker(options: Object): Promise<Object>;
+  /** Opens the system image/video picker via SAF (ACTION_OPEN_DOCUMENT). */
+  openImageVideoPicker(options: Object): Promise<Object>;
+  /**
+   * Opens an existing photo/video (e.g. one just picked from the gallery) on the camera's own
+   * preview/editor screen — the same screen, controller and tools a capture lands on. Resolves
+   * with the same `{ cancelled, assets }` shape as {@link openCameraPicker}.
+   */
+  openMediaEditor(options: Object): Promise<Object>;
+  /** Opens a document uri in an external viewer via ACTION_VIEW. Resolves true if launched. */
+  openDocument(uri: string, mimeType: string): Promise<boolean>;
+  startUpload(uris: string[], uploadUrl: string): Promise<void>;
+  getUploadState(): Promise<string>;
+  getNotificationHistory(): Promise<string>;
+  clearNotificationHistory(): Promise<void>;
+
+  /**
+   * Real device-memory facts (ActivityManager on Android): isLowRamDevice,
+   * memoryClassMb, totalRamMb, availableRamMb, isCurrentlyLowMemory, cpuCores.
+   */
+  getDeviceCapabilities(): Promise<Object>;
+
+  // Media Editing Features
+  cropImage(uri: string, options: Object): Promise<string>;
+  rotateImage(uri: string, degrees: number): Promise<string>;
+  applyFilter(uri: string, filterType: string): Promise<string>;
+
+  // Media Management Features
+  createAlbum(albumName: string): Promise<boolean>;
+  moveMediaToAlbum(uris: string[], albumId: string): Promise<boolean>;
+  /**
+   * Deletes media files. On Android each file's bytes are securely overwritten
+   * with encrypted cryptographically secure random data before the file is
+   * unlinked, and cached copies / derived variants are swept too.
+   *
+   * Resolves `true` when at least one file was removed. It CANNOT express
+   * whether the overwrite succeeded — use {@link secureDeleteMedia} when the
+   * security verdict matters (e.g. before telling a user the media is gone).
+   */
+  deleteMedia(uris: string[]): Promise<boolean>;
+  /**
+   * Securely deletes ONE media item and reports exactly what was achieved.
+   *
+   * The file's exact size is measured, it is overwritten with encrypted CSPRNG
+   * garbage 2 MiB longer than that size (chunked, so nothing is held in RAM at
+   * file scale), the write is flushed to storage, and only then is the file
+   * unlinked — after which thumbnails, cached copies, derived variants and
+   * native metadata references are removed.
+   *
+   * `options` accepts `{ assetId, fileName, coverUri }`. Passing `assetId` is
+   * strongly preferred: compressed/exported/edited variants and video cover
+   * frames are named after it, and without it those copies of the same media
+   * are not found.
+   *
+   * Resolves `{ deleted, securelyOverwritten, fullySecure, originalBytes,
+   * overwrittenBytes, derivedFilesErased, derivedFilesFailed, error? }`. Only
+   * `fullySecure` justifies reporting a secure deletion to the user.
+   */
+  secureDeleteMedia(uri: string, options: Object): Promise<Object>;
+  deleteStoredMedia(mediaId: string): Promise<boolean>;
+  /**
+   * Share one or more media uris through the native Android share sheet using
+   * Intent.ACTION_SEND (single item) or Intent.ACTION_SEND_MULTIPLE (multiple
+   * items), with the correct MIME type. `file://` paths are wrapped in a
+   * FileProvider content uri so no raw file path leaks to another process.
+   * Resolves `true` when the share chooser was launched, `false` otherwise.
+   */
+  shareMedia(uris: string[], mimeType: string): Promise<boolean>;
+
+  // Advanced Camera Features
+  setCameraFlash(mode: string): Promise<void>;
+  setCameraTimer(delaySeconds: number): Promise<void>;
+  enableCameraGrid(enabled: boolean): Promise<void>;
+
+  // Metadata Features
+  setMediaCaption(uri: string, caption: string): Promise<boolean>;
+  getMediaMetadata(uri: string): Promise<Object>;
+  /**
+   * The byte length of the exact clip the recording process finalized under `mediaId`, or 0 when
+   * none is remembered. Lets a preview quote the recorded size (matching the recording counter and
+   * the native editor's "Original" row) instead of the smaller background-cropped file on disk.
+   */
+  getRecordedOriginalSize(mediaId: string): Promise<number>;
+
+  // Video Features
+  trimVideo(uri: string, startTime: number, endTime: number): Promise<string>;
+  compressVideo(uri: string, qualityOrOption: string): Promise<string>;
+
+  // Image Features
+  compressImage(uri: string, qualityOrOption: string): Promise<string>;
+
+  // QR Code Features
+  scanQRCode(): Promise<string>;
+
+  // Face Detection Features
+  enableFaceDetection(enabled: boolean): Promise<void>;
+  setFaceEffect(effectType: string): Promise<void>;
+
+  // Theme Features
+  setCameraTheme(theme: string): Promise<void>;
+
+  /**
+   * Push the full serialized white-label config (theme + icons + animations +
+   * dimensions + notifications) to native. Stored in SharedPreferences and read
+   * by the camera Activity/editor on next launch.
+   */
+  setCameraConfig(configJson: string): Promise<void>;
+
+  // Media Storage Features
+  initializeMediaStorage(): Promise<Object>;
+  publishMedia(mediaId: string, moveMode: boolean): Promise<Object>;
+  publishBatch(mediaIds: string[], moveMode: boolean): Promise<Object>;
+  getCachedMedia(): Promise<Object[]>;
+  getPublishedMedia(): Promise<Object[]>;
+  getStorageStats(): Promise<Object>;
+  cleanupOldCache(olderThanDays: number): Promise<Object>;
+  getFailedTransfers(): Promise<Object[]>;
+  retryFailedTransfers(): Promise<Object[]>;
+
+  // Audio Player Features
+  playAudio(uri: string, title: string): Promise<void>;
+  pauseAudio(): Promise<void>;
+  resumeAudio(): Promise<void>;
+  seekAudio(positionMs: number): Promise<void>;
+  stopAudio(): Promise<void>;
+
+  // ── Audio Recording Features ─────────────────────────────────────────
+
+  /**
+   * Start recording audio via native MediaRecorder.
+   * Resolves with `{ filePath, mimeType }`.
+   *
+   * Options (all optional):
+   * - `outputFormat`: 'mpeg4' | 'aac_adts' | 'amr_nb' | 'amr_wb' | 'three_gpp'
+   * - `audioEncoder`: 'aac' | 'amr_nb' | 'amr_wb' | 'he_aac'
+   * - `audioSource`: 'mic' | 'camcorder' | 'voice_recognition' | 'voice_communication'
+   * - `bitRate`: number (default 128000)
+   * - `sampleRate`: number (default 44100)
+   * - `meteringIntervalMs`: number (0 = disabled; >0 fires `onAudioAmplitude` events)
+   */
+  startAudioRecording(options: Object): Promise<Object>;
+
+  /**
+   * Stop the active recording.
+   * Resolves with `{ filePath, durationMs, fileSizeBytes, mimeType }`.
+   */
+  stopAudioRecording(): Promise<Object>;
+
+  /**
+   * Cancel the active recording and delete the temporary file.
+   * Resolves with `{ deleted: boolean }`.
+   */
+  cancelAudioRecording(): Promise<Object>;
+
+  /**
+   * Stop the active recording, validate the file, move it to the Documents
+   * directory, and return the finalized audio asset.
+   *
+   * Resolves with an asset map: `{ id, uri, documentUri, type, fileName,
+   *   mimeType, size, duration, dateTaken }`.
+   */
+  stopAndPublishAudioRecording(): Promise<Object>;
+
+  /**
+   * Pause the current recording (requires API 24+).
+   */
+  pauseAudioRecording(): Promise<void>;
+
+  /**
+   * Resume a paused recording (requires API 24+).
+   */
+  resumeAudioRecording(): Promise<void>;
+
+  /**
+   * Get the current recording state.
+   * Resolves with `{ state, filePath, durationMs, isPauseSupported }`.
+   */
+  getAudioRecordingState(): Promise<Object>;
+
+  /**
+   * Get the current max amplitude from the active MediaRecorder.
+   * Returns an integer (0 = silence, higher = louder).
+   */
+  getAudioAmplitude(): Promise<number>;
+
+  // Localization bridge
+  /**
+   * Pushes the host app's strings, text direction and active language to the
+   * native camera. `locale` is a BCP-47 tag ('fr', 'zh-Hans', 'ar') or '' when
+   * the host has not set one, in which case native formatting uses the device
+   * locale. Prefer `setCameraLocalization` / `setCameraLanguage` over calling
+   * this directly.
+   */
+  setLocalization(translations: Object, isRtl: boolean, locale: string): void;
+}
+
+const nativeModule =
+  TurboModuleRegistry.get<Spec>('CustomCamera') ?? createStubModule();
+
+export default nativeModule;

package/src/NativeCustomCamera.web.ts

@@ -0,0 +1,192 @@
+function createUnsupportedPlatformError(): Error {
+  return new Error('react-native-ensys-camera-x is not supported on web');
+}
+
+function rejectUnsupported<T>(): Promise<T> {
+  return Promise.reject(createUnsupportedPlatformError());
+}
+
+const CustomCamera = {
+  openCamera(): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  openCameraPicker(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  openDocumentPicker(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  openAudioPicker(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  openImageVideoPicker(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  openMediaEditor(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  openDocument(_uri: string, _mimeType: string): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  startUpload(_uris: string[], _uploadUrl: string): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  getUploadState(): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  getNotificationHistory(): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  clearNotificationHistory(): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  getDeviceCapabilities(): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  cropImage(_uri: string, _options: Object): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  rotateImage(_uri: string, _degrees: number): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  applyFilter(_uri: string, _filterType: string): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  createAlbum(_albumName: string): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  moveMediaToAlbum(_uris: string[], _albumId: string): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  deleteMedia(_uris: string[]): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  secureDeleteMedia(_uri: string, _options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  shareMedia(_uris: string[], _mimeType: string): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  setCameraFlash(_mode: string): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setCameraTimer(_delaySeconds: number): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  enableCameraGrid(_enabled: boolean): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setMediaCaption(_uri: string, _caption: string): Promise<boolean> {
+    return rejectUnsupported();
+  },
+
+  getMediaMetadata(_uri: string): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  getRecordedOriginalSize(_mediaId: string): Promise<number> {
+    return rejectUnsupported();
+  },
+
+  trimVideo(
+    _uri: string,
+    _startTime: number,
+    _endTime: number
+  ): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  compressVideo(
+    uri: string,
+    _qualityOrOption: string
+  ): Promise<string> {
+    // For web fallback, return the original URI without modification
+    return Promise.resolve(uri);
+  },
+
+  compressImage(uri: string, _qualityOrOption: string): Promise<string> {
+    // Same web fallback as compressVideo: hand the original URI back unmodified rather than
+    // rejecting, so a caller that only wants a smaller copy still gets a usable one.
+    return Promise.resolve(uri);
+  },
+
+  scanQRCode(): Promise<string> {
+    return rejectUnsupported();
+  },
+
+  enableFaceDetection(_enabled: boolean): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setFaceEffect(_effectType: string): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setCameraTheme(_theme: string): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setCameraConfig(_configJson: string): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  setLocalization(_translations: Object, _isRtl: boolean, _locale: string): void {},
+
+  // Audio Recording Features (unsupported on web)
+  startAudioRecording(_options: Object): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  stopAudioRecording(): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  cancelAudioRecording(): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  stopAndPublishAudioRecording(): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  pauseAudioRecording(): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  resumeAudioRecording(): Promise<void> {
+    return rejectUnsupported();
+  },
+
+  getAudioRecordingState(): Promise<Object> {
+    return rejectUnsupported();
+  },
+
+  getAudioAmplitude(): Promise<number> {
+    return rejectUnsupported();
+  },
+};
+
+export default CustomCamera;

package/src/NativeCustomVideoView.ts

@@ -0,0 +1,30 @@
+import { type NativeSyntheticEvent, requireNativeComponent, type ViewProps } from 'react-native';
+
+export interface VideoPlaybackProgressEventData {
+  currentTimeMs: number;
+  durationMs: number;
+  isPlaying: boolean;
+}
+
+export interface VideoPlaybackProgressEvent extends NativeSyntheticEvent<VideoPlaybackProgressEventData> {}
+
+export interface NativeCustomVideoViewProps extends ViewProps {
+  src?: string;
+  paused?: boolean;
+  /**
+   * Whether this view is the currently-visible page in a paging viewer. When a paging host
+   * (e.g. the full-screen preview viewer) sets this per cell, only the active clip keeps a
+   * live player: deactivating releases the decoder and resets to 00:00, so returning replays
+   * from the start rather than resuming, and at most one video plays at a time.
+   *
+   * Optional — defaults to true natively, so a single-video consumer that never sets it
+   * behaves exactly as before (driven purely by `paused`).
+   */
+  active?: boolean;
+  /** Called when the native player advances or pauses at a position. */
+  onPlaybackProgress?: (event: VideoPlaybackProgressEvent) => void;
+  /** Called once the video reaches the end of playback. */
+  onPlaybackEnded?: (event: NativeSyntheticEvent<{ durationMs: number }>) => void;
+}
+
+export const NativeCustomVideoView = requireNativeComponent<NativeCustomVideoViewProps>('NativeCustomVideoView');