rns-mediapicker 0.0.1

package/README.md

@@ -0,0 +1,69 @@
+### rns-mediapicker
+A high-performance media picker for React Native and Expo. It handles image/video selection with native efficiency, automatic JPEG compression, and white-background flattening for transparent images.
+
+
+```bash
+installation
+yarn add rns-mediapicker
+```
+
+```bash
+Add the plugin to your app.json or app.config.js to automate permissions and Android manifest queries.
+
+{
+  "expo": {
+    "plugins": ["rns-mediapicker"]
+  }
+}
+```
+
+```js
+import FastMediaPicker from 'rns-mediapicker';
+
+const pickMedia = async () => {
+  try {
+    const result = await FastMediaPicker.pick(
+      false,    // useCamera: true to open camera, false for gallery
+      'both',   // mediaType: 'image', 'video', or 'both'
+      'back'    // env: 'front' or 'back' camera
+    );
+
+    console.log("File URI:", result.uri);
+    console.log("Dimensions:", result.width, "x", result.height);
+    console.log("Is Video:", result.isVideo);
+  } catch (error) {
+    if (error.code === 'E_CANCELLED') {
+      console.log('User closed the picker');
+    } else {
+      console.error('Picker Error:', error.message);
+    }
+  }
+};
+```
+
+```bash
+api-parameters
+pick(useCamera, mediaType, env)
+
+1. useCamera (boolean): Default is false.
+2. mediaType (string): 'image', 'video', or 'both'. Default is 'both'.
+3. env (string): 'front' or 'back'. Specifically for camera mode.
+```
+
+```bash
+response-object
+{
+  uri: string;      // path to the processed file
+  width: number;    // media width
+  height: number;   // media height
+  type: string;     // 'image' or 'video'
+  isVideo: boolean; // helper flag
+}
+
+-features-included
+1. Android 11+ Intent Queries: Automatically handled via plugin.
+2. FileProvider: Safe URI sharing handled internally.
+3. iOS Permissions: Usage descriptions injected into Info.plist.
+4. Image Flattening: Transparent images are automatically flattened onto white backgrounds.
+5. Swipe-to-Dismiss: iOS swipe-down gestures are correctly caught as cancellations.
+```

package/android/build.gradle

@@ -0,0 +1,70 @@
+// 1. Buildscript defines WHERE to get the plugins
+buildscript {
+    ext.kotlin_version = project.hasProperty('kotlinVersion') ? project.kotlinVersion : '1.8.10'
+    repositories {
+        google()
+        mavenCentral()
+    }
+    dependencies {
+        classpath "com.android.tools.build:gradle:7.4.2"
+        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
+    }
+}
+
+// 2. Apply the plugins immediately after buildscript
+apply plugin: 'com.android.library'
+apply plugin: 'kotlin-android'
+
+// 3. Define helper functions
+def safeExtGet(prop, fallback) {
+    rootProject.ext.has(prop) ? rootProject.ext.get(prop) : fallback
+}
+
+// 4. The Android block - should now be recognized
+android {
+    // Crucial for AGP 7+
+    namespace "com.rnsnativecall"
+    
+    compileSdkVersion safeExtGet('compileSdkVersion', 33)
+
+    defaultConfig {
+        minSdkVersion safeExtGet('minSdkVersion', 21)
+        targetSdkVersion safeExtGet('targetSdkVersion', 33)
+        
+        testInstrumentationRunner "androidx.test.runner.AndroidJUnitRunner"
+    }
+
+    compileOptions {
+        sourceCompatibility JavaVersion.VERSION_17
+        targetCompatibility JavaVersion.VERSION_17
+    }
+
+    kotlinOptions {
+        jvmTarget = '17' // Changed from 1.8
+    }
+
+    // lintOptions is deprecated in newer AGP, using lint instead
+    lint {
+        abortOnError false
+    }
+}
+
+repositories {
+    mavenCentral()
+    google()
+}
+
+dependencies {
+    implementation "com.facebook.react:react-native:+"
+    
+    implementation "org.jetbrains.kotlin:kotlin-stdlib:$kotlin_version"
+    implementation "com.google.firebase:firebase-messaging:23.4.0"
+    implementation "androidx.appcompat:appcompat:1.6.1"
+
+    implementation "com.google.android.material:material:1.9.0"
+    implementation "androidx.core:core-ktx:1.12.0"
+
+    // Glide for profile pictures
+    implementation "com.github.bumptech.glide:glide:4.15.1"
+    annotationProcessor "com.github.bumptech.glide:compiler:4.15.1"
+}

package/android/src/main/java/com/rnsmediapicker/FastMediaPickerModule.kt

@@ -0,0 +1,372 @@
+package com.rnsmediapicker
+
+import android.app.Activity
+import android.content.Intent
+import android.graphics.*
+import android.media.MediaMetadataRetriever
+import android.net.Uri
+import android.os.Build
+import android.provider.MediaStore
+import android.webkit.MimeTypeMap
+import androidx.core.content.FileProvider
+import com.facebook.react.bridge.*
+import com.facebook.react.module.annotations.ReactModule
+import com.facebook.react.modules.core.DeviceEventManagerModule
+import com.facebook.react.modules.core.PermissionAwareActivity
+import com.facebook.react.modules.core.PermissionListener
+import java.io.File
+import java.io.FileOutputStream
+import java.util.*
+
+@ReactModule(name = "FastMediaPicker")
+class FastMediaPickerModule(
+    private val reactContext: ReactApplicationContext,
+) : ReactContextBaseJavaModule(reactContext),
+    ActivityEventListener,
+    PermissionListener {
+    private var pickerPromise: Promise? = null
+    private var cameraCaptureUri: Uri? = null
+    private var pendingFrontCamera = false
+
+    companion object {
+        private const val PICKER_REQUEST_CODE = 4123
+        private const val CAMERA_PERMISSION_REQUEST = 9123
+        private const val MAX_IMAGE_SIZE = 1200
+        private const val JPEG_QUALITY = 85
+    }
+
+    init {
+        reactContext.addActivityEventListener(this)
+    }
+
+    override fun getName(): String = "FastMediaPicker"
+
+    // -------------------- REQUIRED EVENT CONTRACT --------------------
+
+    @ReactMethod
+    fun addListener(eventName: String) {
+        // Required for RN event emitter (even if unused)
+    }
+
+    @ReactMethod
+    fun removeListeners(count: Int) {
+        // Required for RN event emitter (even if unused)
+    }
+
+    private fun sendLog(message: String) {
+        android.util.Log.d("FastMediaPicker", message)
+        try {
+            reactContext
+                .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter::class.java)
+                .emit("onPickerLog", message)
+        } catch (_: Exception) {
+        }
+    }
+
+    // -------------------- PUBLIC API --------------------
+
+    @ReactMethod
+    fun pick(
+        useCamera: Boolean,
+        mediaType: String,
+        env: String?,
+        promise: Promise,
+    ) {
+        val activity =
+            currentActivity ?: run {
+                promise.reject("E_ACTIVITY_DOES_NOT_EXIST", "Activity doesn't exist")
+                return
+            }
+
+        cleanup()
+        pickerPromise = promise
+        pendingFrontCamera = env?.lowercase() == "front"
+
+        try {
+            if (useCamera) {
+                if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M &&
+                    activity.checkSelfPermission(android.Manifest.permission.CAMERA)
+                    != android.content.pm.PackageManager.PERMISSION_GRANTED
+                ) {
+                    val permissionAwareActivity =
+                        activity as? PermissionAwareActivity
+                            ?: run {
+                                promise.reject("E_ACTIVITY_NOT_PERMISSION_AWARE", "Activity not PermissionAware")
+                                cleanup()
+                                return
+                            }
+
+                    permissionAwareActivity.requestPermissions(
+                        arrayOf(android.Manifest.permission.CAMERA),
+                        CAMERA_PERMISSION_REQUEST,
+                        this,
+                    )
+                    return
+                }
+                launchCamera(activity, pendingFrontCamera)
+            } else {
+                launchPicker(activity, mediaType.lowercase())
+            }
+        } catch (e: Exception) {
+            promise.reject("E_LAUNCH_FAILED", e.message)
+            cleanup()
+        }
+    }
+
+    // -------------------- PICKER / CAMERA --------------------
+
+    private fun launchPicker(
+        activity: Activity,
+        type: String,
+    ) {
+        val intent =
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+                Intent(MediaStore.ACTION_PICK_IMAGES).apply {
+                    addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION)
+                    this.type =
+                        when (type) {
+                            "image" -> "image/*"
+                            "video" -> "video/*"
+                            else -> "*/*"
+                        }
+                }
+            } else {
+                Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+                    addCategory(Intent.CATEGORY_OPENABLE)
+                    addFlags(
+                        Intent.FLAG_GRANT_READ_URI_PERMISSION or
+                            Intent.FLAG_GRANT_PERSISTABLE_URI_PERMISSION,
+                    )
+                    this.type =
+                        when (type) {
+                            "image" -> "image/*"
+                            "video" -> "video/*"
+                            else -> "*/*"
+                        }
+                }
+            }
+
+        activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
+    }
+
+    private fun launchCamera(
+        activity: Activity,
+        useFrontCamera: Boolean,
+    ) {
+        val photoFile = createTempFile("jpg")
+        val authority = "${reactContext.packageName}.provider"
+        cameraCaptureUri = FileProvider.getUriForFile(reactContext, authority, photoFile)
+
+        val intent =
+            Intent(MediaStore.ACTION_IMAGE_CAPTURE).apply {
+                putExtra(MediaStore.EXTRA_OUTPUT, cameraCaptureUri)
+                addFlags(
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION or
+                        Intent.FLAG_GRANT_WRITE_URI_PERMISSION,
+                )
+                if (useFrontCamera) {
+                    putExtra("android.intent.extras.CAMERA_FACING", 1)
+                    putExtra("android.intent.extra.USE_FRONT_CAMERA", true)
+                }
+            }
+
+        activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
+    }
+
+    // -------------------- ACTIVITY CALLBACKS --------------------
+
+    override fun onActivityResult(
+        activity: Activity?,
+        requestCode: Int,
+        resultCode: Int,
+        data: Intent?,
+    ) {
+        if (requestCode != PICKER_REQUEST_CODE || pickerPromise == null) return
+
+        if (resultCode == Activity.RESULT_CANCELED) {
+            pickerPromise?.reject("E_CANCELLED", "User cancelled")
+            cleanup()
+            return
+        }
+
+        val uri = data?.data ?: cameraCaptureUri
+
+        if (uri != null && Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+            try {
+                reactContext.contentResolver.takePersistableUriPermission(
+                    uri,
+                    Intent.FLAG_GRANT_READ_URI_PERMISSION,
+                )
+            } catch (_: Exception) {
+            }
+        }
+
+        if (uri != null) {
+            processMedia(uri)
+        } else {
+            pickerPromise?.reject("E_NO_URI", "No media selected")
+            cleanup()
+        }
+    }
+
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray,
+    ): Boolean {
+        if (requestCode == CAMERA_PERMISSION_REQUEST) {
+            if (grantResults.isNotEmpty() &&
+                grantResults[0] == android.content.pm.PackageManager.PERMISSION_GRANTED
+            ) {
+                currentActivity?.let {
+                    launchCamera(it, pendingFrontCamera)
+                }
+            } else {
+                pickerPromise?.reject("E_CAMERA_PERMISSION", "Camera permission denied")
+                cleanup()
+            }
+            return true
+        }
+        return false
+    }
+
+    // -------------------- MEDIA PROCESSING --------------------
+
+    private fun processMedia(uri: Uri) {
+        val resolver = reactContext.contentResolver
+        val mimeType = resolver.getType(uri) ?: "image/jpeg"
+        val isVideo = mimeType.startsWith("video/")
+
+        try {
+            if (isVideo) {
+                val ext =
+                    MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType) ?: "mp4"
+                val tempFile = createTempFile(ext)
+
+                resolver.openInputStream(uri)?.use { input ->
+                    FileOutputStream(tempFile).use { output -> input.copyTo(output) }
+                }
+
+                val (w, h) = getVideoDimensions(tempFile)
+                resolveResult(Uri.fromFile(tempFile).toString(), true, w, h)
+            } else {
+                val tempFile = processAndSaveImage(uri)
+                val opts = BitmapFactory.Options().apply { inJustDecodeBounds = true }
+                BitmapFactory.decodeFile(tempFile.absolutePath, opts)
+                resolveResult(
+                    Uri.fromFile(tempFile).toString(),
+                    false,
+                    opts.outWidth,
+                    opts.outHeight,
+                )
+            }
+        } catch (e: Exception) {
+            pickerPromise?.reject("E_PROCESS_ERROR", e.message)
+        } finally {
+            cleanup()
+        }
+    }
+
+    private fun getVideoDimensions(file: File): Pair<Int, Int> {
+        val retriever = MediaMetadataRetriever()
+        return try {
+            retriever.setDataSource(file.absolutePath)
+            val w =
+                retriever
+                    .extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)
+                    ?.toInt() ?: 0
+            val h =
+                retriever
+                    .extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)
+                    ?.toInt() ?: 0
+            val rot =
+                retriever
+                    .extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_ROTATION)
+                    ?.toInt() ?: 0
+            if (rot == 90 || rot == 270) h to w else w to h
+        } finally {
+            retriever.release()
+        }
+    }
+
+    private fun processAndSaveImage(uri: Uri): File {
+        val tempFile = createTempFile("jpg")
+        val resolver = reactContext.contentResolver
+
+        val opts =
+            BitmapFactory.Options().apply {
+                inJustDecodeBounds = true
+                resolver.openInputStream(uri)?.use {
+                    BitmapFactory.decodeStream(it, null, this)
+                }
+                inSampleSize =
+                    calculateInSampleSize(outWidth, outHeight, MAX_IMAGE_SIZE, MAX_IMAGE_SIZE)
+                inJustDecodeBounds = false
+            }
+
+        val original =
+            resolver.openInputStream(uri)?.use {
+                BitmapFactory.decodeStream(it, null, opts)
+            } ?: throw RuntimeException("Decode failed")
+
+        val result =
+            Bitmap.createBitmap(original.width, original.height, Bitmap.Config.ARGB_8888)
+
+        Canvas(result).apply {
+            drawColor(Color.WHITE)
+            drawBitmap(original, 0f, 0f, null)
+        }
+
+        FileOutputStream(tempFile).use {
+            result.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, it)
+        }
+
+        original.recycle()
+        result.recycle()
+        return tempFile
+    }
+
+    private fun calculateInSampleSize(
+        w: Int,
+        h: Int,
+        reqW: Int,
+        reqH: Int,
+    ): Int {
+        var size = 1
+        if (h > reqH || w > reqW) {
+            val halfH = h / 2
+            val halfW = w / 2
+            while (halfH / size >= reqH && halfW / size >= reqW) {
+                size *= 2
+            }
+        }
+        return size
+    }
+
+    private fun resolveResult(
+        uri: String,
+        isVideo: Boolean,
+        w: Int,
+        h: Int,
+    ) {
+        val map =
+            Arguments.createMap().apply {
+                putString("uri", uri)
+                putBoolean("isVideo", isVideo)
+                putString("type", if (isVideo) "video" else "image")
+                putDouble("width", w.toDouble())
+                putDouble("height", h.toDouble())
+            }
+        pickerPromise?.resolve(map)
+    }
+
+    private fun createTempFile(ext: String): File = File(reactContext.cacheDir, "fast-${UUID.randomUUID()}.$ext")
+
+    private fun cleanup() {
+        pickerPromise = null
+        cameraCaptureUri = null
+        pendingFrontCamera = false
+    }
+
+    override fun onNewIntent(intent: Intent?) {}
+}

package/android/src/main/java/com/rnsmediapicker/FastMediaPickerPackage.kt

@@ -0,0 +1,13 @@
+package com.rnsmediapicker
+
+import com.facebook.react.ReactPackage
+import com.facebook.react.bridge.NativeModule
+import com.facebook.react.bridge.ReactApplicationContext
+import com.facebook.react.uimanager.ViewManager
+
+class FastMediaPickerPackage : ReactPackage {
+    override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> =
+        listOf(FastMediaPickerModule(reactContext))
+
+    override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> = emptyList()
+}

package/android/src/main/res/xml/file_paths.xml

@@ -0,0 +1,5 @@
+<?xml version="1.0" encoding="utf-8"?>
+<paths>
+    <external-path name="my_images" path="." />
+    <cache-path name="cache" path="." />
+</paths>

package/app.plugin.js

@@ -0,0 +1,5 @@
+const withMediaPicker = require('./withMediaPicker');
+
+module.exports = function (config) {
+    return withMediaPicker(config);
+};

package/index.d.ts

@@ -0,0 +1,32 @@
+declare module 'rns-mediapicker' {
+    export interface PickerResponse {
+        /** The local file URI of the processed media */
+        uri: string;
+        /** Width of the image or video in pixels */
+        width: number;
+        /** Height of the image or video in pixels */
+        height: number;
+        /** The type of media: 'image' or 'video' */
+        type: 'image' | 'video';
+        /** Helper boolean for quick video checking */
+        isVideo: boolean;
+    }
+
+    export interface FastMediaPickerType {
+        /**
+         * Launch the media picker or camera.
+         * * @param useCamera - Set to true to open the camera directly. Defaults to false.
+         * @param mediaType - Specify 'image', 'video', or 'both'. Defaults to 'both'.
+         * @param env - Use 'front' to specify the front camera on Android/iOS.
+         * @returns A promise that resolves with the media metadata.
+         */
+        pick(
+            useCamera?: boolean,
+            mediaType?: 'image' | 'video' | 'both',
+            env?: 'front' | 'back' | string
+        ): Promise<PickerResponse>;
+    }
+
+    const FastMediaPicker: FastMediaPickerType;
+    export default FastMediaPicker;
+}

package/index.js

@@ -0,0 +1,36 @@
+import { NativeModules, TurboModuleRegistry, Platform } from 'react-native';
+
+// 1. Try to find the module in the new TurboModuleRegistry or the legacy NativeModules
+const NativeModule = NativeModules.FastMediaPicker
+    ? NativeModules.FastMediaPicker
+    : TurboModuleRegistry.get('FastMediaPicker');
+
+/**
+ * High-performance media picker for React Native.
+ * Supports image and video picking with automatic compression and white-background flattening.
+ */
+const FastMediaPicker = {
+    /**
+     * Launch the media picker or camera.
+     * * @param {boolean} useCamera - Whether to open the camera directly.
+     * @param {string} mediaType - 'image', 'video', or 'both'.
+     * @param {string} env - Use 'front' for front camera on supported devices.
+     * @returns {Promise<{uri: string, width: number, height: number, type: string, isVideo: boolean}>}
+     */
+    pick: async (useCamera = false, mediaType = 'both', env = '') => {
+        if (!NativeModule) {
+            throw new Error(
+                "FastMediaPicker: Native module not found. Ensure you have run 'npx expo prebuild' and rebuilt the native app."
+            );
+        }
+
+        try {
+            // In some RN versions, TurboModules require the exact argument count
+            return await NativeModule.pick(useCamera, mediaType, env);
+        } catch (error) {
+            throw error;
+        }
+    }
+};
+
+export default FastMediaPicker;

package/ios/FastMediaPicker.m

@@ -0,0 +1,11 @@
+#import <React/RCTBridgeModule.h>
+
+@interface RCT_EXTERN_MODULE(FastMediaPicker, NSObject)
+
+RCT_EXTERN_METHOD(pick:(BOOL)useCamera
+                  mediaType:(NSString *)mediaType
+                  env:(NSString *)env
+                  resolver:(RCTPromiseResolveBlock)resolve
+                  rejecter:(RCTPromiseRejectBlock)reject)
+
+@end

package/ios/FastMediaPicker.swift

@@ -0,0 +1,194 @@
+import AVFoundation
+import Photos
+import UIKit
+import UniformTypeIdentifiers
+import React
+
+@objc(FastMediaPicker)
+// 1. Added UIAdaptivePresentationControllerDelegate to the class signature
+class FastMediaPicker: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate, UIAdaptivePresentationControllerDelegate, RCTBridgeModule {
+
+    static func moduleName() -> String! {
+        return "FastMediaPicker"
+    }
+
+    static func requiresMainQueueSetup() -> Bool {
+        return true
+    }
+
+    private var resolve: RCTPromiseResolveBlock?
+    private var reject: RCTPromiseRejectBlock?
+
+    @objc(pick:mediaType:env:resolver:rejecter:)
+    func pick(
+        _ useCamera: Bool,
+        mediaType: String,
+        env: String?,
+        resolver resolve: @escaping RCTPromiseResolveBlock,
+        rejecter reject: @escaping RCTPromiseRejectBlock
+    ) {
+        self.resolve = resolve
+        self.reject = reject
+
+        DispatchQueue.main.async {
+            let picker = UIImagePickerController()
+            picker.delegate = self
+            // 2. Set the presentation controller delegate to catch swipes
+            picker.presentationController?.delegate = self
+            picker.allowsEditing = false
+
+            if useCamera {
+                guard UIImagePickerController.isSourceTypeAvailable(.camera) else {
+                    self.safeReject("E_CAMERA_UNAVAILABLE", "Camera not available")
+                    return
+                }
+                picker.sourceType = .camera
+                if let env = env?.lowercased(), env == "front" {
+                    picker.cameraDevice = .front
+                }
+            } else {
+                picker.sourceType = .photoLibrary
+            }
+
+            let typeLower = mediaType.lowercased()
+            if typeLower == "image" {
+                picker.mediaTypes = [UTType.image.identifier]
+            } else if typeLower == "video" {
+                picker.mediaTypes = [UTType.movie.identifier]
+                picker.videoQuality = .typeHigh
+            } else {
+                picker.mediaTypes = [UTType.image.identifier, UTType.movie.identifier]
+            }
+
+            if let vc = self.topMostViewController() {
+                vc.present(picker, animated: true, completion: nil)
+            } else {
+                self.safeReject("E_NO_VC", "Could not find view controller")
+            }
+        }
+    }
+
+    // MARK: - Delegate Methods
+    
+    // Handles the "Cancel" button tap
+    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true) {
+            self.safeReject("E_CANCELLED", "User cancelled")
+        }
+    }
+
+    // 3. Handles the swipe-down gesture dismissal
+    func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+        self.safeReject("E_CANCELLED", "User cancelled via swipe")
+    }
+
+    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
+        picker.dismiss(animated: true)
+
+        if let mediaURL = info[.mediaURL] as? URL {
+            handlePickedVideo(url: mediaURL)
+        } else if let image = (info[.editedImage] as? UIImage) ?? (info[.originalImage] as? UIImage) {
+            processPickedImage(image)
+        } else {
+            safeReject("E_NO_MEDIA", "Failed to retrieve media")
+        }
+    }
+
+    // MARK: - Handlers
+  private func processPickedImage(_ image: UIImage) {
+      let fileURL = makeTempURL(ext: "jpg")
+      
+      // Create a white background to prevent transparent areas from turning black
+      let format = UIGraphicsImageRendererFormat()
+      format.scale = image.scale
+      format.opaque = true // This forces a solid background
+      
+      let renderer = UIGraphicsImageRenderer(size: image.size, format: format)
+      let whiteBgImage = renderer.image { context in
+          UIColor.white.setFill()
+          context.fill(CGRect(origin: .zero, size: image.size))
+          image.draw(at: .zero)
+      }
+      
+      // Convert the flattened image to JPEG
+      guard let data = whiteBgImage.jpegData(compressionQuality: 0.8) else {
+          safeReject("E_ENCODE", "JPEG conversion failed")
+          return
+      }
+
+      do {
+          try data.write(to: fileURL)
+          resolve?([
+              "uri": fileURL.absoluteString,
+              "width": image.size.width,
+              "height": image.size.height,
+              "type": "image",
+              "isVideo": false
+          ])
+          cleanupPromise()
+      } catch {
+          safeReject("E_WRITE", error.localizedDescription)
+      }
+  }
+
+    private func handlePickedVideo(url: URL) {
+        // 4. Force lowercase extension
+        let ext = url.pathExtension.isEmpty ? "mp4" : url.pathExtension.lowercased()
+        let fileURL = makeTempURL(ext: ext)
+        
+        do {
+            if FileManager.default.fileExists(atPath: fileURL.path) {
+                try FileManager.default.removeItem(at: fileURL)
+            }
+            try FileManager.default.copyItem(at: url, to: fileURL)
+            let dims = videoDimensions(for: fileURL)
+            resolve?([
+                "uri": fileURL.absoluteString,
+                "width": dims.width,
+                "height": dims.height,
+                "type": "video",
+                "isVideo": true // Added isVideo
+            ])
+            cleanupPromise()
+        } catch {
+            safeReject("E_VIDEO_COPY", error.localizedDescription)
+        }
+    }
+
+    // MARK: - Helpers
+    private func safeReject(_ code: String, _ message: String) {
+        self.reject?(code, message, nil)
+        cleanupPromise()
+    }
+
+    private func cleanupPromise() {
+        resolve = nil
+        reject = nil
+    }
+
+    private func topMostViewController() -> UIViewController? {
+        let keyWindow = UIApplication.shared.connectedScenes
+            .compactMap { $0 as? UIWindowScene }
+            .flatMap { $0.windows }
+            .first { $0.isKeyWindow }
+        
+        var topController = keyWindow?.rootViewController
+        while let presented = topController?.presentedViewController {
+            topController = presented
+        }
+        return topController
+    }
+
+    private func makeTempURL(ext: String) -> URL {
+        let tempDir = URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+        // Ensure ext is lowercase here just in case
+        return tempDir.appendingPathComponent("fastpicker-\(UUID().uuidString).\(ext.lowercased())")
+    }
+
+    private func videoDimensions(for url: URL) -> (width: CGFloat, height: CGFloat) {
+        let asset = AVAsset(url: url)
+        guard let track = asset.tracks(withMediaType: .video).first else { return (0, 0) }
+        let size = track.naturalSize.applying(track.preferredTransform)
+        return (width: abs(size.width), height: abs(size.height))
+    }
+}

package/package.json

@@ -0,0 +1,52 @@
+{
+    "name": "rns-mediapicker",
+    "version": "0.0.1",
+    "description": "High-performance React Native module for picking media on Android and iOS.",
+    "main": "index.js",
+    "types": "index.d.ts",
+    "expo": {
+        "autolinking": {
+            "ios": {
+                "podspec": "rns-mediapicker.podspec"
+            }
+        },
+        "plugin": "./app.plugin.js"
+    },
+    "homepage": "https://github.com/raiidr/rns-mediapicker",
+    "license": "MIT",
+    "author": "Raiidr <info@raiidr.com>",
+    "repository": {
+        "type": "git",
+        "url": "git+https://github.com/raiidr/rns-mediapicker.git"
+    },
+    "scripts": {
+        "p": "npm publish --access public"
+    },
+    "keywords": [
+        "react-native",
+        "mediapicker",
+        "images",
+        "videos",
+        "android",
+        "ios",
+        "expo",
+        "config-plugin"
+    ],
+    "files": [
+        "android",
+        "ios",
+        "app.plugin.js",
+        "index.d.ts",
+        "index.js",
+        "react-native.config.js",
+        "rns-mediapicker.podspec",
+        "withMediaPicker.js"
+    ],
+    "peerDependencies": {
+        "expo": ">=45.0.0",
+        "react-native": ">=0.60.0"
+    },
+    "dependencies": {
+        "@expo/config-plugins": "^9.0.0"
+    }
+}

package/react-native.config.js

@@ -0,0 +1,11 @@
+module.exports = {
+    dependencies: {
+        'rns-mediapicker': {
+            platforms: {
+                ios: {
+                    podspecPath: 'rns-mediapicker.podspec',
+                },
+            },
+        },
+    },
+};

package/rns-mediapicker.podspec

@@ -0,0 +1,18 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "rns-mediapicker"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+  s.platforms    = { :ios => "13.4" }
+  s.source       = { :git => "https://github.com/raiidr/rns-mediapicker.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm,swift}"
+
+  s.dependency "React-Core"
+end

package/withMediaPicker.js

@@ -0,0 +1,116 @@
+const { withAndroidManifest, withInfoPlist, AndroidConfig } = require('@expo/config-plugins');
+
+const { getMainApplicationOrThrow } = AndroidConfig.Manifest;
+
+/**
+ * Android Configuration
+ */
+const withAndroidConfig = (config) => {
+    return withAndroidManifest(config, (config) => {
+        const androidManifest = config.modResults;
+
+        // 1. Add Permissions
+        const permissions = [
+            'android.permission.CAMERA',
+            'android.permission.READ_EXTERNAL_STORAGE',
+            'android.permission.WRITE_EXTERNAL_STORAGE',
+            'android.permission.READ_MEDIA_IMAGES',
+            'android.permission.READ_MEDIA_VIDEO',
+        ];
+
+        if (!androidManifest.manifest['uses-permission']) {
+            androidManifest.manifest['uses-permission'] = [];
+        }
+
+        permissions.forEach((perm) => {
+            if (!androidManifest.manifest['uses-permission'].find((p) => p.$['android:name'] === perm)) {
+                androidManifest.manifest['uses-permission'].push({ $: { 'android:name': perm } });
+            }
+        });
+
+        // 2. Add Queries (For Android 11+ visibility)
+        if (!androidManifest.manifest.queries) {
+            androidManifest.manifest.queries = [{}];
+        }
+        const queries = androidManifest.manifest.queries[0];
+        if (!queries.intent) queries.intent = [];
+
+        const pickerIntents = [
+            { action: [{ $: { 'android:name': 'android.media.action.IMAGE_CAPTURE' } }] },
+            { action: [{ $: { 'android:name': 'android.provider.action.PICK_IMAGES' } }] },
+            {
+                action: [{ $: { 'android:name': 'android.intent.action.OPEN_DOCUMENT' } }],
+                data: [{ $: { 'android:mimeType': 'image/*' } }]
+            },
+            {
+                action: [{ $: { 'android:name': 'android.intent.action.OPEN_DOCUMENT' } }],
+                data: [{ $: { 'android:mimeType': 'video/*' } }]
+            }
+        ];
+
+        pickerIntents.forEach((intent) => {
+            const intentName = intent.action[0].$['android:name'];
+            const exists = queries.intent.find(i => i.action[0].$['android:name'] === intentName);
+            if (!exists) queries.intent.push(intent);
+        });
+
+        // 3. Ensure FileProvider exists (The "Null" Fix)
+        const mainApplication = getMainApplicationOrThrow(androidManifest);
+        if (!mainApplication.provider) {
+            mainApplication.provider = [];
+        }
+
+        const providerClassName = 'androidx.core.content.FileProvider';
+        const providerAuthority = '${applicationId}.provider';
+
+        const hasProvider = mainApplication.provider.find(
+            (p) => p.$['android:name'] === providerClassName || p.$['android:authorities'] === providerAuthority
+        );
+
+        if (!hasProvider) {
+            mainApplication.provider.push({
+                $: {
+                    'android:name': providerClassName,
+                    'android:authorities': providerAuthority,
+                    'android:exported': 'false',
+                    'android:grantUriPermissions': 'true',
+                },
+                'meta-data': [
+                    {
+                        $: {
+                            'android:name': 'android.support.FILE_PROVIDER_PATHS',
+                            'android:resource': '@xml/file_paths',
+                        },
+                    },
+                ],
+            });
+        }
+
+        return config;
+    });
+};
+
+/**
+ * iOS Configuration
+ */
+const withIosConfig = (config) => {
+    return withInfoPlist(config, (config) => {
+        config.modResults.NSCameraUsageDescription =
+            config.modResults.NSCameraUsageDescription || "Allow $(PRODUCT_NAME) to access your camera to take photos and videos.";
+        config.modResults.NSPhotoLibraryUsageDescription =
+            config.modResults.NSPhotoLibraryUsageDescription || "Allow $(PRODUCT_NAME) to access your photo library to select media.";
+        config.modResults.NSMicrophoneUsageDescription =
+            config.modResults.NSMicrophoneUsageDescription || "Allow $(PRODUCT_NAME) to access your microphone when recording video.";
+
+        return config;
+    });
+};
+
+/**
+ * Export the Plugin
+ */
+module.exports = function withMediaPicker(config) {
+    config = withAndroidConfig(config);
+    config = withIosConfig(config);
+    return config;
+};