rns-mediapicker 0.0.4 → 0.0.6

package/README.md

@@ -52,6 +52,8 @@ pick(useCamera, mediaType, env)
 
 ```bash
 response-object
+```
+```js
 {
   uri: string;      // path to the processed file
   width: number;    // media width
@@ -59,8 +61,11 @@ response-object
   type: string;     // 'image' or 'video'
   isVideo: boolean; // helper flag
 }
-
--features-included
+```
+```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.

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

@@ -1,5 +1,6 @@
 package com.rnsmediapicker
 
+import android.Manifest
 import android.app.Activity
 import android.content.Intent
 import android.graphics.*
@@ -27,10 +28,12 @@ class FastMediaPickerModule(
     private var pickerPromise: Promise? = null
     private var cameraCaptureUri: Uri? = null
     private var pendingFrontCamera = false
+    private var pendingUseCamera = false
+    private var pendingMediaType: String? = null
 
     companion object {
         private const val PICKER_REQUEST_CODE = 4123
-        private const val CAMERA_PERMISSION_REQUEST = 9123
+        private const val PERMISSION_REQUEST = 9123
         private const val MAX_IMAGE_SIZE = 1200
         private const val JPEG_QUALITY = 85
     }
@@ -41,31 +44,13 @@ class FastMediaPickerModule(
 
     override fun getName(): String = "FastMediaPicker"
 
-    // -------------------- REQUIRED EVENT CONTRACT --------------------
+    @ReactMethod fun addListener(eventName: String) {}
 
-    @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) {
-        }
-    }
+    @ReactMethod fun removeListeners(count: Int) {}
 
     // -------------------- PUBLIC API --------------------
 
-    @ReactMethod
+@ReactMethod
     fun pick(
         useCamera: Boolean,
         mediaType: String,
@@ -74,43 +59,126 @@ class FastMediaPickerModule(
     ) {
         val activity =
             currentActivity ?: run {
-                promise.reject("E_ACTIVITY_DOES_NOT_EXIST", "Activity doesn't exist")
+                promise.reject("E_NO_ACTIVITY", "Activity not found")
                 return
             }
 
         cleanup()
         pickerPromise = promise
+        pendingUseCamera = useCamera
+        pendingMediaType = mediaType
         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)
+        val permissions = mutableListOf<String>()
+
+        if (useCamera) {
+            // Camera always needs permission
+            permissions.add(Manifest.permission.CAMERA)
+        } else {
+            // GALLERY LOGIC:
+            // Android 13 (API 33) and above use the Photo Picker which REQUIRES NO PERMISSIONS.
+            // We only request storage permissions for older devices (API 32 and below).
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.TIRAMISU) {
+                permissions.add(Manifest.permission.READ_EXTERNAL_STORAGE)
+            }
+        }
+
+        // Filter out permissions that are already granted
+        val missing = permissions.filter {
+            activity.checkSelfPermission(it) != android.content.pm.PackageManager.PERMISSION_GRANTED
+        }
+
+        if (missing.isNotEmpty()) {
+            val pa = activity as? PermissionAwareActivity ?: run {
+                promise.reject("E_NOT_PERMISSION_AWARE", "Activity not PermissionAware")
+                cleanup()
+                return
+            }
+
+            pa.requestPermissions(
+                missing.toTypedArray(),
+                PERMISSION_REQUEST,
+                this,
+            )
+            return
+        }
+
+        // All permissions granted (or none needed), launch the picker/camera
+        launch(activity)
+    }
+
+// Android 14 (API 34+) introduces Partial Access
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.UPSIDE_DOWN_CAKE) {
+            permissions.add(Manifest.permission.READ_MEDIA_IMAGES)
+            permissions.add(Manifest.permission.READ_MEDIA_VIDEO)
+            permissions.add(Manifest.permission.READ_MEDIA_VISUAL_USER_SELECTED)
+        }
+// Android 13 (API 33)
+        else if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.TIRAMISU) {
+            if (mediaType == "video") {
+                permissions.add(Manifest.permission.READ_MEDIA_VIDEO)
+            } else if (mediaType == "image") {
+                permissions.add(Manifest.permission.READ_MEDIA_IMAGES)
             } else {
-                launchPicker(activity, mediaType.lowercase())
+                permissions.add(Manifest.permission.READ_MEDIA_IMAGES)
+                permissions.add(Manifest.permission.READ_MEDIA_VIDEO)
             }
-        } catch (e: Exception) {
-            promise.reject("E_LAUNCH_FAILED", e.message)
+        }
+// Android 12 and below
+        else {
+            permissions.add(Manifest.permission.READ_EXTERNAL_STORAGE)
+        }
+
+        val missing =
+            permissions.filter {
+                activity.checkSelfPermission(it) !=
+                    android.content.pm.PackageManager.PERMISSION_GRANTED
+            }
+
+        if (missing.isNotEmpty()) {
+            val pa =
+                activity as? PermissionAwareActivity ?: run {
+                    promise.reject("E_NOT_PERMISSION_AWARE", "Activity not PermissionAware")
+                    cleanup()
+                    return
+                }
+
+            pa.requestPermissions(
+                missing.toTypedArray(),
+                PERMISSION_REQUEST,
+                this,
+            )
+            return
+        }
+
+        launch(activity)
+    }
+
+    private fun launch(activity: Activity) {
+        if (pendingUseCamera) {
+            launchCamera(activity, pendingFrontCamera)
+        } else {
+            launchPicker(activity, pendingMediaType ?: "image")
+        }
+    }
+
+    // -------------------- 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 --------------------
@@ -119,51 +187,60 @@ class FastMediaPickerModule(
         activity: Activity,
         type: String,
     ) {
+        // 1. Try the Modern Photo Picker (Android 13+ or backported to 11+)
+        // We check for the action string directly to handle backported devices
         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 -> "*/*"
-                        }
+            Intent("android.provider.action.PICK_IMAGES").apply {
+                when (type) {
+                    "video" -> this.type = "video/*"
+                    "image" -> this.type = "image/*"
+                    // For 'both', we leave the type null or specify multiple if needed
                 }
-            } else {
-                Intent(Intent.ACTION_OPEN_DOCUMENT).apply {
+            }
+
+        try {
+            activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
+        } catch (e: Exception) {
+            // 2. Fallback: Legacy ACTION_GET_CONTENT (Android 10 and below, or failed 13+)
+            val fallbackIntent =
+                Intent(Intent.ACTION_GET_CONTENT).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 -> "*/*"
+                            "image" -> "image/*"
+                            else -> "*/*" // 'both' case
                         }
+                    // Allow both images and videos in the legacy picker if 'both' is selected
+                    if (type == "both") {
+                        putExtra(Intent.EXTRA_MIME_TYPES, arrayOf("image/*", "video/*"))
+                    }
                 }
-            }
 
-        activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
+            try {
+                activity.startActivityForResult(
+                    Intent.createChooser(fallbackIntent, "Select Media"),
+                    PICKER_REQUEST_CODE,
+                )
+            } catch (fallbackEx: Exception) {
+                pickerPromise?.reject("E_NO_PICKER", "No app available to pick media")
+                cleanup()
+            }
+        }
     }
 
     private fun launchCamera(
         activity: Activity,
         useFrontCamera: Boolean,
     ) {
-        val photoFile = createTempFile("jpg")
+        val file = createTempFile("jpg")
         val authority = "${reactContext.packageName}.provider"
-        cameraCaptureUri = FileProvider.getUriForFile(reactContext, authority, photoFile)
+        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,
-                )
+                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)
@@ -173,7 +250,7 @@ class FastMediaPickerModule(
         activity.startActivityForResult(intent, PICKER_REQUEST_CODE)
     }
 
-    // -------------------- ACTIVITY CALLBACKS --------------------
+    // -------------------- ACTIVITY RESULT --------------------
 
     override fun onActivityResult(
         activity: Activity?,
@@ -183,184 +260,67 @@ class FastMediaPickerModule(
     ) {
         if (requestCode != PICKER_REQUEST_CODE || pickerPromise == null) return
 
-        if (resultCode == Activity.RESULT_CANCELED) {
+        if (resultCode != Activity.RESULT_OK) {
             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()
+            pickerPromise?.reject("E_NO_URI", "No media")
         }
     }
 
-    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 --------------------
+    // -------------------- MEDIA --------------------
 
     private fun processMedia(uri: Uri) {
         val resolver = reactContext.contentResolver
-        val mimeType = resolver.getType(uri) ?: "image/jpeg"
-        val isVideo = mimeType.startsWith("video/")
+        val mime = resolver.getType(uri) ?: "image/jpeg"
+        val isVideo = mime.startsWith("video")
 
         try {
             if (isVideo) {
-                val ext =
-                    MimeTypeMap.getSingleton().getExtensionFromMimeType(mimeType) ?: "mp4"
-                val tempFile = createTempFile(ext)
-
+                val file = createTempFile("mp4")
                 resolver.openInputStream(uri)?.use { input ->
-                    FileOutputStream(tempFile).use { output -> input.copyTo(output) }
+                    FileOutputStream(file).use { input.copyTo(it) }
                 }
-
-                val (w, h) = getVideoDimensions(tempFile)
-                resolveResult(Uri.fromFile(tempFile).toString(), true, w, h)
+                resolveResult(Uri.fromFile(file).toString(), true, 0, 0)
             } 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,
-                )
+                val file = createTempFile("jpg")
+                resolver.openInputStream(uri)?.use { input ->
+                    BitmapFactory.decodeStream(input)?.compress(
+                        Bitmap.CompressFormat.JPEG,
+                        JPEG_QUALITY,
+                        FileOutputStream(file),
+                    )
+                }
+                resolveResult(Uri.fromFile(file).toString(), false, 0, 0)
             }
         } catch (e: Exception) {
-            pickerPromise?.reject("E_PROCESS_ERROR", e.message)
+            pickerPromise?.reject("E_PROCESS", 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 =
+        pickerPromise?.resolve(
             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 createTempFile(ext: String) = File(reactContext.cacheDir, "fast-${UUID.randomUUID()}.$ext")
 
     private fun cleanup() {
         pickerPromise = null

package/package.json

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

package/withMediaPicker.js

@@ -3,74 +3,98 @@ const { withAndroidManifest, withInfoPlist, AndroidConfig } = require('@expo/con
 const { getMainApplicationOrThrow } = AndroidConfig.Manifest;
 
 /**
- * Android Configuration
+ * ANDROID CONFIG
  */
 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',
-        ];
+        // -------------------------
+        // 1. PERMISSIONS
+        // -------------------------
 
         if (!androidManifest.manifest['uses-permission']) {
             androidManifest.manifest['uses-permission'] = [];
         }
 
+        const permissions = [
+            { name: 'android.permission.CAMERA' },
+            { name: 'android.permission.READ_MEDIA_IMAGES' },
+            { name: 'android.permission.READ_MEDIA_VIDEO' },
+            { name: 'android.permission.READ_EXTERNAL_STORAGE', maxSdkVersion: '32' },
+        ];
+
         permissions.forEach((perm) => {
-            if (!androidManifest.manifest['uses-permission'].find((p) => p.$['android:name'] === perm)) {
-                androidManifest.manifest['uses-permission'].push({ $: { 'android:name': perm } });
+            const exists = androidManifest.manifest['uses-permission'].some(
+                (p) => p.$['android:name'] === perm.name
+            );
+
+            if (!exists) {
+                androidManifest.manifest['uses-permission'].push({
+                    $: {
+                        'android:name': perm.name,
+                        ...(perm.maxSdkVersion
+                            ? { 'android:maxSdkVersion': perm.maxSdkVersion }
+                            : {}),
+                    },
+                });
             }
         });
 
-        // 2. Add Queries (For Android 11+ visibility)
+        // -------------------------
+        // 2. QUERIES (Android 11+)
+        // -------------------------
+
         if (!androidManifest.manifest.queries) {
             androidManifest.manifest.queries = [{}];
         }
+
         const queries = androidManifest.manifest.queries[0];
         if (!queries.intent) queries.intent = [];
 
-        const pickerIntents = [
+        const intents = [
             { 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/*' } }]
+                data: [{ $: { 'android:mimeType': 'image/*' } }],
             },
             {
                 action: [{ $: { 'android:name': 'android.intent.action.OPEN_DOCUMENT' } }],
-                data: [{ $: { 'android:mimeType': 'video/*' } }]
-            }
+                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);
+        intents.forEach((intent) => {
+            const actionName = intent.action[0].$['android:name'];
+            const exists = queries.intent.some(
+                (i) => i.action?.[0]?.$['android:name'] === actionName
+            );
             if (!exists) queries.intent.push(intent);
         });
 
-        // 3. Ensure FileProvider exists (The "Null" Fix)
+        // -------------------------
+        // 3. FILE PROVIDER
+        // -------------------------
+
         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
+        const hasProvider = mainApplication.provider.some(
+            (p) =>
+                p.$['android:name'] === 'androidx.core.content.FileProvider' ||
+                p.$['android:authorities'] === providerAuthority
         );
 
         if (!hasProvider) {
             mainApplication.provider.push({
                 $: {
-                    'android:name': providerClassName,
+                    'android:name': 'androidx.core.content.FileProvider',
                     'android:authorities': providerAuthority,
                     'android:exported': 'false',
                     'android:grantUriPermissions': 'true',
@@ -91,26 +115,33 @@ const withAndroidConfig = (config) => {
 };
 
 /**
- * iOS Configuration
+ * IOS CONFIG
  */
 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.";
+        const plist = config.modResults;
+
+        plist.NSCameraUsageDescription =
+            plist.NSCameraUsageDescription ||
+            'Allow access to your camera to take photos and videos.';
+
+        plist.NSPhotoLibraryUsageDescription =
+            plist.NSPhotoLibraryUsageDescription ||
+            'Allow access to your photo library to select media.';
+
+        plist.NSMicrophoneUsageDescription =
+            plist.NSMicrophoneUsageDescription ||
+            'Allow access to your microphone when recording videos.';
 
         return config;
     });
 };
 
 /**
- * Export the Plugin
+ * EXPORT PLUGIN
  */
 module.exports = function withMediaPicker(config) {
     config = withAndroidConfig(config);
     config = withIosConfig(config);
     return config;
-};
+};