@technotoil/image-video-editor 0.1.0

package/src/native/CameraView.tsx

@@ -0,0 +1,95 @@
+import React, { forwardRef, useImperativeHandle, useRef, useState } from 'react';
+import { requireNativeComponent, ViewStyle } from 'react-native';
+
+type NativeProps = {
+  facing: 'front' | 'back';
+  flashMode?: 'on' | 'off';
+  style?: ViewStyle;
+  photoTrigger?: string;
+  recordTrigger?: string;
+  onPhotoCaptured?: (event: any) => void;
+  onRecordStarted?: (event: any) => void;
+  onRecordStopped?: (event: any) => void;
+};
+
+const NativeCameraView = requireNativeComponent<NativeProps>('RNCameraView');
+
+export interface CameraViewRef {
+  capturePhoto(): Promise<{ uri: string; width: number; height: number }>;
+  startRecording(): Promise<void>;
+  stopRecording(): Promise<{ uri: string; durationMs: number; width: number; height: number }>;
+}
+
+interface Props {
+  facing: 'front' | 'back';
+  flashMode?: 'on' | 'off';
+  style?: ViewStyle;
+}
+
+export const CameraView = forwardRef<CameraViewRef, Props>(({ facing, flashMode = 'off', style }, ref) => {
+  const [photoTrigger, setPhotoTrigger] = useState<string>('');
+  const [recordTrigger, setRecordTrigger] = useState<'start' | 'stop' | 'idle'>('idle');
+  
+  const photoPromiseRef = useRef<{ resolve: Function; reject: Function } | null>(null);
+  const recordStartPromiseRef = useRef<{ resolve: Function; reject: Function } | null>(null);
+  const recordStopPromiseRef = useRef<{ resolve: Function; reject: Function } | null>(null);
+
+  useImperativeHandle(ref, () => ({
+    capturePhoto: () => {
+      return new Promise((resolve, reject) => {
+        photoPromiseRef.current = { resolve, reject };
+        setPhotoTrigger(Date.now().toString());
+      });
+    },
+    startRecording: () => {
+      return new Promise((resolve, reject) => {
+        recordStartPromiseRef.current = { resolve, reject };
+        setRecordTrigger('start');
+      });
+    },
+    stopRecording: () => {
+      return new Promise((resolve, reject) => {
+        recordStopPromiseRef.current = { resolve, reject };
+        setRecordTrigger('stop');
+      });
+    },
+  }));
+
+  return (
+    <NativeCameraView
+      facing={facing}
+      flashMode={flashMode}
+      style={style}
+      photoTrigger={photoTrigger}
+      recordTrigger={recordTrigger}
+      onPhotoCaptured={(e: any) => {
+        const { uri, width, height, error } = e.nativeEvent;
+        if (error) {
+          photoPromiseRef.current?.reject(new Error(error));
+        } else {
+          photoPromiseRef.current?.resolve({ uri, width, height });
+        }
+        photoPromiseRef.current = null;
+      }}
+      onRecordStarted={(e: any) => {
+        const { error } = e.nativeEvent;
+        if (error) {
+          recordStartPromiseRef.current?.reject(new Error(error));
+        } else {
+          recordStartPromiseRef.current?.resolve();
+        }
+        recordStartPromiseRef.current = null;
+      }}
+      onRecordStopped={(e: any) => {
+        const { uri, durationMs, width, height, error } = e.nativeEvent;
+        if (error) {
+          recordStopPromiseRef.current?.reject(new Error(error));
+        } else {
+          recordStopPromiseRef.current?.resolve({ uri, durationMs, width, height });
+        }
+        recordStopPromiseRef.current = null;
+        setRecordTrigger('idle');
+      }}
+    />
+  );
+});

package/src/native/FrameGrabber.ts

@@ -0,0 +1,21 @@
+import { NativeModules, Platform } from 'react-native';
+import type { FrameCaptureOptions } from '../types';
+
+const { RNFrameGrabber } = NativeModules as {
+  RNFrameGrabber?: {
+    captureFrame: (uri: string, options: FrameCaptureOptions) => Promise<string>;
+  };
+};
+
+export async function captureFrame(
+  uri: string,
+  options: FrameCaptureOptions
+): Promise<string> {
+  if (!RNFrameGrabber?.captureFrame) {
+    throw new Error(
+      `RNFrameGrabber.captureFrame is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNFrameGrabber.captureFrame(uri, options);
+}
+

package/src/native/MediaEditor.ts

@@ -0,0 +1,33 @@
+import { NativeModules, Platform } from 'react-native';
+import type { ImageEditOptions, VideoTrimOptions } from '../types';
+
+const { RNMediaEditor } = NativeModules as {
+  RNMediaEditor?: {
+    editImage: (uri: string, options: ImageEditOptions) => Promise<string>;
+    trimVideo: (uri: string, options: VideoTrimOptions) => Promise<string>;
+  };
+};
+
+export async function editImage(
+  uri: string,
+  options: ImageEditOptions
+): Promise<string> {
+  if (!RNMediaEditor?.editImage) {
+    throw new Error(
+      `RNMediaEditor.editImage is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaEditor.editImage(uri, options);
+}
+
+export async function trimVideo(
+  uri: string,
+  options: VideoTrimOptions
+): Promise<string> {
+  if (!RNMediaEditor?.trimVideo) {
+    throw new Error(
+      `RNMediaEditor.trimVideo is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaEditor.trimVideo(uri, options);
+}

package/src/native/MediaLibrary.ts

@@ -0,0 +1,69 @@
+import { NativeModules, Platform } from 'react-native';
+import type { MediaItem, MediaType } from '../types';
+
+export type Album = {
+  id: string;
+  title: string;
+};
+
+export type MediaQuery = {
+  limit?: number;
+  offset?: number;
+  type?: MediaType | 'all';
+  albumId?: string;
+};
+
+const { RNMediaLibrary } = NativeModules as {
+  RNMediaLibrary?: {
+    requestAccess: () => Promise<boolean>;
+    listAlbums: () => Promise<Album[]>;
+    listMedia: (query: MediaQuery) => Promise<MediaItem[]>;
+    exportAsset: (localId: string) => Promise<string>;
+    saveToGallery: (uri: string, type: string) => Promise<boolean>;
+  };
+};
+
+export async function requestMediaAccess(): Promise<boolean> {
+  if (!RNMediaLibrary?.requestAccess) {
+    throw new Error(
+      `RNMediaLibrary is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaLibrary.requestAccess();
+}
+
+export async function listAlbums(): Promise<Album[]> {
+  if (!RNMediaLibrary?.listAlbums) {
+    throw new Error(
+      `RNMediaLibrary.listAlbums is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaLibrary.listAlbums();
+}
+
+export async function listMedia(query: MediaQuery): Promise<MediaItem[]> {
+  if (!RNMediaLibrary?.listMedia) {
+    throw new Error(
+      `RNMediaLibrary.listMedia is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaLibrary.listMedia(query);
+}
+
+export async function exportAsset(localId: string): Promise<string> {
+  if (!RNMediaLibrary?.exportAsset) {
+    throw new Error(
+      `RNMediaLibrary.exportAsset is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaLibrary.exportAsset(localId);
+}
+
+export async function saveToGallery(uri: string, type: string): Promise<boolean> {
+  if (!RNMediaLibrary?.saveToGallery) {
+    throw new Error(
+      `RNMediaLibrary.saveToGallery is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaLibrary.saveToGallery(uri, type);
+}

package/src/native/MediaPicker.ts

@@ -0,0 +1,17 @@
+import { NativeModules, Platform } from 'react-native';
+import type { MediaItem } from '../types';
+
+const { RNMediaPicker } = NativeModules as {
+  RNMediaPicker?: {
+    pickMedia: () => Promise<MediaItem[]>;
+  };
+};
+
+export async function pickMedia(): Promise<MediaItem[]> {
+  if (!RNMediaPicker?.pickMedia) {
+    throw new Error(
+      `RNMediaPicker is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaPicker.pickMedia();
+}

package/src/native/MediaPlayer.ts

@@ -0,0 +1,16 @@
+import { NativeModules, Platform } from 'react-native';
+
+const { RNMediaPlayer } = NativeModules as {
+  RNMediaPlayer?: {
+    playVideo: (uri: string) => Promise<boolean>;
+  };
+};
+
+export async function playVideo(uri: string): Promise<boolean> {
+  if (!RNMediaPlayer?.playVideo) {
+    throw new Error(
+      `RNMediaPlayer is not available on ${Platform.OS}. Make sure the native module is linked.`
+    );
+  }
+  return RNMediaPlayer.playVideo(uri);
+}

package/src/native/VideoPreview.tsx

@@ -0,0 +1,20 @@
+import React from 'react';
+import { requireNativeComponent, ViewStyle, StyleProp } from 'react-native';
+
+type Props = {
+  uri: string;
+  paused?: boolean;
+  muted?: boolean;
+  style?: StyleProp<ViewStyle>;
+  resizeMode?: string;
+  trimStartMs?: number;
+  trimEndMs?: number;
+  seekToMs?: number;
+  onChange?: (e: { nativeEvent: { currentTimeMs: number } }) => void;
+};
+
+const NativeVideoPreview = requireNativeComponent<Props>('RNVideoPreview');
+
+export function VideoPreview(props: Props) {
+  return <NativeVideoPreview {...props} />;
+}