react-native-iinstall 0.2.13 → 0.2.14

package/lib/src/pushRegistration.js

@@ -0,0 +1,70 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.registerPushToken = registerPushToken;
+exports.unregisterPushToken = unregisterPushToken;
+const react_native_1 = require("react-native");
+function normalizeApiEndpoint(apiEndpoint) {
+    return apiEndpoint.replace(/\/+$/, '');
+}
+function resolvePlatform(platform) {
+    if (platform)
+        return platform;
+    return react_native_1.Platform.OS === 'ios' ? 'IOS' : 'ANDROID';
+}
+async function registerPushToken({ token, apiKey, apiEndpoint = 'https://iinstall.app', deviceUdid, projectId, platform, }) {
+    try {
+        const response = await fetch(`${normalizeApiEndpoint(apiEndpoint)}/api/notifications/push/register`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                token,
+                apiKey,
+                deviceUdid,
+                projectId,
+                platform: resolvePlatform(platform),
+            }),
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const data = await response.json().catch(() => ({}));
+        return {
+            success: response.ok,
+            status: response.status,
+            data,
+            error: response.ok ? undefined : data?.error || 'Failed to register push token',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            status: 500,
+            error: error instanceof Error ? error.message : 'Unknown register push error',
+        };
+    }
+}
+async function unregisterPushToken({ token, apiKey, apiEndpoint = 'https://iinstall.app', }) {
+    try {
+        const response = await fetch(`${normalizeApiEndpoint(apiEndpoint)}/api/notifications/push/register`, {
+            method: 'DELETE',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify({
+                token,
+                apiKey,
+            }),
+        });
+        // eslint-disable-next-line @typescript-eslint/no-explicit-any
+        const data = await response.json().catch(() => ({}));
+        return {
+            success: response.ok,
+            status: response.status,
+            data,
+            error: response.ok ? undefined : data?.error || 'Failed to unregister push token',
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            status: 500,
+            error: error instanceof Error ? error.message : 'Unknown unregister push error',
+        };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-iinstall",
-  "version": "0.2.13",
+  "version": "0.2.14",
   "description": "🎯 IInstall React Native SDK - The ultimate beta testing & QA feedback tool. Shake-to-report with voice recordings, screen recordings, and screenshots. Zero-config setup with TypeScript support. Perfect for beta testing, QA teams, and user feedback collection.",
   "author": "TesterFlow Team",
   "license": "MIT",
@@ -34,22 +34,27 @@
   "files": [
     "lib",
     "src",
-    "INTEGRATION_GUIDE.md"
+    "INTEGRATION_GUIDE.md",
+    "RELEASE_MANIFEST.json"
   ],
   "scripts": {
+    "prebuild": "npm run prepare:release",
     "build": "tsc",
+    "sync:release-manifest": "node scripts/sync-release-manifest.mjs",
+    "check:release-manifest": "node scripts/check-release-manifest.mjs",
+    "prepare:release": "npm run sync:release-manifest && npm run check:release-manifest",
     "prepare": "npm run build"
   },
   "peerDependencies": {
     "react": ">=16.8.0",
-    "react-native": ">=0.60.0"
-  },
-  "dependencies": {
-    "react-native-sensors": "^7.3.0",
-    "react-native-view-shot": "^3.1.2",
-    "react-native-device-info": "^10.0.0",
+    "react-native": ">=0.60.0",
     "react-native-audio-recorder-player": "^3.6.4",
+    "react-native-device-info": "^10.0.0",
     "react-native-record-screen": "^0.6.2",
+    "react-native-sensors": "^7.3.0",
+    "react-native-view-shot": "^3.1.2"
+  },
+  "dependencies": {
     "rxjs": "^7.0.0"
   },
   "devDependencies": {
@@ -57,6 +62,11 @@
     "@types/react-native": "^0.70.0",
     "react": "18.2.0",
     "react-native": "0.72.6",
+    "react-native-audio-recorder-player": "^3.6.4",
+    "react-native-device-info": "^10.0.0",
+    "react-native-record-screen": "^0.6.2",
+    "react-native-sensors": "^7.3.0",
+    "react-native-view-shot": "^3.1.2",
     "typescript": "^5.0.0"
   }
 }

package/src/FeedbackModal.tsx

@@ -16,15 +16,13 @@ import {
   TouchableWithoutFeedback,
   ScrollView
 } from 'react-native';
-import DeviceInfo from 'react-native-device-info';
-import AudioRecorderPlayer, {
-  AVEncodingOption,
-  AVEncoderAudioQualityIOSType,
-  AudioEncoderAndroidType,
-  AudioSourceAndroidType,
-  OutputFormatAndroidType,
-  type AudioSet,
-} from 'react-native-audio-recorder-player';
+import {
+  createAudioRecorderPlayer,
+  getAudioRecordingPreset,
+  getDeviceMetadata,
+  getDeviceUniqueId,
+  hasAudioRecordingSupport,
+} from './nativeModules';
 
 interface FeedbackModalProps {
   visible: boolean;
@@ -52,19 +50,28 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
   const [isRecordingAudio, setIsRecordingAudio] = useState(false);
   const [audioUri, setAudioUri] = useState<string | null>(null);
   const [audioDuration, setAudioDuration] = useState('00:00');
+  const audioRecordingAvailable = hasAudioRecordingSupport();
   
-  const audioRecorderPlayer = useRef(new AudioRecorderPlayer()).current;
+  const audioRecorderPlayer = useRef(createAudioRecorderPlayer()).current;
 
   useEffect(() => {
     return () => {
       // Cleanup
-      if (isRecordingAudio) {
-        audioRecorderPlayer.stopRecorder();
+      if (isRecordingAudio && audioRecorderPlayer) {
+        audioRecorderPlayer.stopRecorder().catch(() => undefined);
       }
     };
-  }, [isRecordingAudio]);
+  }, [audioRecorderPlayer, isRecordingAudio]);
 
   const onStartAudioRecord = async () => {
+    if (!audioRecorderPlayer || !audioRecordingAvailable) {
+      Alert.alert(
+        'Audio unavailable',
+        'Install react-native-audio-recorder-player in your app root, then rebuild the app.'
+      );
+      return;
+    }
+
     if (Platform.OS === 'android') {
       try {
         const grants = await PermissionsAndroid.requestMultiple([
@@ -86,23 +93,9 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
     }
 
     try {
-      const audioSet: AudioSet = {
-        AVFormatIDKeyIOS: AVEncodingOption.aac,
-        AVEncoderAudioQualityKeyIOS: AVEncoderAudioQualityIOSType.high,
-        AVSampleRateKeyIOS: 44100,
-        AVNumberOfChannelsKeyIOS: 1,
-        AVEncoderBitRateKeyIOS: 128000,
-        AudioEncoderAndroid: AudioEncoderAndroidType.AAC,
-        AudioSourceAndroid: AudioSourceAndroidType.MIC,
-        OutputFormatAndroid: OutputFormatAndroidType.MPEG_4,
-        AudioEncodingBitRateAndroid: 128000,
-        AudioSamplingRateAndroid: 44100,
-        AudioChannelsAndroid: 1,
-      };
-
       const result = await audioRecorderPlayer.startRecorder(
         undefined,
-        audioSet,
+        getAudioRecordingPreset(),
       );
       audioRecorderPlayer.addRecordBackListener((e) => {
         setAudioDuration(audioRecorderPlayer.mmssss(Math.floor(e.currentPosition)));
@@ -117,6 +110,10 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
   };
 
   const onStopAudioRecord = async () => {
+    if (!audioRecorderPlayer) {
+      return;
+    }
+
     try {
       const result = await audioRecorderPlayer.stopRecorder();
       audioRecorderPlayer.removeRecordBackListener();
@@ -134,7 +131,7 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
   };
 
   const handleClose = async () => {
-    if (isRecordingAudio) {
+    if (isRecordingAudio && audioRecorderPlayer) {
       try {
         await audioRecorderPlayer.stopRecorder();
       } catch (error) {
@@ -203,21 +200,14 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
       }
 
       // 4. Metadata
-      const metadata = {
-        device: DeviceInfo.getModel(),
-        systemName: DeviceInfo.getSystemName(),
-        systemVersion: DeviceInfo.getSystemVersion(),
-        appVersion: DeviceInfo.getVersion(),
-        buildNumber: DeviceInfo.getBuildNumber(),
-        brand: DeviceInfo.getBrand(),
-        isEmulator: await DeviceInfo.isEmulator(),
-      };
+      const metadata = await getDeviceMetadata();
       formData.append('metadata', JSON.stringify(metadata));
 
       // 5. Other fields
       formData.append('description', description);
       formData.append('apiKey', apiKey);
-      formData.append('udid', await DeviceInfo.getUniqueId());
+      const deviceUdid = await getDeviceUniqueId();
+      formData.append('udid', deviceUdid || 'unknown');
       
       // 6. Send
       const response = await fetch(`${apiEndpoint}/api/feedback`, {
@@ -306,11 +296,23 @@ export const FeedbackModal: React.FC<FeedbackModalProps> = ({
           <View style={styles.actionsRow}>
               {/* Audio Recorder */}
               <TouchableOpacity 
-                style={[styles.actionBtn, isRecordingAudio ? styles.recordingBtn : undefined, audioUri ? styles.hasAudioBtn : undefined]}
+                style={[
+                  styles.actionBtn,
+                  isRecordingAudio ? styles.recordingBtn : undefined,
+                  audioUri ? styles.hasAudioBtn : undefined,
+                  !audioRecordingAvailable ? styles.disabledActionBtn : undefined,
+                ]}
                 onPress={isRecordingAudio ? onStopAudioRecord : onStartAudioRecord}
+                disabled={!audioRecordingAvailable}
               >
                   <Text style={[styles.actionBtnText, (isRecordingAudio || audioUri) ? { color: '#FFF' } : undefined]}>
-                      {isRecordingAudio ? `Stop (${audioDuration})` : audioUri ? 'Re-record Audio' : '🎙 Record Audio'}
+                      {!audioRecordingAvailable
+                        ? '🎙 Audio Unavailable'
+                        : isRecordingAudio
+                          ? `Stop (${audioDuration})`
+                          : audioUri
+                            ? 'Re-record Audio'
+                            : '🎙 Record Audio'}
                   </Text>
               </TouchableOpacity>
 
@@ -437,6 +439,9 @@ const styles = StyleSheet.create({
   hasAudioBtn: {
       backgroundColor: '#4CAF50',
   },
+  disabledActionBtn: {
+      opacity: 0.45,
+  },
   actionBtnText: {
       fontSize: 14,
       fontWeight: '600',

package/src/index.tsx

@@ -1,11 +1,16 @@
 import React, { useEffect, useState, useRef } from 'react';
 import { View, StyleSheet, TouchableOpacity, Text, SafeAreaView, Platform } from 'react-native';
-import { captureScreen } from 'react-native-view-shot';
 import { ShakeDetector } from './ShakeDetector';
 import { FeedbackModal } from './FeedbackModal';
-import RecordScreen from 'react-native-record-screen';
-import DeviceInfo from 'react-native-device-info';
 import { registerPushToken } from './pushRegistration';
+import {
+  captureScreenImage,
+  getDeviceUniqueId,
+  hasScreenRecordingSupport,
+  isEmulatorDevice,
+  startScreenRecording,
+  stopScreenRecording,
+} from './nativeModules';
 
 interface IInstallProps {
   apiKey: string;
@@ -53,7 +58,7 @@ export const IInstall: React.FC<IInstallProps> = ({
   useEffect(() => {
     let mounted = true;
 
-    DeviceInfo.isEmulator()
+    isEmulatorDevice()
       .then((value) => {
         if (mounted) {
           setIsEmulator(value);
@@ -75,7 +80,7 @@ export const IInstall: React.FC<IInstallProps> = ({
 
     try {
       // Capture screenshot
-      const uri = await captureScreen({
+      const uri = await captureScreenImage({
         format: 'png',
         quality: 0.8,
       });
@@ -113,7 +118,7 @@ export const IInstall: React.FC<IInstallProps> = ({
     let cancelled = false;
 
     const syncPushToken = async () => {
-      const deviceUdid = await DeviceInfo.getUniqueId().catch(() => undefined);
+      const deviceUdid = await getDeviceUniqueId();
       const result = await registerPushToken({
         token: pushToken,
         apiKey,
@@ -168,6 +173,7 @@ export const IInstall: React.FC<IInstallProps> = ({
     showFloatingButtonOnEmulator &&
     !modalVisible &&
     !isRecording;
+  const screenRecordingAvailable = hasScreenRecordingSupport();
 
   const normalizeVideoUri = (value: string) => {
     if (Platform.OS === 'ios' && value.startsWith('/')) {
@@ -242,10 +248,18 @@ export const IInstall: React.FC<IInstallProps> = ({
   };
 
   const handleStartRecording = async () => {
+    if (!screenRecordingAvailable) {
+      console.warn(
+        'IInstall: Screen recording unavailable. Install react-native-record-screen in your app and rebuild.'
+      );
+      setModalVisible(true);
+      return;
+    }
+
     setModalVisible(false);
     setIsRecording(true);
     try {
-        await RecordScreen.startRecording({ mic: true });
+        await startScreenRecording({ mic: true });
     } catch (e) {
         console.error('Failed to start recording', e);
         setIsRecording(false);
@@ -256,7 +270,7 @@ export const IInstall: React.FC<IInstallProps> = ({
   const handleStopRecording = async () => {
     try {
         // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        const res: any = await RecordScreen.stopRecording();
+        const res: any = await stopScreenRecording();
         if (res) {
             const nextVideoUri = resolveRecordedVideoUri(res);
             if (nextVideoUri) {
@@ -315,7 +329,7 @@ export const IInstall: React.FC<IInstallProps> = ({
         }}
         screenshotUri={screenshotUri}
         videoUri={videoUri}
-        onStartRecording={handleStartRecording}
+        onStartRecording={screenRecordingAvailable ? handleStartRecording : undefined}
         apiKey={apiKey}
         apiEndpoint={apiEndpoint}
       />

package/src/nativeModules.ts

@@ -0,0 +1,308 @@
+import { Platform } from 'react-native';
+
+type CaptureScreenOptions = {
+  format?: 'png' | 'jpg' | 'webm' | 'raw';
+  quality?: number;
+  result?: 'tmpfile' | 'base64' | 'data-uri' | 'zip-base64';
+};
+
+type DeviceInfoModule = {
+  getModel?: () => string;
+  getSystemName?: () => string;
+  getSystemVersion?: () => string;
+  getVersion?: () => string;
+  getBuildNumber?: () => string;
+  getBrand?: () => string;
+  isEmulator?: () => Promise<boolean>;
+  getUniqueId?: () => Promise<string>;
+};
+
+type ViewShotModule = {
+  captureScreen?: (options?: CaptureScreenOptions) => Promise<string>;
+};
+
+type RecordScreenModule = {
+  startRecording?: (config?: { mic?: boolean; fps?: number; bitrate?: number }) => Promise<unknown>;
+  stopRecording?: () => Promise<unknown>;
+};
+
+type AudioRecorderModule = {
+  default?: new () => AudioRecorderPlayerLike;
+  AVEncodingOption?: { aac?: string };
+  AVEncoderAudioQualityIOSType?: { high?: number };
+  AudioEncoderAndroidType?: { AAC?: number };
+  AudioSourceAndroidType?: { MIC?: number };
+  OutputFormatAndroidType?: { MPEG_4?: number };
+};
+
+type RecordBackEvent = {
+  currentPosition: number;
+};
+
+export type AudioRecorderPlayerLike = {
+  startRecorder: (uri?: string, audioSets?: Record<string, unknown>) => Promise<string>;
+  stopRecorder: () => Promise<string>;
+  addRecordBackListener: (callback: (recordingMeta: RecordBackEvent) => void) => void;
+  removeRecordBackListener: () => void;
+  mmssss: (milisecs: number) => string;
+};
+
+export type DeviceMetadata = {
+  device: string;
+  systemName: string;
+  systemVersion: string;
+  appVersion: string;
+  buildNumber: string;
+  brand: string;
+  isEmulator: boolean;
+};
+
+const warnedKeys = new Set<string>();
+
+function warnOnce(key: string, message: string) {
+  if (warnedKeys.has(key)) {
+    return;
+  }
+  warnedKeys.add(key);
+  console.warn(message);
+}
+
+function getDefaultExport<T>(moduleValue: unknown): T | null {
+  if (!moduleValue) {
+    return null;
+  }
+  if (typeof moduleValue === 'object' && moduleValue !== null && 'default' in moduleValue) {
+    return (moduleValue as { default: T }).default;
+  }
+  return moduleValue as T;
+}
+
+function loadRawModule<T>(moduleName: string): T | null {
+  try {
+    return require(moduleName) as T;
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    warnOnce(
+      `missing:${moduleName}`,
+      `[iInstall SDK] Missing native dependency "${moduleName}". Install it in your app root and rebuild. (${reason})`
+    );
+    return null;
+  }
+}
+
+let cachedDeviceInfoModule: DeviceInfoModule | null | undefined;
+let cachedCaptureScreen: ((options?: CaptureScreenOptions) => Promise<string>) | null | undefined;
+let cachedRecordScreenModule: RecordScreenModule | null | undefined;
+let cachedAudioModule: AudioRecorderModule | null | undefined;
+
+function getDeviceInfoModule(): DeviceInfoModule | null {
+  if (cachedDeviceInfoModule !== undefined) {
+    return cachedDeviceInfoModule;
+  }
+  const required = loadRawModule<unknown>('react-native-device-info');
+  cachedDeviceInfoModule = required ? getDefaultExport<DeviceInfoModule>(required) : null;
+  return cachedDeviceInfoModule;
+}
+
+function getCaptureScreenFn(): ((options?: CaptureScreenOptions) => Promise<string>) | null {
+  if (cachedCaptureScreen !== undefined) {
+    return cachedCaptureScreen;
+  }
+  const required = loadRawModule<ViewShotModule>('react-native-view-shot');
+  cachedCaptureScreen = required?.captureScreen ?? null;
+  if (!cachedCaptureScreen) {
+    warnOnce(
+      'missing:react-native-view-shot:captureScreen',
+      '[iInstall SDK] Screenshot capture unavailable: react-native-view-shot is not linked correctly.'
+    );
+  }
+  return cachedCaptureScreen;
+}
+
+function getRecordScreenModule(): RecordScreenModule | null {
+  if (cachedRecordScreenModule !== undefined) {
+    return cachedRecordScreenModule;
+  }
+  const required = loadRawModule<unknown>('react-native-record-screen');
+  cachedRecordScreenModule = required ? getDefaultExport<RecordScreenModule>(required) : null;
+  return cachedRecordScreenModule;
+}
+
+function getAudioRecorderModule(): AudioRecorderModule | null {
+  if (cachedAudioModule !== undefined) {
+    return cachedAudioModule;
+  }
+  cachedAudioModule = loadRawModule<AudioRecorderModule>('react-native-audio-recorder-player');
+  return cachedAudioModule;
+}
+
+function fallbackString(value: string | undefined, defaultValue: string): string {
+  if (!value || value.trim().length === 0) {
+    return defaultValue;
+  }
+  return value;
+}
+
+export async function isEmulatorDevice(): Promise<boolean> {
+  const moduleRef = getDeviceInfoModule();
+  if (!moduleRef?.isEmulator) {
+    return false;
+  }
+  try {
+    return await moduleRef.isEmulator();
+  } catch {
+    return false;
+  }
+}
+
+export async function getDeviceUniqueId(): Promise<string | undefined> {
+  const moduleRef = getDeviceInfoModule();
+  if (!moduleRef?.getUniqueId) {
+    return undefined;
+  }
+  try {
+    const value = await moduleRef.getUniqueId();
+    return fallbackString(value, 'unknown');
+  } catch {
+    return undefined;
+  }
+}
+
+export async function getDeviceMetadata(): Promise<DeviceMetadata> {
+  const moduleRef = getDeviceInfoModule();
+  const systemName = Platform.OS === 'ios' ? 'iOS' : Platform.OS;
+  const systemVersion = String(Platform.Version ?? 'unknown');
+
+  const metadata: DeviceMetadata = {
+    device: 'Unknown Device',
+    systemName,
+    systemVersion,
+    appVersion: 'unknown',
+    buildNumber: 'unknown',
+    brand: Platform.OS === 'ios' ? 'Apple' : 'Unknown',
+    isEmulator: false,
+  };
+
+  if (!moduleRef) {
+    return metadata;
+  }
+
+  try {
+    metadata.device = fallbackString(moduleRef.getModel?.(), metadata.device);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.systemName = fallbackString(moduleRef.getSystemName?.(), metadata.systemName);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.systemVersion = fallbackString(moduleRef.getSystemVersion?.(), metadata.systemVersion);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.appVersion = fallbackString(moduleRef.getVersion?.(), metadata.appVersion);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.buildNumber = fallbackString(moduleRef.getBuildNumber?.(), metadata.buildNumber);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.brand = fallbackString(moduleRef.getBrand?.(), metadata.brand);
+  } catch {
+    // noop
+  }
+  try {
+    metadata.isEmulator = moduleRef.isEmulator ? await moduleRef.isEmulator() : false;
+  } catch {
+    metadata.isEmulator = false;
+  }
+
+  return metadata;
+}
+
+export function hasScreenRecordingSupport(): boolean {
+  const moduleRef = getRecordScreenModule();
+  return Boolean(moduleRef?.startRecording && moduleRef?.stopRecording);
+}
+
+export async function startScreenRecording(config: { mic?: boolean } = { mic: true }): Promise<void> {
+  const moduleRef = getRecordScreenModule();
+  if (!moduleRef?.startRecording) {
+    throw new Error(
+      'Screen recording dependency missing. Install react-native-record-screen and rebuild the app.'
+    );
+  }
+  await moduleRef.startRecording(config);
+}
+
+export async function stopScreenRecording(): Promise<unknown> {
+  const moduleRef = getRecordScreenModule();
+  if (!moduleRef?.stopRecording) {
+    throw new Error(
+      'Screen recording dependency missing. Install react-native-record-screen and rebuild the app.'
+    );
+  }
+  return moduleRef.stopRecording();
+}
+
+export async function captureScreenImage(options?: CaptureScreenOptions): Promise<string> {
+  const captureScreen = getCaptureScreenFn();
+  if (!captureScreen) {
+    throw new Error(
+      'Screenshot dependency missing. Install react-native-view-shot and rebuild the app.'
+    );
+  }
+  return captureScreen(options);
+}
+
+export function hasAudioRecordingSupport(): boolean {
+  const moduleRef = getAudioRecorderModule();
+  const recorderCtor = moduleRef?.default;
+  return typeof recorderCtor === 'function';
+}
+
+export function createAudioRecorderPlayer(): AudioRecorderPlayerLike | null {
+  const moduleRef = getAudioRecorderModule();
+  const recorderCtor = moduleRef?.default;
+  if (typeof recorderCtor !== 'function') {
+    warnOnce(
+      'missing:react-native-audio-recorder-player:ctor',
+      '[iInstall SDK] Audio recording unavailable: react-native-audio-recorder-player is not linked correctly.'
+    );
+    return null;
+  }
+
+  try {
+    return new recorderCtor();
+  } catch (error) {
+    const reason = error instanceof Error ? error.message : String(error);
+    warnOnce(
+      'missing:react-native-audio-recorder-player:new',
+      `[iInstall SDK] Failed to initialize audio recorder. (${reason})`
+    );
+    return null;
+  }
+}
+
+export function getAudioRecordingPreset(): Record<string, string | number> {
+  const moduleRef = getAudioRecorderModule();
+  return {
+    AVFormatIDKeyIOS: moduleRef?.AVEncodingOption?.aac ?? 'aac',
+    AVEncoderAudioQualityKeyIOS: moduleRef?.AVEncoderAudioQualityIOSType?.high ?? 96,
+    AVSampleRateKeyIOS: 44100,
+    AVNumberOfChannelsKeyIOS: 1,
+    AVEncoderBitRateKeyIOS: 128000,
+    AudioEncoderAndroid: moduleRef?.AudioEncoderAndroidType?.AAC ?? 3,
+    AudioSourceAndroid: moduleRef?.AudioSourceAndroidType?.MIC ?? 1,
+    OutputFormatAndroid: moduleRef?.OutputFormatAndroidType?.MPEG_4 ?? 2,
+    AudioEncodingBitRateAndroid: 128000,
+    AudioSamplingRateAndroid: 44100,
+    AudioChannelsAndroid: 1,
+  };
+}