rns-mediapicker 0.1.3 → 3.0.0

package/README.md

@@ -1,7 +1,7 @@
 # 🎵 / 🖼️ / 🎥 rns-mediapicker
 
 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.
+Supports **audio, image, video, `.adp` project files** from **camera or library**, automatic JPEG compression, EXIF-safe dimensions, and iterative quality targeting.
 
 ---
 
@@ -29,6 +29,7 @@ Add the plugin to your `app.json` or `app.config.js`.
 This automatically configures:
 
 - iOS permissions (`Info.plist`)
+- iOS `.adp` custom UTType declaration
 - Android intent queries
 - Android `FileProvider`
 
@@ -44,87 +45,201 @@ This automatically configures:
 
 ## 🧑‍💻 Usage
 
+### Pick from library (image or video)
+
 ```js
 import MediaPicker from 'rns-mediapicker';
 
-const pickMedia = async () => {
-  try {
-    const result = await MediaPicker.pick(
-      false,    // useCamera: true = camera, false = picker
-      'both',   // mediaType: 'audio' | 'image' | 'video' | 'both'
-      'back'    // env: 'front' | 'back' (camera only)
-    );
-
-    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 cancelled picker');
-    } else {
+const result = await MediaPicker.pick(
+  false,    // useCamera
+  'both',   // mediaType
+  'back',   // env
+  0         // targetKB — 0 means no compression
+);
+
+console.log(result.uri);    // file:///...
+console.log(result.type);   // 'image' | 'video' | 'audio' | 'adp'
+console.log(result.width);  // number (0 for audio/adp)
+console.log(result.height); // number (0 for audio/adp)
+console.log(result.size);   // KB (images only — field is absent for video/audio/adp)
+console.log(result.isVideo);
+console.log(result.isAudio);
+```
+
+---
+
+### Open camera
+
+```js
+// Photo with back camera
+const result = await MediaPicker.pick(true, 'image', 'back', 0);
+
+// Video with front camera
+const result = await MediaPicker.pick(true, 'video', 'front', 0);
+```
+
+---
+
+### Pick audio
+
+```js
+const result = await MediaPicker.pick(false, 'audio', 'back', 0);
+
+console.log(result.uri);     // file:///...
+console.log(result.type);    // 'audio'
+console.log(result.isAudio); // true
+```
+
+---
+
+### Pick with image compression (`targetKB`)
+
+Compresses the image iteratively until it fits within the target size.  
+Quality steps down by 10% per iteration (from 100% → minimum 10%).
+
+```js
+// Pick an image and compress to max 200KB
+const result = await MediaPicker.pick(false, 'image', 'back', 200);
+
+console.log(result.size); // Actual size in KB after compression
+console.log(result.uri);  // Compressed JPEG file URI
+```
+
+> `targetKB = 0` disables compression and returns the full-quality image.
+
+---
+
+### Pick a `.adp` project file
+
+`.adp` is a custom Audipella project file format. This opens the file browser  
+filtered to `.adp` files only (iOS) or a general file browser (Android).
+
+```js
+const result = await MediaPicker.pick(false, 'adp', 'back', 0);
+
+console.log(result.uri);  // file:///...path/to/file.adp
+console.log(result.type); // 'adp'
+```
+
+---
+
+### Error handling
+
+```js
+try {
+  const result = await MediaPicker.pick(false, 'image', 'back', 0);
+} catch (error) {
+  switch (error.code) {
+    case 'E_CANCELLED':
+      console.log('User cancelled');
+      break;
+    case 'E_PERMISSION_DENIED':
+      console.log('Permission denied');
+      break;
+    case 'E_CAMERA_UNAVAILABLE':
+      console.log('Camera not available on this device');
+      break;
+    case 'E_PROCESS':
+      console.log('Failed to process media:', error.message);
+      break;
+    default:
       console.error('Picker error:', error.message);
-    }
   }
-};
+}
 ```
 
 ---
 
 ## 🧩 API Reference
 
-### `pick(useCamera, mediaType, env)`
+### `pick(useCamera, mediaType, env, targetKB)`
 
-| Parameter  | Type     | Description |
-|-----------|----------|-------------|
-| useCamera | boolean  | `true` opens the camera, `false` opens the media picker |
-| mediaType | string   | `'audio'`, `'image'`, `'video'`, or `'both'` |
-| env       | string   | `'front'` or `'back'` camera (camera mode only) |
+| Parameter   | Type     | Default    | Description |
+|-------------|----------|------------|-------------|
+| `useCamera` | boolean  | —          | `true` opens the camera, `false` opens the file/media picker |
+| `mediaType` | string   | —          | `'image'`, `'video'`, `'both'`, `'audio'`, or `'adp'` |
+| `env`       | string   | `'back'`   | `'front'` or `'back'` — camera only, best-effort on Android |
+| `targetKB`  | number   | `0`        | Max image size in KB. `0` = no compression. Images only |
+
+All four parameters must be passed. Use `0` for `targetKB` to disable compression, and `'back'` for `env` when camera direction is not relevant.
 
 ---
 
 ## 📦 Response Object
 
-```js
+```ts
 {
-  uri: string;       // Local file URI
-  width: number;     // Media width (0 for audio)
-  height: number;    // Media height (0 for audio)
-  type: string;      // 'image' | 'video' | 'audio'
-  isVideo: boolean;  // Helper flag
-  isAudio: boolean;  // Helper flag
+  uri: string;       // Local file URI (file://...)
+  width: number;     // Width in pixels (0 for audio and adp)
+  height: number;    // Height in pixels (0 for audio and adp)
+  size?: number;     // File size in KB — present for images only, absent for video/audio/adp
+  type: 'image' | 'video' | 'audio' | 'adp';
+  isVideo: boolean;
+  isAudio: boolean;
 }
 ```
 
 ---
 
+## 🗂️ Media Type Reference
+
+| `mediaType` | Opens | Returns |
+|-------------|-------|---------|
+| `'image'`   | Photo library / camera | `type: 'image'` |
+| `'video'`   | Video library / camera | `type: 'video'` |
+| `'both'`    | Photo + video library / camera | `type: 'image'` or `'video'` |
+| `'audio'`   | File browser (audio files) | `type: 'audio'` |
+| `'adp'`     | File browser (`.adp` files on iOS; all files on Android) | `type: 'adp'` |
+
+---
+
+## 🚨 Error Codes
+
+| Code | Description |
+|------|-------------|
+| `E_CANCELLED` | User dismissed the picker or cancelled |
+| `E_PERMISSION_DENIED` | Camera or storage permission denied |
+| `E_NOT_PERMISSION_AWARE` | Android activity does not implement `PermissionAwareActivity` |
+| `E_CAMERA_UNAVAILABLE` | Device has no camera (iOS) |
+| `E_NO_ACTIVITY` | Android activity not found |
+| `E_NO_URI` | No media URI returned from picker |
+| `E_PROCESS` | Failed to decode, compress, or copy the file |
+| `E_AUDIO_COPY` | Failed to copy audio/adp file to temp location |
+| `E_VIDEO_COPY` | Failed to copy video file to temp location |
+| `E_IMAGE_WRITE` | Failed to encode or write image to disk |
+| `E_LOAD` | Failed to load media from PHPicker (iOS) |
+
+---
+
 ## ✨ Features
 
-- 🎵 Audio / 🖼️ Image / 🎥 Video support  
-- 📷 Camera and 📁 Library selection  
-- 🎬 Camera video capture (Android & iOS)  
-- 🗜️ Automatic JPEG compression  
-- ⬜ White-background flattening for transparent images  
-- 🔄 EXIF-safe rotation and accurate dimensions  
-- 📂 Scoped-storage safe temporary files  
-- 🤖 Android 11+ intent queries handled automatically  
-- 🔐 Android `FileProvider` preconfigured  
-- 🍎 iOS swipe-to-dismiss cancellation handling  
+- 🖼️ Image / 🎥 Video / 🎵 Audio / 📁 `.adp` project file support
+- 📷 Camera and 📁 Library selection
+- 🎬 Camera video capture (Android & iOS)
+- 🗜️ Iterative JPEG compression with `targetKB` target
+- 🔄 EXIF-safe rotation and accurate dimensions
+- 📂 Scoped-storage safe temporary files
+- 🤖 Android 11+ intent queries handled automatically
+- 🔐 Android `FileProvider` preconfigured
+- 🍎 iOS swipe-to-dismiss cancellation handling
+- 🍎 iOS `.adp` UTType auto-registered via Expo plugin
 - 🧹 Clean promise lifecycle (no leaks)
 
 ---
 
 ## 📝 Notes
 
-- All returned files are copied into the app’s **temporary cache directory**
-- Audio files preserve original encoding
+- All returned files are copied into the app's **temporary cache directory**
+- Audio files preserve their original encoding and extension
+- `.adp` files are copied as-is — no processing applied
+- `targetKB` compression only applies to **images**, not video or audio
+- The `size` field is only present in the response for images; it is absent (not `0`) for video, audio, and adp results
 - Front camera selection is **best-effort** on Android
+- On Android, `.adp` picker opens a general file browser since Android has no built-in MIME type for `.adp`; the file is identified by its extension after selection
 - No external native dependencies required
 
 ---
 
 ## 📄 License
 
-MIT
+MIT

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

@@ -8,6 +8,7 @@ import android.media.ExifInterface
 import android.media.MediaMetadataRetriever
 import android.net.Uri
 import android.os.Build
+import android.provider.OpenableColumns
 import android.provider.MediaStore
 import android.webkit.MimeTypeMap
 import androidx.core.content.FileProvider
@@ -30,11 +31,12 @@ class FastMediaPickerModule(
     private var pendingFrontCamera = false
     private var pendingUseCamera = false
     private var pendingMediaType: String? = null
+    private var pendingTargetKB: Int = 0  // ← new
+
 
     companion object {
         private const val PICKER_REQUEST_CODE = 4123
         private const val PERMISSION_REQUEST = 9123
-        private const val JPEG_QUALITY = 85
     }
 
     init {
@@ -52,10 +54,11 @@ class FastMediaPickerModule(
         useCamera: Boolean,
         mediaType: String,
         env: String?,
+        targetKB: Int,   // ← matches iOS pick:mediaType:env:targetKB:resolver:rejecter:
         promise: Promise,
     ) {
         val activity =
-            currentActivity ?: run {
+            reactApplicationContext.currentActivity ?: run {
                 promise.reject("E_NO_ACTIVITY", "Activity not found")
                 return
             }
@@ -65,6 +68,8 @@ class FastMediaPickerModule(
         pendingUseCamera = useCamera
         pendingMediaType = mediaType.lowercase()
         pendingFrontCamera = env?.lowercase() == "front"
+        pendingTargetKB = targetKB  // ← new
+
 
         val permissions = mutableListOf<String>()
         if (useCamera) {
@@ -104,26 +109,56 @@ class FastMediaPickerModule(
         activity: Activity,
         type: String,
     ) {
+
+        // 1a. ADP: Custom project file — use */* so the file manager shows all files,
+// Android has no built-in MIME type for .adp so we can't filter more tightly here.
+if (type == "adp") {
+    val intent =
+        Intent(Intent.ACTION_GET_CONTENT).apply {
+            addCategory(Intent.CATEGORY_OPENABLE)
+            this.type = "*/*"
+            putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)
+        }
+    activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
+    return
+}
+        // 1. AUDIO: Use GET_CONTENT but without the chooser for faster return
         if (type == "audio") {
             val intent =
                 Intent(Intent.ACTION_GET_CONTENT).apply {
                     addCategory(Intent.CATEGORY_OPENABLE)
                     this.type = "audio/*"
+                    // Some devices honor this to disable multi-select UI
+                    putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)
                 }
-            activity.startActivityForResult(Intent.createChooser(intent, "Select Audio"), PICKER_REQUEST_CODE)
+            activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
             return
         }
 
+        // 2. MODERN PHOTO PICKER (Android 13+):
+        // We set the limit to 1 explicitly.
         if (Build.VERSION.SDK_INT >= 33) {
-            val intent = Intent(MediaStore.ACTION_PICK_IMAGES)
+            val intent =
+                Intent(MediaStore.ACTION_PICK_IMAGES).apply {
+                    // This is the key for Android 13+ to return on single tap
+                    if (type == "image") {
+                        this.type = "image/*"
+                    } else if (type == "video") {
+                        this.type = "video/*"
+                    }
+                    // Setting limit to 1 via the extra usually triggers auto-done on click
+                    // Note: Standard ACTION_PICK_IMAGES is single-select by default
+                    // unless EXTRA_PICK_IMAGES_MAX is set.
+                }
             activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
             return
         }
 
+        // 3. FALLBACK (Older Androids):
+        // Avoid Intent.createChooser to bypass the extra "Open with..." dialog
         val fallback =
             Intent(Intent.ACTION_GET_CONTENT).apply {
                 addCategory(Intent.CATEGORY_OPENABLE)
-                // FIXED: Explicitly use this.type to refer to Intent property
                 this.type =
                     when (type) {
                         "video" -> "video/*"
@@ -133,8 +168,9 @@ class FastMediaPickerModule(
                 if (type == "both") {
                     putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
                 }
+                putExtra(Intent.EXTRA_ALLOW_MULTIPLE, false)
             }
-        activity.startActivityForResult(Intent.createChooser(fallback, "Select Media"), PICKER_REQUEST_CODE)
+        activity.startActivityForResult(fallback, PICKER_REQUEST_CODE)
     }
 
     private fun launchCamera(
@@ -168,7 +204,7 @@ class FastMediaPickerModule(
     }
 
     override fun onActivityResult(
-        activity: Activity?,
+        activity: Activity,
         requestCode: Int,
         resultCode: Int,
         data: Intent?,
@@ -197,54 +233,87 @@ class FastMediaPickerModule(
         resultCode: Int,
         data: Intent?,
     ) {
-        onActivityResult(currentActivity, requestCode, resultCode, data)
+        reactApplicationContext.currentActivity?.let { activity ->
+            onActivityResult(activity, requestCode, resultCode, data)
+        }
     }
 
     private fun processMedia(uri: Uri) {
-        val resolver = reactContext.contentResolver
-        val mime = resolver.getType(uri) ?: "image/jpeg"
-
-        try {
+        // Mirrors iOS: heavy processing (decode, compress, copy) happens off the main thread.
+        // Only the promise resolve/reject lands back via the RN bridge.
+        Thread {
+            val resolver = reactContext.contentResolver
+            val mime = resolver.getType(uri) ?: "image/jpeg"
+            val displayName = getDisplayName(uri)
+    
+            try {
+
+                val isAdpFile = uri.toString().endsWith(".adp", ignoreCase = true) ||
+                mime.equals("application/adp", ignoreCase = true) ||
+                displayName.endsWith(".adp", ignoreCase = true)
+            
             when {
-                mime.startsWith("audio") -> {
-                    val ext = MimeTypeMap.getSingleton().getExtensionFromMimeType(mime) ?: "mp3"
-                    val file = createTempFile(ext)
+                isAdpFile -> {
+                    val file = createTempFile("adp")
                     resolver.openInputStream(uri)?.use { it.copyTo(FileOutputStream(file)) }
-                    resolveResult(Uri.fromFile(file).toString(), false, true, 0, 0)
+                    resolveResult(Uri.fromFile(file).toString(), false, false, 0, 0, typeOverride = "adp")
                 }
 
-                mime.startsWith("video") -> {
-                    val file = createTempFile("mp4")
-                    resolver.openInputStream(uri)?.use { it.copyTo(FileOutputStream(file)) }
-
-                    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)
-                }
-
-                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,
-                    )
+                    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)
+                    }
+    
+                    mime.startsWith("video") -> {
+                        val file = createTempFile("mp4")
+                        resolver.openInputStream(uri)?.use { it.copyTo(FileOutputStream(file)) }
+    
+                        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)
+                    }
+    
+                    else -> {
+                        val file = createTempFile("jpg")
+                        val bitmap = BitmapFactory.decodeStream(resolver.openInputStream(uri))
+                        val rotated = rotateIfNeeded(bitmap, uri)
+    
+                        var quality = 100
+                        var outStream = java.io.ByteArrayOutputStream()
+                        rotated.compress(Bitmap.CompressFormat.JPEG, quality, outStream)
+    
+                        if (pendingTargetKB > 0) {
+                            val targetBytes = pendingTargetKB * 1024
+                            while (outStream.size() > targetBytes && quality > 10) {
+                                quality -= 10
+                                outStream = java.io.ByteArrayOutputStream()
+                                rotated.compress(Bitmap.CompressFormat.JPEG, quality, outStream)
+                            }
+                        }
+    
+                        FileOutputStream(file).use { it.write(outStream.toByteArray()) }
+                        resolveResult(
+                            Uri.fromFile(file).toString(),
+                            false,
+                            false,
+                            rotated.width,
+                            rotated.height,
+                            outStream.size() / 1024,
+                        )
+                    }
                 }
+            } catch (e: Exception) {
+                pickerPromise?.reject("E_PROCESS", e.message)
+            } finally {
+                cleanup()
             }
-        } catch (e: Exception) {
-            pickerPromise?.reject("E_PROCESS", e.message)
-        } finally {
-            cleanup()
-        }
+        }.start()
     }
 
     private fun rotateIfNeeded(
@@ -271,36 +340,45 @@ class FastMediaPickerModule(
         isAudio: Boolean,
         w: Int,
         h: Int,
+        sizeKB: Int = 0,
+        typeOverride: String? = null,   // ← for custom types like "adp"
     ) {
         pickerPromise?.resolve(
             Arguments.createMap().apply {
                 putString("uri", uri)
                 putBoolean("isVideo", isVideo)
                 putBoolean("isAudio", isAudio)
-                putInt("width", w)
-                putInt("height", h)
-                putString(
-                    "type",
-                    if (isAudio) {
-                        "audio"
-                    } else if (isVideo) {
-                        "video"
-                    } else {
-                        "image"
-                    },
-                )
+                putDouble("width", w.toDouble())
+                putDouble("height", h.toDouble())
+                putString("type", typeOverride ?: if (isAudio) "audio" else if (isVideo) "video" else "image")
+                if (!isAudio && !isVideo && sizeKB > 0) putInt("size", sizeKB)
             },
         )
     }
 
     private fun createTempFile(ext: String) = File(reactContext.cacheDir, "fast-${UUID.randomUUID()}.$ext")
 
+    private fun getDisplayName(uri: Uri): String {
+        return runCatching {
+            reactContext.contentResolver.query(uri, arrayOf(OpenableColumns.DISPLAY_NAME), null, null, null)
+                ?.use { cursor ->
+                    val nameIndex = cursor.getColumnIndex(OpenableColumns.DISPLAY_NAME)
+                    if (nameIndex >= 0 && cursor.moveToFirst()) {
+                        cursor.getString(nameIndex) ?: ""
+                    } else {
+                        ""
+                    }
+                } ?: ""
+        }.getOrDefault("")
+    }
+
     private fun cleanup() {
         pickerPromise = null
         cameraCaptureUri = null
         pendingFrontCamera = false
         pendingUseCamera = false
         pendingMediaType = null
+        pendingTargetKB = 0  // ← new
     }
 
     override fun onRequestPermissionsResult(
@@ -316,9 +394,11 @@ class FastMediaPickerModule(
             return true
         }
 
-        currentActivity?.let { launch(it) }
+        reactApplicationContext.currentActivity?.let { activity ->
+            launch(activity)
+        }
         return true
     }
 
-    override fun onNewIntent(intent: Intent?) {}
+    override fun onNewIntent(intent: Intent) {}
 }

package/index.d.ts

@@ -7,21 +7,25 @@ declare module 'rns-mediapicker' {
         uri: string;
         width: number;
         height: number;
-        type: 'image' | 'video';
+        size: number;
+        type: 'image' | 'video' | 'audio' | 'adp';  // ← adp added
         isVideo: boolean;
+        isAudio: boolean;
     }
 
     export interface MediaPickerType {
         /**
          * Launch the media picker or camera.
          * @param useCamera Set to true to open the camera directly.
-         * @param mediaType Specify 'image', 'video', or 'both'.
+         * @param mediaType Specify 'image', 'video', 'both', or 'audio'.
          * @param env Use 'front' or 'back'.
+         * @param targetKB Max file size in KB (for image compression).
          */
         pick(
             useCamera?: boolean,
-            mediaType?: 'image' | 'video' | 'both' | 'audio',
-            env?: 'front' | 'back' | string
+            mediaType?: 'image' | 'video' | 'both' | 'audio' | 'adp',  // ← adp added
+            env?: 'front' | 'back' | string,
+            targetKB?: number
         ): Promise<PickerResponse>;
     }
 

package/index.js

@@ -5,17 +5,25 @@ const NativeModule = NativeModules.FastMediaPicker
     : TurboModuleRegistry.get('FastMediaPicker');
 
 const MediaPicker = {
-    pick: async (useCamera = false, mediaType = 'both', env = 'back') => {
+    /**
+     * @param {boolean} useCamera 
+     * @param {'image' | 'video' | 'both' | 'audio'} mediaType 
+     * @param {'front' | 'back'} env 
+     * @param {number} targetKB - Max size in KB (0 for no compression)
+     */
+    pick: async (useCamera = false, mediaType = 'both', env = 'back', targetKB = 0) => {
         if (!NativeModule) {
             throw new Error("MediaPicker: Native module not found.");
         }
 
-        // Match the signature: pick(boolean, String, String)
-        // React Native automatically injects the promise as the last argument
+        const validTypes = ['image', 'video', 'both', 'audio', 'adp'];  // ← adp added
+        const safeMediaType = validTypes.includes(mediaType) ? mediaType : 'both';
+
         return await NativeModule.pick(
             !!useCamera,
-            mediaType || 'both',
-            env || 'back'
+            safeMediaType,          // ← was: mediaType || 'both' (didn't validate)
+            env || 'back',
+            targetKB || 0
         );
     }
 };

package/ios/FastMediaPicker.m

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

package/ios/FastMediaPicker.swift

@@ -1,38 +1,55 @@
 import AVFoundation
 import Photos
 import PhotosUI
+import React
 import UIKit
 import UniformTypeIdentifiers
-import React
 
 @objc(FastMediaPicker)
 class FastMediaPicker: NSObject,
-                       UIImagePickerControllerDelegate,
-                       UINavigationControllerDelegate,
-                       UIAdaptivePresentationControllerDelegate,
-                       PHPickerViewControllerDelegate,
-                       UIDocumentPickerDelegate,
-                       RCTBridgeModule {
+    UIImagePickerControllerDelegate,
+    UINavigationControllerDelegate,
+    UIAdaptivePresentationControllerDelegate,
+    PHPickerViewControllerDelegate,
+    UIDocumentPickerDelegate,
+    RCTBridgeModule
+{
 
     static func moduleName() -> String! { return "FastMediaPicker" }
     static func requiresMainQueueSetup() -> Bool { return true }
 
     private var resolve: RCTPromiseResolveBlock?
     private var reject: RCTPromiseRejectBlock?
+    // Added to store the target size across picker callbacks
+    private var targetKB: Int = 0
 
-    @objc(pick:mediaType:env:resolver:rejecter:)
+    @objc(pick:mediaType:env:targetKB:resolver:rejecter:)
     func pick(
         _ useCamera: Bool,
         mediaType: String,
         env: String?,
+        targetKB: Int,
         resolver resolve: @escaping RCTPromiseResolveBlock,
         rejecter reject: @escaping RCTPromiseRejectBlock
     ) {
         self.resolve = resolve
         self.reject = reject
+        self.targetKB = targetKB
         let typeLower = mediaType.lowercased()
 
         DispatchQueue.main.async {
+            // 1a. ADP (Custom project file)
+            if typeLower == "adp" {
+                // UTType(filenameExtension:) resolves our custom .adp type at runtime.
+                // Falls back to .data (generic binary) if not declared in Info.plist yet.
+                let adpType = UTType(filenameExtension: "adp") ?? .data
+                let picker = UIDocumentPickerViewController(forOpeningContentTypes: [adpType])
+                picker.delegate = self
+                picker.allowsMultipleSelection = false
+                self.topMostViewController()?.present(picker, animated: true)
+                return
+            }
+
             // 1. AUDIO (Document Picker)
             if typeLower == "audio" {
                 let picker = UIDocumentPickerViewController(forOpeningContentTypes: [.audio])
@@ -75,9 +92,13 @@ class FastMediaPicker: NSObject,
             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]) }
+            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
@@ -101,7 +122,8 @@ class FastMediaPicker: NSObject,
 
         // Check for Video
         if provider.hasItemConformingToTypeIdentifier(UTType.movie.identifier) {
-            provider.loadFileRepresentation(forTypeIdentifier: UTType.movie.identifier) { [weak self] url, error in
+            provider.loadFileRepresentation(forTypeIdentifier: UTType.movie.identifier) {
+                [weak self] url, error in
                 if let url = url {
                     self?.handlePickedVideo(url: url)
                 } else {
@@ -122,12 +144,14 @@ class FastMediaPicker: NSObject,
             }
             return
         }
-        
+
         safeReject("E_NO_MEDIA", "Unsupported media type")
     }
 
     // MARK: - Document Picker (Audio)
-    func documentPicker(_ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]) {
+    func documentPicker(
+        _ controller: UIDocumentPickerViewController, didPickDocumentsAt urls: [URL]
+    ) {
         guard let url = urls.first else {
             safeReject("E_CANCELLED", "No file selected")
             return
@@ -145,12 +169,22 @@ class FastMediaPicker: NSObject,
             }
             try FileManager.default.copyItem(at: url, to: fileURL)
 
-            self.safeResolve([
-                "uri": fileURL.absoluteString,
-                "type": "audio",
-                "isAudio": true,
-                "isVideo": false
-            ])
+            // Distinguish .adp project files from regular audio by extension
+            if ext == "adp" {
+                self.safeResolve([
+                    "uri": fileURL.absoluteString,
+                    "type": "adp",
+                    "isAudio": false,
+                    "isVideo": false,
+                ])
+            } else {
+                self.safeResolve([
+                    "uri": fileURL.absoluteString,
+                    "type": "audio",
+                    "isAudio": true,
+                    "isVideo": false,
+                ])
+            }
         } catch {
             safeReject("E_AUDIO_COPY", error.localizedDescription)
         }
@@ -161,8 +195,10 @@ class FastMediaPicker: NSObject,
     }
 
     // MARK: - UIImagePicker (Camera)
-    func imagePickerController(_ picker: UIImagePickerController,
-                               didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]) {
+    func imagePickerController(
+        _ picker: UIImagePickerController,
+        didFinishPickingMediaWithInfo info: [UIImagePickerController.InfoKey: Any]
+    ) {
         picker.dismiss(animated: true)
 
         if let mediaURL = info[.mediaURL] as? URL {
@@ -188,21 +224,38 @@ class FastMediaPicker: NSObject,
     private func processPickedImage(_ image: UIImage) {
         let fileURL = makeTempURL(ext: "jpg")
 
-        // Standardize image orientation and convert to Data
-        guard let data = image.jpegData(compressionQuality: 0.8) else {
+        // 1. Initial attempt at high quality (Standardize orientation automatically via jpegData)
+        var compression: CGFloat = 1.0
+        guard var data = image.jpegData(compressionQuality: compression) else {
             safeReject("E_IMAGE_WRITE", "Image encoding failed")
             return
         }
 
+        // 2. Iterative compression logic
+        if targetKB > 0 {
+            let targetBytes = targetKB * 1024
+
+            // If the initial file is already larger than target, reduce quality
+            if data.count > targetBytes {
+                while data.count > targetBytes && compression > 0.1 {
+                    compression -= 0.1
+                    if let compressedData = image.jpegData(compressionQuality: compression) {
+                        data = compressedData
+                    }
+                }
+            }
+        }
+
         do {
             try data.write(to: fileURL)
             self.safeResolve([
                 "uri": fileURL.absoluteString,
                 "width": image.size.width,
                 "height": image.size.height,
+                "size": data.count / 1024,  // Size in KB
                 "type": "image",
                 "isAudio": false,
-                "isVideo": false
+                "isVideo": false,
             ])
         } catch {
             safeReject("E_IMAGE_WRITE", error.localizedDescription)
@@ -227,7 +280,7 @@ class FastMediaPicker: NSObject,
                 "height": dims.height,
                 "type": "video",
                 "isAudio": false,
-                "isVideo": true
+                "isVideo": true,
             ])
         } catch {
             safeReject("E_VIDEO_COPY", error.localizedDescription)
@@ -284,4 +337,4 @@ class FastMediaPicker: NSObject,
         let size = track.naturalSize.applying(track.preferredTransform)
         return (abs(size.width), abs(size.height))
     }
-}
+}

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "rns-mediapicker",
-    "version": "0.1.3",
+    "version": "3.0.0",
     "description": "High-performance React Native module for picking media on Android and iOS.",
     "main": "index.js",
     "types": "index.d.ts",

package/withMediaPicker.js

@@ -138,6 +138,28 @@ const withIosConfig = (config) => {
             plist.NSMicrophoneUsageDescription ||
             'Allow access to your microphone when recording videos.';
 
+        // Register .adp as a known custom type so UIDocumentPickerViewController
+        // can filter to it exclusively instead of falling back to showing all files.
+        const adpTypeIdentifier = 'com.audipella.adp';
+        const existingImports = plist.UTImportedTypeDeclarations || [];
+        const alreadyDeclared = existingImports.some(
+            (t) => t.UTTypeIdentifier === adpTypeIdentifier
+        );
+
+        if (!alreadyDeclared) {
+            plist.UTImportedTypeDeclarations = [
+                ...existingImports,
+                {
+                    UTTypeIdentifier: adpTypeIdentifier,
+                    UTTypeDescription: 'Audipella Project',
+                    UTTypeConformsTo: ['public.data'],
+                    UTTypeTagSpecification: {
+                        'public.filename-extension': ['adp'],
+                    },
+                },
+            ];
+        }
+
         return config;
     });
 };