rns-mediapicker 0.0.8 → 0.1.0

package/README.md

@@ -1,74 +1,96 @@
 ### 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
+A high-performance native media picker for React Native and Expo.
+Supports audio, image, and video selection from camera or library, automatic JPEG compression, EXIF-safe dimensions, and transparent-image flattening.
+
+---
+
+## Installation
+
 yarn add rns-mediapicker
-```
+npx expo install rns-mediapicker
+npm install rns-mediapicker
+
+---
+
+## Expo Configuration
+
+Add the plugin to your app.json or app.config.js to automatically configure permissions, intent queries, and FileProvider.
 
-```bash
-Add the plugin to your app.json or app.config.js to automate permissions and Android manifest queries.
-```
-```js
 {
   "expo": {
     "plugins": ["rns-mediapicker"]
   }
 }
-```
 
-```js
+---
+
+## Usage
+
 import MediaPicker from 'rns-mediapicker';
 
 const pickMedia = async () => {
   try {
     const result = await MediaPicker.pick(
-      false,    // useCamera: true to open camera, false for gallery
-      'both',   // mediaType: 'image', 'video', or 'both'
-      'back'    // env: 'front' or 'back' camera
+      false,
+      'both',
+      'back'
     );
 
-    console.log("File URI:", result.uri);
-    console.log("Dimensions:", result.width, "x", result.height);
-    console.log("Is Video:", result.isVideo);
+    console.log('URI:', result.uri);
+    console.log('Type:', result.type);
+    console.log('Width:', result.width);
+    console.log('Height:', result.height);
+    console.log('Is Video:', result.isVideo);
+    console.log('Is Audio:', result.isAudio);
   } catch (error) {
     if (error.code === 'E_CANCELLED') {
-      console.log('User closed the picker');
+      console.log('User cancelled picker');
     } else {
-      console.error('Picker Error:', error.message);
+      console.error('Picker error:', error.message);
     }
   }
 };
-```
 
-```bash
-api-parameters
+---
+
+## API
+
 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.
-```
+useCamera (boolean): true opens camera, false opens picker  
+mediaType (string): 'audio', 'image', 'video', 'both'  
+env (string): 'front' or 'back' camera (camera only)
+
+---
+
+## Response Object
 
-```bash
-response-object
-```
-```js
 {
-  uri: string;      // path to the processed file
-  width: number;    // media width
-  height: number;   // media height
-  type: string;     // 'image' or 'video'
-  isVideo: boolean; // helper flag
+  uri: string;
+  width: number;
+  height: number;
+  type: string;
+  isVideo: boolean;
+  isAudio: boolean;
 }
-```
-```bash 
-features-included
-```
-```js
-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.
-```
+
+---
+
+## Features
+
+- Audio / Image / Video support
+- Camera and Library selection
+- Camera video capture (Android & iOS)
+- Automatic JPEG compression
+- White-background flattening
+- EXIF-safe rotation and dimensions
+- Scoped-storage safe temp files
+- Android FileProvider configured
+- iOS swipe-to-dismiss cancellation handling
+
+---
+
+## License
+
+MIT

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

@@ -4,6 +4,7 @@ import android.Manifest
 import android.app.Activity
 import android.content.Intent
 import android.graphics.*
+import android.media.ExifInterface
 import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Build
@@ -12,7 +13,6 @@ 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
@@ -34,7 +34,6 @@ class FastMediaPickerModule(
     companion object {
         private const val PICKER_REQUEST_CODE = 4123
         private const val PERMISSION_REQUEST = 9123
-        private const val MAX_IMAGE_SIZE = 1200
         private const val JPEG_QUALITY = 85
     }
 
@@ -48,8 +47,6 @@ class FastMediaPickerModule(
 
     @ReactMethod fun removeListeners(count: Int) {}
 
-    // -------------------- PUBLIC API --------------------
-
     @ReactMethod
     fun pick(
         useCamera: Boolean,
@@ -66,18 +63,14 @@ class FastMediaPickerModule(
         cleanup()
         pickerPromise = promise
         pendingUseCamera = useCamera
-        pendingMediaType = mediaType
+        pendingMediaType = mediaType.lowercase()
         pendingFrontCamera = env?.lowercase() == "front"
 
         val permissions = mutableListOf<String>()
-
         if (useCamera) {
             permissions.add(Manifest.permission.CAMERA)
-        } else {
-            // Only require storage permission for legacy pickers on Android 12 and below
-            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
-                permissions.add(Manifest.permission.READ_EXTERNAL_STORAGE)
-            }
+        } else if (Build.VERSION.SDK_INT < 33) {
+            permissions.add(Manifest.permission.READ_EXTERNAL_STORAGE)
         }
 
         val missing =
@@ -86,12 +79,12 @@ class FastMediaPickerModule(
             }
 
         if (missing.isNotEmpty()) {
-            val pa =
-                activity as? PermissionAwareActivity ?: run {
-                    promise.reject("E_NOT_PERMISSION_AWARE", "Activity not PermissionAware")
-                    cleanup()
-                    return
-                }
+            val pa = activity as? PermissionAwareActivity
+            if (pa == null) {
+                promise.reject("E_NOT_PERMISSION_AWARE", "Activity not PermissionAware")
+                cleanup()
+                return
+            }
             pa.requestPermissions(missing.toTypedArray(), PERMISSION_REQUEST, this)
             return
         }
@@ -101,92 +94,78 @@ class FastMediaPickerModule(
 
     private fun launch(activity: Activity) {
         if (pendingUseCamera) {
-            launchCamera(activity, pendingFrontCamera)
+            launchCamera(activity, pendingMediaType, pendingFrontCamera)
         } else {
             launchPicker(activity, pendingMediaType ?: "both")
         }
     }
 
-    // -------------------- PERMISSIONS CALLBACK --------------------
-
-    override fun onRequestPermissionsResult(
-        requestCode: Int,
-        permissions: Array<String>,
-        grantResults: IntArray,
-    ): Boolean {
-        if (requestCode != PERMISSION_REQUEST) return false
-
-        if (grantResults.any { it != android.content.pm.PackageManager.PERMISSION_GRANTED }) {
-            pickerPromise?.reject("E_PERMISSION_DENIED", "Required permission denied")
-            cleanup()
-            return true
-        }
-
-        currentActivity?.let { launch(it) }
-        return true
-    }
-
-    // -------------------- PICKER / CAMERA --------------------
-
     private fun launchPicker(
         activity: Activity,
         type: String,
     ) {
-        val intent =
-            Intent("android.provider.action.PICK_IMAGES").apply {
-                when (type) {
-                    "video" -> this.type = "video/*"
-                    "image" -> this.type = "image/*"
+        if (type == "audio") {
+            val intent =
+                Intent(Intent.ACTION_GET_CONTENT).apply {
+                    addCategory(Intent.CATEGORY_OPENABLE)
+                    this.type = "audio/*"
                 }
-            }
+            activity.startActivityForResult(Intent.createChooser(intent, "Select Audio"), PICKER_REQUEST_CODE)
+            return
+        }
 
-        try {
+        if (Build.VERSION.SDK_INT >= 33) {
+            val intent = Intent(MediaStore.ACTION_PICK_IMAGES)
             activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
-        } catch (e: Exception) {
-            val fallbackIntent =
-                Intent(Intent.ACTION_GET_CONTENT).apply {
-                    addCategory(Intent.CATEGORY_OPENABLE)
-                    this.type =
-                        when (type) {
-                            "video" -> "video/*"
-                            "image" -> "image/*"
-                            else -> "*/*"
-                        }
-                    if (type == "both") {
-                        putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
+            return
+        }
+
+        val fallback =
+            Intent(Intent.ACTION_GET_CONTENT).apply {
+                addCategory(Intent.CATEGORY_OPENABLE)
+                type =
+                    when (type) {
+                        "video" -> "video/*"
+                        "image" -> "image/*"
+                        else -> "*/*"
                     }
+                if (type == "both") {
+                    putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
                 }
-            try {
-                activity.startActivityForResult(Intent.createChooser(fallbackIntent, "Select Media"), PICKER_REQUEST_CODE)
-            } catch (fallbackEx: Exception) {
-                pickerPromise?.reject("E_NO_PICKER", "No picker available")
-                cleanup()
             }
-        }
+        activity.startActivityForResult(Intent.createChooser(fallback, "Select Media"), PICKER_REQUEST_CODE)
     }
 
     private fun launchCamera(
         activity: Activity,
+        type: String?,
         useFrontCamera: Boolean,
     ) {
-        val file = createTempFile("jpg")
+        val isVideo = type == "video"
+        val ext = if (isVideo) "mp4" else "jpg"
+        val file = createTempFile(ext)
+
         val authority = "${reactContext.packageName}.provider"
         cameraCaptureUri = FileProvider.getUriForFile(reactContext, authority, file)
 
         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)
-                }
+            if (isVideo) {
+                Intent(MediaStore.ACTION_VIDEO_CAPTURE)
+            } else {
+                Intent(MediaStore.ACTION_IMAGE_CAPTURE)
             }
+
+        intent.putExtra(MediaStore.EXTRA_OUTPUT, cameraCaptureUri)
+        intent.addFlags(Intent.FLAG_GRANT_READ_URI_PERMISSION or Intent.FLAG_GRANT_WRITE_URI_PERMISSION)
+
+        if (useFrontCamera) {
+            intent.putExtra("android.intent.extras.CAMERA_FACING", 1)
+            intent.putExtra("android.intent.extra.USE_FRONT_CAMERA", true)
+        }
+
         activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
     }
 
-    // -------------------- ACTIVITY RESULT --------------------
-
     override fun onActivityResult(
         activity: Activity?,
         requestCode: Int,
@@ -202,57 +181,62 @@ class FastMediaPickerModule(
         }
 
         val uri = data?.data ?: cameraCaptureUri
-        if (uri != null) {
-            processMedia(uri)
-        } else {
+        if (uri == null) {
             pickerPromise?.reject("E_NO_URI", "No media selected")
             cleanup()
+            return
         }
+
+        processMedia(uri)
     }
 
-    // -------------------- MEDIA PROCESSING --------------------
+    override fun onActivityResult(
+        requestCode: Int,
+        resultCode: Int,
+        data: Intent?,
+    ) {
+        onActivityResult(currentActivity, requestCode, resultCode, data)
+    }
 
     private fun processMedia(uri: Uri) {
         val resolver = reactContext.contentResolver
         val mime = resolver.getType(uri) ?: "image/jpeg"
-        val isVideo = mime.startsWith("video")
 
         try {
-            if (isVideo) {
-                val file = createTempFile("mp4")
-                resolver.openInputStream(uri)?.use { input ->
-                    FileOutputStream(file).use { input.copyTo(it) }
+            when {
+                mime.startsWith("audio") -> {
+                    val ext = MimeTypeMap.getSingleton().getExtensionFromMimeType(mime) ?: "mp3"
+                    val file = createTempFile(ext)
+                    resolver.openInputStream(uri)?.use { it.copyTo(FileOutputStream(file)) }
+                    resolveResult(Uri.fromFile(file).toString(), false, true, 0, 0)
                 }
 
-                // Get Video Dimensions
-                val retriever = MediaMetadataRetriever()
-                retriever.setDataSource(reactContext, uri)
-                val width = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toInt() ?: 0
-                val height = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toInt() ?: 0
-                retriever.release()
+                mime.startsWith("video") -> {
+                    val file = createTempFile("mp4")
+                    resolver.openInputStream(uri)?.use { it.copyTo(FileOutputStream(file)) }
 
-                resolveResult(Uri.fromFile(file).toString(), true, width, height)
-            } else {
-                val file = createTempFile("jpg")
-                var width = 0
-                var height = 0
-
-                resolver.openInputStream(uri)?.use { input ->
-                    val options = BitmapFactory.Options().apply { inJustDecodeBounds = true }
-                    BitmapFactory.decodeStream(input, null, options)
-                    width = options.outWidth
-                    height = options.outHeight
+                    val retriever = MediaMetadataRetriever()
+                    retriever.setDataSource(reactContext, uri)
+                    val w = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_WIDTH)?.toInt() ?: 0
+                    val h = retriever.extractMetadata(MediaMetadataRetriever.METADATA_KEY_VIDEO_HEIGHT)?.toInt() ?: 0
+                    retriever.release()
+
+                    resolveResult(Uri.fromFile(file).toString(), true, false, w, h)
                 }
 
-                // Re-open stream for actual compression
-                resolver.openInputStream(uri)?.use { input ->
-                    BitmapFactory.decodeStream(input)?.compress(
-                        Bitmap.CompressFormat.JPEG,
-                        JPEG_QUALITY,
-                        FileOutputStream(file),
+                else -> {
+                    val file = createTempFile("jpg")
+                    val bitmap = BitmapFactory.decodeStream(resolver.openInputStream(uri))
+                    val rotated = rotateIfNeeded(bitmap, uri)
+                    rotated.compress(Bitmap.CompressFormat.JPEG, JPEG_QUALITY, FileOutputStream(file))
+                    resolveResult(
+                        Uri.fromFile(file).toString(),
+                        false,
+                        false,
+                        rotated.width,
+                        rotated.height,
                     )
                 }
-                resolveResult(Uri.fromFile(file).toString(), false, width, height)
             }
         } catch (e: Exception) {
             pickerPromise?.reject("E_PROCESS", e.message)
@@ -261,9 +245,28 @@ class FastMediaPickerModule(
         }
     }
 
+    private fun rotateIfNeeded(
+        bitmap: Bitmap,
+        uri: Uri,
+    ): Bitmap {
+        val input = reactContext.contentResolver.openInputStream(uri) ?: return bitmap
+        val exif = ExifInterface(input)
+        val rotation =
+            when (exif.getAttributeInt(ExifInterface.TAG_ORIENTATION, ExifInterface.ORIENTATION_NORMAL)) {
+                ExifInterface.ORIENTATION_ROTATE_90 -> 90
+                ExifInterface.ORIENTATION_ROTATE_180 -> 180
+                ExifInterface.ORIENTATION_ROTATE_270 -> 270
+                else -> 0
+            }
+        if (rotation == 0) return bitmap
+        val matrix = Matrix().apply { postRotate(rotation.toFloat()) }
+        return Bitmap.createBitmap(bitmap, 0, 0, bitmap.width, bitmap.height, matrix, true)
+    }
+
     private fun resolveResult(
         uri: String,
         isVideo: Boolean,
+        isAudio: Boolean,
         w: Int,
         h: Int,
     ) {
@@ -271,9 +274,19 @@ class FastMediaPickerModule(
             Arguments.createMap().apply {
                 putString("uri", uri)
                 putBoolean("isVideo", isVideo)
+                putBoolean("isAudio", isAudio)
                 putInt("width", w)
                 putInt("height", h)
-                putString("type", if (isVideo) "video" else "image")
+                putString(
+                    "type",
+                    if (isAudio) {
+                        "audio"
+                    } else if (isVideo) {
+                        "video"
+                    } else {
+                        "image"
+                    },
+                )
             },
         )
     }
@@ -288,5 +301,22 @@ class FastMediaPickerModule(
         pendingMediaType = null
     }
 
+    override fun onRequestPermissionsResult(
+        requestCode: Int,
+        permissions: Array<String>,
+        grantResults: IntArray,
+    ): Boolean {
+        if (requestCode != PERMISSION_REQUEST) return false
+
+        if (grantResults.any { it != android.content.pm.PackageManager.PERMISSION_GRANTED }) {
+            pickerPromise?.reject("E_PERMISSION_DENIED", "Required permission denied")
+            cleanup()
+            return true
+        }
+
+        currentActivity?.let { launch(it) }
+        return true
+    }
+
     override fun onNewIntent(intent: Intent?) {}
 }

package/index.d.ts

@@ -1,3 +1,7 @@
+/**
+ * Mediapicker Module
+ * All functions use options objects for better autocomplete and clarity.
+ */
 declare module 'rns-mediapicker' {
     export interface PickerResponse {
         uri: string;
@@ -16,7 +20,7 @@ declare module 'rns-mediapicker' {
          */
         pick(
             useCamera?: boolean,
-            mediaType?: 'image' | 'video' | 'both',
+            mediaType?: 'image' | 'video' | 'both' | 'audio',
             env?: 'front' | 'back' | string
         ): Promise<PickerResponse>;
     }

package/ios/FastMediaPicker.swift

@@ -1,20 +1,21 @@
 import AVFoundation
 import Photos
+import PhotosUI
 import UIKit
 import UniformTypeIdentifiers
 import React
 
 @objc(FastMediaPicker)
-// 1. Added UIAdaptivePresentationControllerDelegate to the class signature
-class FastMediaPicker: NSObject, UIImagePickerControllerDelegate, UINavigationControllerDelegate, UIAdaptivePresentationControllerDelegate, RCTBridgeModule {
+class FastMediaPicker: NSObject,
+                       UIImagePickerControllerDelegate,
+                       UINavigationControllerDelegate,
+                       UIAdaptivePresentationControllerDelegate,
+                       PHPickerViewControllerDelegate,
+                       UIDocumentPickerDelegate,
+                       RCTBridgeModule {
 
-    static func moduleName() -> String! {
-        return "FastMediaPicker"
-    }
-
-    static func requiresMainQueueSetup() -> Bool {
-        return true
-    }
+    static func moduleName() -> String! { return "FastMediaPicker" }
+    static func requiresMainQueueSetup() -> Bool { return true }
 
     private var resolve: RCTPromiseResolveBlock?
     private var reject: RCTPromiseRejectBlock?
@@ -29,136 +30,228 @@ class FastMediaPicker: NSObject, UIImagePickerControllerDelegate, UINavigationCo
     ) {
         self.resolve = resolve
         self.reject = reject
+        let typeLower = mediaType.lowercased()
 
         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
 
+            // 1. AUDIO (Document Picker)
+            if typeLower == "audio" {
+                let picker = UIDocumentPickerViewController(forOpeningContentTypes: [.audio])
+                picker.delegate = self
+                picker.allowsMultipleSelection = false
+                self.topMostViewController()?.present(picker, animated: true)
+                return
+            }
+
+            // 2. CAMERA
             if useCamera {
                 guard UIImagePickerController.isSourceTypeAvailable(.camera) else {
                     self.safeReject("E_CAMERA_UNAVAILABLE", "Camera not available")
                     return
                 }
+
+                let picker = UIImagePickerController()
+                picker.delegate = self
+                picker.presentationController?.delegate = self
                 picker.sourceType = .camera
-                if let env = env?.lowercased(), env == "front" {
+                picker.allowsEditing = false
+
+                if env?.lowercased() == "front" {
                     picker.cameraDevice = .front
                 }
-            } else {
-                picker.sourceType = .photoLibrary
+
+                if typeLower == "video" {
+                    picker.mediaTypes = [UTType.movie.identifier]
+                } else if typeLower == "image" {
+                    picker.mediaTypes = [UTType.image.identifier]
+                } else {
+                    picker.mediaTypes = [UTType.image.identifier, UTType.movie.identifier]
+                }
+
+                self.topMostViewController()?.present(picker, animated: true)
+                return
             }
 
-            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]
+            // 3. LIBRARY (PHPicker)
+            var config = PHPickerConfiguration()
+            config.selectionLimit = 1
+
+            if typeLower == "image" { config.filter = .images }
+            else if typeLower == "video" { config.filter = .videos }
+            else { config.filter = .any(of: [.images, .videos]) }
+
+            let picker = PHPickerViewController(configuration: config)
+            picker.delegate = self
+            picker.presentationController?.delegate = self
+            self.topMostViewController()?.present(picker, animated: true)
+        }
+    }
+
+    // MARK: - PHPicker
+    func picker(_ picker: PHPickerViewController, didFinishPicking results: [PHPickerResult]) {
+        picker.dismiss(animated: true)
+
+        guard let result = results.first else {
+            safeReject("E_CANCELLED", "User cancelled")
+            return
+        }
+
+        let provider = result.itemProvider
+
+        if provider.hasItemConformingToTypeIdentifier(UTType.movie.identifier) {
+            provider.loadFileRepresentation(forTypeIdentifier: UTType.movie.identifier) { [weak self] url, error in
+                guard let self = self else { return }
+                if let url = url {
+                    self.handlePickedVideo(url: url)
+                } else {
+                    self.safeReject("E_LOAD", error?.localizedDescription ?? "Video load failed")
+                }
             }
+            return
+        }
 
-            if let vc = self.topMostViewController() {
-                vc.present(picker, animated: true, completion: nil)
-            } else {
-                self.safeReject("E_NO_VC", "Could not find view controller")
+        if provider.canLoadObject(ofClass: UIImage.self) {
+            provider.loadObject(ofClass: UIImage.self) { [weak self] image, _ in
+                guard let self = self, let img = image as? UIImage else { return }
+                self.processPickedImage(img)
             }
         }
     }
 
-    // MARK: - Delegate Methods
-    
-    // Handles the "Cancel" button tap
-    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
-        picker.dismiss(animated: true) {
-            self.safeReject("E_CANCELLED", "User cancelled")
+    // MARK: - Document Picker (Audio)
+    func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+        guard let url = urls.first else {
+            safeReject("E_CANCELLED", "No file selected")
+            return
+        }
+
+        let access = url.startAccessingSecurityScopedResource()
+        defer { if access { url.stopAccessingSecurityScopedResource() } }
+
+        let ext = url.pathExtension.isEmpty ? "mp3" : 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)
+
+            DispatchQueue.main.async {
+                self.resolve?([
+                    "uri": fileURL.absoluteString,
+                    "type": "audio",
+                    "isAudio": true,
+                    "isVideo": false
+                ])
+                self.cleanupPromise()
+            }
+        } catch {
+            safeReject("E_AUDIO_COPY", error.localizedDescription)
         }
     }
 
-    // 3. Handles the swipe-down gesture dismissal
-    func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
-        self.safeReject("E_CANCELLED", "User cancelled via swipe")
+    func documentPickerWasCancelled(_ controller: UIDocumentPickerViewController) {
+        safeReject("E_CANCELLED", "User cancelled")
     }
 
-    func imagePickerController(_ picker: UIImagePickerController, didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey : Any]) {
+    // MARK: - UIImagePicker (Camera)
+    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) {
+            return
+        }
+
+        if let image = (info[.editedImage] as? UIImage) ?? (info[.originalImage] as? UIImage) {
             processPickedImage(image)
-        } else {
-            safeReject("E_NO_MEDIA", "Failed to retrieve media")
+            return
+        }
+
+        safeReject("E_NO_MEDIA", "Failed to retrieve media")
+    }
+
+    func imagePickerControllerDidCancel(_ picker: UIImagePickerController) {
+        picker.dismiss(animated: true) {
+            self.safeReject("E_CANCELLED", "User cancelled")
         }
     }
 
-    // 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)
-      }
-  }
+    // MARK: - Media Handlers
+    private func processPickedImage(_ image: UIImage) {
+        let fileURL = makeTempURL(ext: "jpg")
+
+        let format = UIGraphicsImageRendererFormat()
+        format.scale = image.scale
+        format.opaque = true
+
+        let renderer = UIGraphicsImageRenderer(size: image.size, format: format)
+        let output = renderer.image { ctx in
+            UIColor.white.setFill()
+            ctx.fill(CGRect(origin: .zero, size: image.size))
+            image.draw(at: .zero)
+        }
+
+        guard let data = output.jpegData(compressionQuality: 0.8) else {
+            safeReject("E_IMAGE_WRITE", "Image encoding failed")
+            return
+        }
+
+        do {
+            try data.write(to: fileURL)
+            DispatchQueue.main.async {
+                self.resolve?([
+                    "uri": fileURL.absoluteString,
+                    "width": image.size.width,
+                    "height": image.size.height,
+                    "type": "image",
+                    "isVideo": false
+                ])
+                self.cleanupPromise()
+            }
+        } catch {
+            safeReject("E_IMAGE_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()
+            DispatchQueue.main.async {
+                self.resolve?([
+                    "uri": fileURL.absoluteString,
+                    "width": dims.width,
+                    "height": dims.height,
+                    "type": "video",
+                    "isVideo": true
+                ])
+                self.cleanupPromise()
+            }
         } catch {
             safeReject("E_VIDEO_COPY", error.localizedDescription)
         }
     }
 
     // MARK: - Helpers
+    func presentationControllerDidDismiss(_ presentationController: UIPresentationController) {
+        safeReject("E_CANCELLED", "User cancelled via swipe")
+    }
+
     private func safeReject(_ code: String, _ message: String) {
-        self.reject?(code, message, nil)
-        cleanupPromise()
+        DispatchQueue.main.async {
+            self.reject?(code, message, nil)
+            self.cleanupPromise()
+        }
     }
 
     private func cleanupPromise() {
@@ -167,28 +260,29 @@ class FastMediaPicker: NSObject, UIImagePickerControllerDelegate, UINavigationCo
     }
 
     private func topMostViewController() -> UIViewController? {
-        let keyWindow = UIApplication.shared.connectedScenes
+        let window = UIApplication.shared.connectedScenes
             .compactMap { $0 as? UIWindowScene }
             .flatMap { $0.windows }
             .first { $0.isKeyWindow }
-        
-        var topController = keyWindow?.rootViewController
-        while let presented = topController?.presentedViewController {
-            topController = presented
+
+        var top = window?.rootViewController
+        while let presented = top?.presentedViewController {
+            top = presented
         }
-        return topController
+        return top
     }
 
     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())")
+        URL(fileURLWithPath: NSTemporaryDirectory(), isDirectory: true)
+            .appendingPathComponent("fastpicker-\(UUID().uuidString).\(ext)")
     }
 
     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) }
+        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))
+        return (abs(size.width), abs(size.height))
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-mediapicker",
-    "version": "0.0.8",
+    "version": "0.1.0",
     "description": "High-performance React Native module for picking media on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",
@@ -20,7 +20,8 @@
         "url": "git+https://github.com/raiidr/rns-mediapicker.git"
     },
     "scripts": {
-        "p": "npm publish --access public"
+        "p": "npm publish --access public",
+        "i": "npm publish --access public"
     },
     "keywords": [
         "react-native",

package/withMediaPicker.js

@@ -20,6 +20,7 @@ const withAndroidConfig = (config) => {
         const permissions = [
             { name: 'android.permission.CAMERA' },
             { name: 'android.permission.READ_MEDIA_IMAGES' },
+            { name: 'android.permission.READ_MEDIA_AUDIO' },
             { name: 'android.permission.READ_MEDIA_VIDEO' },
             { name: 'android.permission.READ_EXTERNAL_STORAGE', maxSdkVersion: '32' },
         ];
@@ -63,6 +64,10 @@ const withAndroidConfig = (config) => {
                 action: [{ $: { 'android:name': 'android.intent.action.OPEN_DOCUMENT' } }],
                 data: [{ $: { 'android:mimeType': 'video/*' } }],
             },
+            {
+                action: [{ $: { 'android:name': 'android.intent.action.GET_CONTENT' } }],
+                data: [{ $: { 'android:mimeType': 'audio/*' } }],
+            },
         ];
 
         intents.forEach((intent) => {