react-native-iinstall 0.2.12 → 0.2.14

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,
+  };
+}

package/src/pushRegistration.ts

@@ -0,0 +1,111 @@
+import { Platform } from 'react-native';
+
+export type PushPlatform = 'IOS' | 'ANDROID';
+
+export interface RegisterPushTokenParams {
+  token: string;
+  apiKey: string;
+  apiEndpoint?: string;
+  deviceUdid?: string;
+  projectId?: string;
+  platform?: PushPlatform;
+}
+
+export interface UnregisterPushTokenParams {
+  token: string;
+  apiKey: string;
+  apiEndpoint?: string;
+}
+
+export interface PushRegistrationResult {
+  success: boolean;
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  data?: any;
+  error?: string;
+  status: number;
+}
+
+function normalizeApiEndpoint(apiEndpoint: string): string {
+  return apiEndpoint.replace(/\/+$/, '');
+}
+
+function resolvePlatform(platform?: PushPlatform): PushPlatform {
+  if (platform) return platform;
+  return Platform.OS === 'ios' ? 'IOS' : 'ANDROID';
+}
+
+export async function registerPushToken({
+  token,
+  apiKey,
+  apiEndpoint = 'https://iinstall.app',
+  deviceUdid,
+  projectId,
+  platform,
+}: RegisterPushTokenParams): Promise<PushRegistrationResult> {
+  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: any = 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',
+    };
+  }
+}
+
+export async function unregisterPushToken({
+  token,
+  apiKey,
+  apiEndpoint = 'https://iinstall.app',
+}: UnregisterPushTokenParams): Promise<PushRegistrationResult> {
+  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: any = 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',
+    };
+  }
+}