react-native-photo-video-editor 0.1.0

package/CHANGELOG.md

@@ -0,0 +1,27 @@
+# Changelog
+
+## Unreleased
+
+- Adopt the "Studio Violet" design system exported from Stitch (`stitch_react_native_photo_editor_sdk/`) for the photo editor shell and every existing tool: new color/spacing/radius tokens (`DesignTokens.kt`/`DesignTokens.swift`), a real Material Symbols icon set (46 icons fetched from source SVGs and converted to Android vector drawables; SF Symbols on iOS), an icon-tile main tool rail (expanded to the full 16-tool set from the mockup: Crop/Adjust/Filters/Effects/Blur/Text/Stickers/Shapes/Draw/Frames/Overlays/Background/Retouch/Remove/Layers/Resize), a circular-close/pill-Export header, Rotate/Flip moved into the Crop sub-bar, Adjust and Filters split into separate tools (previously combined), real per-preset thumbnail cards for Filters, a card grid for Stickers/Shapes, color-swatch controls for Draw, icon actions for the Layer property bar, and Color/Size properties for text layers. Android is Gradle-verified end to end (`compileDebugKotlin`, `assembleDebug` for the library and example app); iOS mirrors the header, tool rail, and Crop sub-bar but is unbuilt (no macOS/Xcode here) — the remaining tool sub-bars (Filters cards, Stickers/Shapes grid, Draw, Layers, Text) are visually unchanged on iOS for now. Toolbar entries with no mockup-independent functionality yet (Effects, Frames, Overlays, Background, Retouch) still show "coming in a later milestone".
+- Add two new photo tools shown in the mockups but not previously implemented: **Blur & Depth** (synthetic Radial/Linear tilt-shift blur via `RadialGradient`/`LinearGradient` + `PorterDuff.DST_IN` alpha-mask compositing — no ML/device depth sensing, since that's unverifiable without a device, so the mockup's ML-driven "Portrait" mode is intentionally out of scope) and **Canvas Resize & Social Presets** (IG Post/Story/Square, YouTube, Twitter presets, reusing the existing crop-aspect-ratio mechanism plus an exact export pixel-size override). Both are Android-only so far, Gradle-verified, wired into both preview and export. AI Object Removal / Magic Eraser was explicitly excluded from this pass per instruction.
+- Add focused photo/video editor APIs, native full-screen preview shells, feature-aware toolbars, typed editor events, and the versioned project model foundation.
+- Expand the example into separate pick and launch actions.
+- Apply `theme` (background/toolbar/text/primary colors, status bar style) in the Android and iOS native editor shells; previously accepted but ignored.
+- Fix an Android Kotlin build failure in the toolbar layout (`orientation = HORIZONTAL` did not resolve; now `LinearLayout.HORIZONTAL`).
+- Fix the Android header and toolbar rendering underneath the status/gesture bars on targetSdk 35+ (enforced edge-to-edge draws the window behind system bars by default). The header/toolbar now consume `WindowInsetsCompat` system bar insets and grow by that amount instead of being obscured.
+- Add real photo editing (Milestone 2): freeform + aspect-ratio-preset crop, 90° rotate, horizontal/vertical flip, fine straighten, pan/pinch-to-zoom preview, and JPEG/PNG/WebP export with EXIF orientation handling and optional metadata preservation. `EditorResult` now returns real `width`/`height`/`fileSize`/`mimeType` for photo edits. Filters/Text/Stickers/Draw remain stubs (Milestone 3/4) but now show a "coming in a later milestone" message instead of doing nothing.
+- Add photo adjustments and filters (Milestone 3): Brightness, Contrast, Saturation, Exposure, Gamma, Temperature, Tint, Highlights, Shadows, Sharpen, Blur, Pixelate, Mirror, and five original preset filters (Mono, Noir, Fade, Chrome, Warmth) with an adjustable blend strength. Applied identically in preview and export on both platforms via matching hand-implemented formulas (no CoreImage/RenderScript dependency). Text/Stickers/Draw remain stubs (Milestone 4).
+- Add photo layers (Milestone 4): text, stickers (8 built-in + consumer `stickerAssets`), shapes (rect/oval/line), and freehand drawing, with tap-to-select, drag-to-move, and Scale/Rotate/Opacity sliders per layer. Duplicate/Lock/Hide/Front/Back/Delete actions, plus header Undo/Redo backed by a 50-entry snapshot history (one entry per committed operation, never per drag frame). Layers are burned in identically at preview and export resolution. Added `EditorOptions.stickerAssets` and `EditorOptions.fonts` to the public TypeScript API; `fonts` is accepted and forwarded but not yet wired to load custom font files (documented gap, see `docs/photo-editor.md`).
+- Fix Android tool sub-bars (crop/filters/stickers/draw/layers/video-aspect) rendering under the gesture nav bar when first shown. Only the main toolbar had edge-to-edge bottom-inset handling; every sub-bar that can replace it at the bottom of the screen now gets the same treatment, applied up front to all of them (Android dispatches insets regardless of visibility, so whichever bar becomes visible when a tool is selected is already correctly padded).
+- Add real video editing (Milestone 5): custom player with play/pause/scrub, a dual-handle trim range bar backed by a background-generated thumbnail strip, mute, cover-frame timestamp selection, 90° rotate, horizontal flip, and H.264/AAC MP4 export via Media3 `Transformer` (Android) / `AVAssetExportSession` (iOS), with an in-editor progress spinner and cancel button that deletes the partial output file. `EditorResult` now returns real `width`/`height`/`duration`/`fileSize`/`mimeType` for video exports too. Added the `androidx.media3` dependency family (exoplayer/ui/transformer/effect/common, resolved live over the network). Aspect-ratio crop is Android-only for now — deliberately not shipped on iOS, where the transform math to combine it correctly with rotation was not verifiable without a device.
+- Add selected-state highlighting for every mode toolbar button (Crop/Filters/Stickers/Draw on photo, Crop/Mute on video) and every chip in a tool's sub-bar (aspect presets, filter adjustment/preset chips, layer property chips) so the active one is visible at a glance, using `primaryColor` text on a low-alpha `primaryColor` background.
+- Add playback speed control (Milestone 6, in progress): cycles 0.5x/1x/1.5x/2x on the preview player (`ExoPlayer.setPlaybackSpeed` / `AVPlayer.rate`). Export does not yet honor the selected speed — a deliberate, documented scope cut (see `docs/video-editor.md`) rather than an oversight, since getting Media3/AVFoundation speed-change-at-export math right was not verifiable without a device.
+- Add timed text/sticker/shape overlays on video (Milestone 6): reuses the exact `PhotoLayer`/`PhotoLayerStack`/`PhotoLayerRenderer` machinery from photo layers rather than a parallel system (added `startMs`/`endMs` + `isActiveAt`/`isActive(atMs:)` to `PhotoLayer`). Preview composites active overlays over the player on the existing position-poll tick; export burns them in via Media3 `OverlayEffect`/`BitmapOverlay` (Android) or `AVVideoCompositionCoreAnimationTool` (iOS). Header Undo/Redo now works for video too. Scoped to full-duration overlays only for this pass — no per-overlay time-range trim UI or drag/scale/rotate/delete yet (the largest remaining Milestone 6 item), which let the export side flatten every overlay into one static composited image instead of a genuinely time-varying one.
+- Add video-level Brightness/Contrast/Saturation filters (Milestone 6, Android only, export-only — no live preview): applied via `androidx.media3.effect.Brightness`/`Contrast`/`HslAdjustment`, verified to exist in the pinned Media3 1.4.1 by inspecting the actual library bytecode (`javap`) before writing any code, rather than guessing. iOS is scoped out — per-frame CIFilter application needs a different AVFoundation composition pathway (`AVMutableVideoComposition(asset:applyingCIFiltersWithHandler:)`) that conflicts with the manual layer-instruction composition already used for rotate/flip/crop; combining them would need a custom `AVVideoCompositing` implementation.
+- An attempt to also apply `speed` at export (via `SpeedProvider`/`TimestampAdjustment`) found that API isn't in Media3 1.4.1; bumping to 1.9.4 to get it broke three other already-verified call sites, so the bump was reverted and `speed` stays preview-only, documented in `docs/video-editor.md`.
+- Add video overlay selection, transform, and time-range editing (Milestone 6, closing the last gap): tap an overlay on the video preview to select it, reusing the exact `LayerOverlayView` built for photo layers. A mini toolbar offers Scale/Rotate/Opacity (shared slider) plus Start/End chips to scrub the overlay's time range, and Delete. Android export now genuinely respects per-overlay time ranges via a `BitmapOverlay.getBitmap(presentationTimeUs:)` callback that recomputes and caches the active layer set per timestamp (previously every overlay was flattened into one static full-duration image); iOS gets the same editing UI but its export still burns overlays in for the whole clip regardless of range — documented as the one remaining Milestone 6 gap, since fixing it needs a custom `AVVideoCompositing` implementation.
+- Add a multi-clip timeline (Milestone 7, partial — audio tracks and transitions deliberately deferred per the master spec's own sequencing advice): the single implicit video is replaced by an ordered `VideoClip` list (id/source/trim), with a clip-strip UI (Split at the playhead/Duplicate/Delete/Move-Left/Move-Right) and the trim range view now bound to whichever clip is selected instead of the whole video. Android plays a genuine multi-item ExoPlayer playlist and adds `VideoEditSession.globalPositionMs()`/`seekToGlobalMs()` to bridge the composed timeline and the player's own per-item position; export concatenates every clip into one `EditedMediaItemSequence`/`Composition`, verified against the actual Media3 1.4.1 bytecode (`javap`) before writing the code. iOS takes an architecturally simpler route — both preview and export concatenate every clip into a single `AVMutableComposition` via native multi-segment `insertTimeRange(_:of:at:)`, so `player.currentTime()`/`.seek(to:)` already are the composed-timeline position with no separate global-position bookkeeping needed, unlike Android's playlist approach. Gradle-verified on Android (`compileDebugKotlin`, `assembleDebug` for both the library and example app); iOS reviewed but not locally built (no macOS/Xcode here). Every clip in this pass still shares one source file — importing separate additional source files is a follow-up. See `docs/video-editor.md` for the full gap list.
+
+## 0.1.0
+
+- Initial Turbo Module foundation and typed placeholder contract.

package/CONTRIBUTING.md

@@ -0,0 +1,101 @@
+# Contributing
+
+Contributions are always welcome, no matter how large or small!
+
+We want this community to be friendly and respectful to each other. Please follow it in all your interactions with the project. Before contributing, please read the [code of conduct](./CODE_OF_CONDUCT.md).
+
+## Development workflow
+
+This project is a monorepo managed using [Yarn workspaces](https://yarnpkg.com/features/workspaces). It contains the following packages:
+
+- The library package in the root directory.
+- An example app in the `example/` directory.
+
+To get started with the project, make sure you have the correct version of [Node.js](https://nodejs.org/) installed. See the [`.nvmrc`](./.nvmrc) file for the version used in this project.
+
+Run `yarn` in the root directory to install the required dependencies for each package:
+
+```sh
+yarn
+```
+
+> Since the project relies on Yarn workspaces, you cannot use [`npm`](https://github.com/npm/cli) for development without manually migrating.
+
+The [example app](/example/) demonstrates usage of the library. You need to run it to test any changes you make.
+
+It is configured to use the local version of the library, so any changes you make to the library's source code will be reflected in the example app. Changes to the library's JavaScript code will be reflected in the example app without a rebuild, but native code changes will require a rebuild of the example app.
+
+If you want to use Android Studio or Xcode to edit the native code, you can open the `example/android` or `example/ios` directories respectively in those editors. To edit the Objective-C or Swift files, open `example/ios/PhotoVideoEditorExample.xcworkspace` in Xcode and find the source files at `Pods > Development Pods > react-native-photo-video-editor`.
+
+To edit the Java or Kotlin files, open `example/android` in Android studio and find the source files at `react-native-photo-video-editor` under `Android`.
+
+You can use various commands from the root directory to work with the project.
+
+To start the packager:
+
+```sh
+yarn example start
+```
+
+To run the example app on Android:
+
+```sh
+yarn example android
+```
+
+To run the example app on iOS:
+
+```sh
+yarn example ios
+```
+
+To confirm that the app is running with the new architecture, you can check the Metro logs for a message like this:
+
+```sh
+Running "PhotoVideoEditorExample" with {"fabric":true,"initialProps":{"concurrentRoot":true},"rootTag":1}
+```
+
+Note the `"fabric":true` and `"concurrentRoot":true` properties.
+
+Make sure your code passes TypeScript:
+
+```sh
+yarn typecheck
+```
+
+To check for linting errors, run the following:
+
+```sh
+yarn lint
+```
+
+To fix formatting errors, run the following:
+
+```sh
+yarn lint --fix
+```
+
+
+
+### Scripts
+
+The `package.json` file contains various scripts for common tasks:
+
+- `yarn`: setup project by installing dependencies.
+- `yarn typecheck`: type-check files with TypeScript.
+  - `yarn lint`: lint files with [ESLint](https://eslint.org/).
+    - `yarn example start`: start the Metro server for the example app.
+- `yarn example android`: run the example app on Android.
+- `yarn example ios`: run the example app on iOS.
+  
+### Sending a pull request
+
+> **Working on your first pull request?** You can learn how from this _free_ series: [How to Contribute to an Open Source Project on GitHub](https://app.egghead.io/playlists/how-to-contribute-to-an-open-source-project-on-github).
+
+When you're sending a pull request:
+
+- Prefer small pull requests focused on one change.
+- Verify that linters and tests are passing.
+- Review the documentation to make sure it looks good.
+- Follow the pull request template when opening a pull request.
+- For pull requests that change the API or implementation, discuss with maintainers first by opening an issue.

package/LICENSE

@@ -0,0 +1,20 @@
+MIT License
+
+Copyright (c) 2026 AUTHOR_NAME_PLACEHOLDER
+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/PhotoVideoEditor.podspec

@@ -0,0 +1,23 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "PhotoVideoEditor"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => min_ios_version_supported }
+  s.source       = { :git => "https://github.com/Babur171/react-native-photo-video-editor.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift,cpp}"
+  s.private_header_files = "ios/**/*.h"
+  # ios/Tests holds XCTest-based unit tests, not library sources — XCTest isn't linked into
+  # consumer app targets, so these must never ship as part of the pod's normal build.
+  s.exclude_files = "ios/Tests/**/*"
+
+  install_modules_dependencies(s)
+end

package/README.md

@@ -0,0 +1,53 @@
+# react-native-photo-video-editor
+
+> Early development: Milestone 6 is complete on Android and nearly complete on iOS, and Milestone 7's multi-clip timeline slice (clip list, split/duplicate/delete/reorder, gapless multi-clip export) is now complete on both platforms — audio tracks and transitions are deliberately deferred to a later slice. Android is compile-verified via Gradle throughout, including live-resolved Media3 dependencies, a time-aware `OverlayEffect` export path, the `Brightness`/`Contrast`/`HslAdjustment` filter export path, and multi-clip export via `EditedMediaItemSequence`/`Composition` (all verified against actual library bytecode, not guessed); iOS implements the same editing UI via AVFoundation but is unbuilt (no macOS toolchain here), uses a simpler `AVMutableComposition`-based approach for multi-clip preview/export, and its overlay export still burns overlays in for the whole clip regardless of their configured time range — the one remaining Milestone 6 gap, needing a custom `AVVideoCompositing` implementation to fix. Video aspect-ratio crop, video-level filters, and export-time speed change are Android-only/not-yet-implemented, each a documented, deliberate scope cut rather than an oversight.
+
+A React Native Android/iOS Turbo Module with focused `openPhotoEditor`, `openVideoEditor`, and unified `openEditor` APIs. The full-screen native shell previews local media, honors feature visibility and theme, edits photos on-device (crop/rotate/straighten, adjustments/filters, and text layers) and video on-device (trim/rotate/speed/text/filters/export), and returns a typed result with real output metadata on Done or a typed cancellation result on Cancel. See [docs/photo-editor.md](docs/photo-editor.md) and [docs/video-editor.md](docs/video-editor.md) for details.
+
+## Requirements and installation
+
+React Native 0.85-compatible New Architecture applications are the verified target of this scaffold. React and React Native are peer dependencies. Autolinking handles native registration.
+
+```sh
+npm install react-native-photo-video-editor
+# or: yarn add react-native-photo-video-editor
+# or: pnpm add react-native-photo-video-editor
+cd ios && pod install
+```
+
+No permissions are required by the placeholder. Future gallery saving will require consumer-app Photos/media usage descriptions or permissions; the library will not add broad storage permissions.
+
+## Usage
+
+```ts
+import {
+  openVideoEditor,
+  cancelExport,
+  addExportProgressListener,
+  PhotoVideoEditorError,
+} from 'react-native-photo-video-editor';
+
+const subscription = addExportProgressListener((event) => {
+  console.log(event.jobId, event.progress); // progress: 0..1
+});
+
+try {
+  const result = await openVideoEditor({
+    source: { uri: 'file:///path/to/video.mp4', type: 'video' },
+    features: { crop: true, rotate: true, trim: true },
+    export: { quality: 'high', videoFormat: 'mp4', frameRate: 30 },
+    saveToGallery: false,
+  });
+  console.log(result.uri, result.cancelled);
+  await cancelExport();
+} catch (error) {
+  if (error instanceof PhotoVideoEditorError)
+    console.error(error.code, error.message);
+} finally {
+  subscription.remove();
+}
+```
+
+See [API](docs/api.md), [architecture](docs/architecture.md), [photo editor](docs/photo-editor.md), [video editor](docs/video-editor.md), and [roadmap](docs/roadmap.md). Known limitations are non-functional tool placeholders, no transformed export, local-URI-only input, and no verified legacy-architecture support.
+
+For local work, run `yarn`, then `yarn typecheck`, `yarn lint`, `yarn test`, and `yarn prepare`. See [CONTRIBUTING.md](CONTRIBUTING.md). MIT licensed; see [LICENSE](LICENSE).

package/android/build.gradle

@@ -0,0 +1,61 @@
+buildscript {
+  ext.PhotoVideoEditor = [
+    kotlinVersion: "2.0.21",
+    minSdkVersion: 24,
+    compileSdkVersion: 36
+  ]
+
+  ext.getExtOrDefault = { prop ->
+    if (rootProject.ext.has(prop)) {
+      return rootProject.ext.get(prop)
+    }
+
+    return PhotoVideoEditor[prop]
+  }
+
+  repositories {
+    google()
+    mavenCentral()
+  }
+
+  dependencies {
+    classpath "com.android.tools.build:gradle:8.7.2"
+    // noinspection DifferentKotlinGradleVersion
+    classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${getExtOrDefault('kotlinVersion')}"
+  }
+}
+
+
+apply plugin: "com.android.library"
+apply plugin: "kotlin-android"
+
+apply plugin: "com.facebook.react"
+
+android {
+  namespace "com.photovideoeditor"
+
+  compileSdkVersion getExtOrDefault("compileSdkVersion")
+
+  defaultConfig {
+    minSdkVersion getExtOrDefault("minSdkVersion")
+  }
+
+  compileOptions {
+    sourceCompatibility JavaVersion.VERSION_17
+    targetCompatibility JavaVersion.VERSION_17
+  }
+}
+
+dependencies {
+  implementation "com.facebook.react:react-android"
+  implementation "androidx.exifinterface:exifinterface:1.3.7"
+  // Grid layout for the online-stickers browse sheet (Stickers > Browse online).
+  implementation "androidx.recyclerview:recyclerview:1.3.2"
+  // Keep the editor on the same Media3 ABI used by react-native-video.
+  implementation "androidx.media3:media3-exoplayer:1.8.0"
+  implementation "androidx.media3:media3-ui:1.8.0"
+  implementation "androidx.media3:media3-transformer:1.8.0"
+  implementation "androidx.media3:media3-effect:1.8.0"
+  implementation "androidx.media3:media3-common:1.8.0"
+  testImplementation "junit:junit:4.13.2"
+}

package/android/src/main/AndroidManifest.xml

@@ -0,0 +1,12 @@
+<manifest xmlns:android="http://schemas.android.com/apk/res/android">
+  <uses-permission android:name="android.permission.INTERNET" />
+
+  <application>
+    <activity
+      android:name=".editor.PhotoVideoEditorActivity"
+      android:configChanges="keyboard|keyboardHidden|orientation|screenSize|uiMode"
+      android:exported="false"
+      android:screenOrientation="portrait"
+      android:theme="@style/PhotoVideoEditorTheme" />
+  </application>
+</manifest>

package/android/src/main/java/com/photovideoeditor/PhotoVideoEditorModule.kt

@@ -0,0 +1,126 @@
+package com.photovideoeditor
+
+import android.app.Activity
+import android.content.Intent
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.bridge.Promise
+import com.facebook.react.bridge.BaseActivityEventListener
+import com.photovideoeditor.editor.PhotoVideoEditorActivity
+import com.photovideoeditor.model.EditorRequest
+import com.photovideoeditor.validation.EditorRequestValidator
+import org.json.JSONObject
+
+class PhotoVideoEditorModule(reactContext: ReactApplicationContext) :
+  NativePhotoVideoEditorSpec(reactContext) {
+
+  private var editorPromise: Promise? = null
+  private var pendingUri: String? = null
+  private var pendingType: String? = null
+  private var pendingMimeType: String? = null
+
+  private val activityEventListener = object : BaseActivityEventListener() {
+    override fun onActivityResult(activity: Activity, requestCode: Int, resultCode: Int, data: Intent?) {
+      if (requestCode != EDITOR_REQUEST_CODE) return
+      val promise = editorPromise ?: return
+      editorPromise = null
+
+      if (resultCode == PhotoVideoEditorActivity.RESULT_ERROR) {
+        val code = data?.getStringExtra(PhotoVideoEditorActivity.EXTRA_ERROR_CODE) ?: "E_INTERNAL"
+        promise.reject(code, data?.getStringExtra(PhotoVideoEditorActivity.EXTRA_ERROR) ?: "The editor could not open the selected media.")
+        pendingUri = null
+        pendingType = null
+        pendingMimeType = null
+        return
+      }
+
+      val cancelled = resultCode != Activity.RESULT_OK
+      val result = JSONObject()
+        .put("uri", data?.getStringExtra(PhotoVideoEditorActivity.EXTRA_URI) ?: pendingUri.orEmpty())
+        .put("type", data?.getStringExtra(PhotoVideoEditorActivity.EXTRA_TYPE) ?: pendingType.orEmpty())
+        .put("cancelled", cancelled)
+      if (!cancelled) {
+        val exportedMimeType = data?.getStringExtra(PhotoVideoEditorActivity.EXTRA_MIME_TYPE) ?: pendingMimeType
+        exportedMimeType?.let { result.put("mimeType", it) }
+        if (data?.hasExtra(PhotoVideoEditorActivity.EXTRA_WIDTH) == true) {
+          result.put("width", data.getIntExtra(PhotoVideoEditorActivity.EXTRA_WIDTH, 0))
+          result.put("height", data.getIntExtra(PhotoVideoEditorActivity.EXTRA_HEIGHT, 0))
+          result.put("fileSize", data.getLongExtra(PhotoVideoEditorActivity.EXTRA_FILE_SIZE, 0L))
+        }
+        if (data?.hasExtra(PhotoVideoEditorActivity.EXTRA_DURATION) == true) {
+          result.put("duration", data.getLongExtra(PhotoVideoEditorActivity.EXTRA_DURATION, 0L))
+        }
+      }
+      pendingUri = null
+      pendingType = null
+      pendingMimeType = null
+      emitOnEditorEvent(JSONObject().put("type", "editorClosed").toString())
+      promise.resolve(result.toString())
+    }
+  }
+
+  init {
+    reactContext.addActivityEventListener(activityEventListener)
+  }
+
+  override fun openEditor(request: String, promise: Promise) {
+    try {
+      val payload = JSONObject(request)
+      val source = payload.optJSONObject("source")
+      if (source == null) {
+        promise.reject("E_INVALID_OPTIONS", "options.source is required.")
+        return
+      }
+      val uri = source.optString("uri").trim()
+      val type = source.optString("type")
+      val mimeType = source.optString("mimeType").takeIf { it.isNotBlank() }
+      val validationCode = EditorRequestValidator.validate(EditorRequest(uri, type, mimeType))
+      if (validationCode != null) {
+        val message = if (validationCode == "E_INVALID_URI") "source.uri must be a non-empty string." else "source.type must be photo or video."
+        promise.reject(validationCode, message)
+        return
+      }
+      val activity = reactApplicationContext.currentActivity
+      if (activity == null) {
+        promise.reject("E_EDITOR_UNAVAILABLE", "The editor requires a foreground Android Activity.")
+        return
+      }
+      if (editorPromise != null) {
+        promise.reject("E_EDITOR_ALREADY_OPEN", "Another editor is already open.")
+        return
+      }
+
+      editorPromise = promise
+      pendingUri = uri
+      pendingType = type
+      pendingMimeType = mimeType
+      val intent = Intent(activity, PhotoVideoEditorActivity::class.java)
+        .putExtra(PhotoVideoEditorActivity.EXTRA_URI, uri)
+        .putExtra(PhotoVideoEditorActivity.EXTRA_TYPE, type)
+        .putExtra(PhotoVideoEditorActivity.EXTRA_MIME_TYPE, mimeType)
+        .putExtra(PhotoVideoEditorActivity.EXTRA_REQUEST, request)
+      activity.runOnUiThread {
+        try {
+          activity.startActivityForResult(intent, EDITOR_REQUEST_CODE)
+          emitOnEditorEvent(JSONObject().put("type", "editorOpened").toString())
+        } catch (error: Exception) {
+          editorPromise = null
+          pendingUri = null
+          pendingType = null
+          pendingMimeType = null
+          promise.reject("E_INTERNAL", "Unable to launch the editor.", error)
+        }
+      }
+    } catch (_: Exception) {
+      promise.reject("E_INVALID_OPTIONS", "Editor options must be valid serialized JSON.")
+    }
+  }
+
+  override fun cancelExport(jobId: String?, promise: Promise) = promise.resolve(false)
+
+  override fun isAvailable(): Boolean = true
+
+  companion object {
+    const val NAME = NativePhotoVideoEditorSpec.NAME
+    private const val EDITOR_REQUEST_CODE = 41091
+  }
+}

package/android/src/main/java/com/photovideoeditor/PhotoVideoEditorPackage.kt

@@ -0,0 +1,31 @@
+package com.photovideoeditor
+
+import com.facebook.react.BaseReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
+import java.util.HashMap
+
+class PhotoVideoEditorPackage : BaseReactPackage() {
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? {
+    return if (name == PhotoVideoEditorModule.NAME) {
+      PhotoVideoEditorModule(reactContext)
+    } else {
+      null
+    }
+  }
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      PhotoVideoEditorModule.NAME to ReactModuleInfo(
+        name = PhotoVideoEditorModule.NAME,
+        className = PhotoVideoEditorModule.NAME,
+        canOverrideExistingModule = false,
+        needsEagerInit = false,
+        isCxxModule = false,
+        isTurboModule = true
+      )
+    )
+  }
+}