@abdurrahman-dev/react-native-ivs-broadcast 0.2.5 → 0.2.6

package/src/index.ts

@@ -10,6 +10,12 @@ import type {
   VideoStats,
   VideoConfig,
   AudioConfig,
+  TransmissionStatistics,
+  AudioDeviceStats,
+  NetworkTestResult,
+  DeviceDescriptor,
+  CameraCapabilities,
+  TimedMetadata,
 } from "./types";
 
 const { IVSBroadcastModule } = NativeModules;
@@ -21,7 +27,7 @@ if (!IVSBroadcastModule) {
   if (__DEV__) {
     console.warn(
       "IVSBroadcastModule native module is not available. " +
-      "Make sure you have properly linked the module and rebuilt the app with 'npx expo run:ios'."
+        "Make sure you have properly linked the module and rebuilt the app with 'npx expo run:ios'."
     );
   }
   // Modül yoksa eventEmitter'ı null bırak, hata fırlatma
@@ -39,7 +45,7 @@ class IVSBroadcast {
     if (!IVSBroadcastModule) {
       throw new Error(
         "IVSBroadcastModule native module is not available. " +
-        "This module requires a development build. Please run 'npx expo run:ios' to rebuild the app."
+          "This module requires a development build. Please run 'npx expo run:ios' to rebuild the app."
       );
     }
   }
@@ -51,7 +57,7 @@ class IVSBroadcast {
     config: IVSBroadcastConfig
   ): Promise<IVSBroadcastSession> {
     this.checkModuleAvailable();
-    
+
     if (!config.rtmpUrl) {
       throw new Error("RTMP URL is required");
     }
@@ -163,6 +169,34 @@ class IVSBroadcast {
     }
   }
 
+  /**
+   * Kamera listesinden belirli bir kamerayı seçer
+   * @param sessionId - Broadcast session ID
+   * @param deviceId - Seçilecek kameranın deviceId'si (listAvailableDevices'dan alınabilir)
+   */
+  async selectCamera(sessionId: string, deviceId: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.selectCamera(sessionId, deviceId);
+    } catch (error: any) {
+      throw new Error(`Failed to select camera: ${error.message}`);
+    }
+  }
+
+  /**
+   * Mikrofon listesinden belirli bir mikrofonu seçer
+   * @param sessionId - Broadcast session ID
+   * @param deviceId - Seçilecek mikrofonun deviceId'si (listAvailableDevices'dan alınabilir)
+   */
+  async selectMicrophone(sessionId: string, deviceId: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.selectMicrophone(sessionId, deviceId);
+    } catch (error: any) {
+      throw new Error(`Failed to select microphone: ${error.message}`);
+    }
+  }
+
   /**
    * Mikrofonu açıp kapatır
    */
@@ -217,6 +251,185 @@ class IVSBroadcast {
     }
   }
 
+  /**
+   * Kullanılabilir cihazları listeler
+   */
+  async listAvailableDevices(): Promise<DeviceDescriptor[]> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.listAvailableDevices();
+    } catch (error: any) {
+      throw new Error(`Failed to list available devices: ${error.message}`);
+    }
+  }
+
+  /**
+   * Bağlı cihazları listeler
+   */
+  async listAttachedDevices(sessionId: string): Promise<DeviceDescriptor[]> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.listAttachedDevices(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to list attached devices: ${error.message}`);
+    }
+  }
+
+  /**
+   * Kamera zoom seviyesini ayarlar
+   */
+  async setCameraZoom(sessionId: string, zoomFactor: number): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.setCameraZoom(sessionId, zoomFactor);
+    } catch (error: any) {
+      throw new Error(`Failed to set camera zoom: ${error.message}`);
+    }
+  }
+
+  /**
+   * Kamera flaşını açıp kapatır
+   */
+  async setTorchEnabled(sessionId: string, enabled: boolean): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.setTorchEnabled(sessionId, enabled);
+    } catch (error: any) {
+      throw new Error(`Failed to set torch: ${error.message}`);
+    }
+  }
+
+  /**
+   * Kamera yeteneklerini alır
+   */
+  async getCameraCapabilities(sessionId: string): Promise<CameraCapabilities> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.getCameraCapabilities(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get camera capabilities: ${error.message}`);
+    }
+  }
+
+  /**
+   * Zamanlı metadata gönderir
+   */
+  async sendTimedMetadata(sessionId: string, metadata: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.sendTimedMetadata(sessionId, metadata);
+    } catch (error: any) {
+      throw new Error(`Failed to send timed metadata: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ağ kalite testi başlatır
+   */
+  async startNetworkTest(
+    rtmpUrl: string,
+    streamKey?: string,
+    duration?: number
+  ): Promise<string> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.startNetworkTest(
+        rtmpUrl,
+        streamKey,
+        duration
+      );
+    } catch (error: any) {
+      throw new Error(`Failed to start network test: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ağ kalite testini iptal eder
+   */
+  async cancelNetworkTest(testId: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.cancelNetworkTest(testId);
+    } catch (error: any) {
+      throw new Error(`Failed to cancel network test: ${error.message}`);
+    }
+  }
+
+  /**
+   * Ses gain seviyesini ayarlar (0.0 - 2.0 arası)
+   */
+  async setAudioGain(sessionId: string, gain: number): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.setAudioGain(sessionId, gain);
+    } catch (error: any) {
+      throw new Error(`Failed to set audio gain: ${error.message}`);
+    }
+  }
+
+  /**
+   * Mevcut ses gain seviyesini alır
+   */
+  async getAudioGain(sessionId: string): Promise<number> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.getAudioGain(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get audio gain: ${error.message}`);
+    }
+  }
+
+  /**
+   * Picture-in-Picture modunu başlatır (iOS 15+, Android 8.0+)
+   * @param sessionId - Broadcast session ID
+   */
+  async startPictureInPicture(sessionId: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.startPictureInPicture(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to start Picture-in-Picture: ${error.message}`);
+    }
+  }
+
+  /**
+   * Picture-in-Picture modunu durdurur
+   * @param sessionId - Broadcast session ID
+   */
+  async stopPictureInPicture(sessionId: string): Promise<void> {
+    this.checkModuleAvailable();
+    try {
+      await IVSBroadcastModule.stopPictureInPicture(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to stop Picture-in-Picture: ${error.message}`);
+    }
+  }
+
+  /**
+   * Picture-in-Picture durumunu alır
+   * @param sessionId - Broadcast session ID
+   */
+  async getPictureInPictureState(sessionId: string): Promise<string> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.getPictureInPictureState(sessionId);
+    } catch (error: any) {
+      throw new Error(`Failed to get Picture-in-Picture state: ${error.message}`);
+    }
+  }
+
+  /**
+   * Picture-in-Picture desteğinin olup olmadığını kontrol eder
+   */
+  async isPictureInPictureSupported(): Promise<boolean> {
+    this.checkModuleAvailable();
+    try {
+      return await IVSBroadcastModule.isPictureInPictureSupported();
+    } catch (error: any) {
+      return false;
+    }
+  }
+
   /**
    * Event listener ekler
    * @returns Cleanup fonksiyonu - listener'ı kaldırmak için çağırılır
@@ -241,9 +454,23 @@ class IVSBroadcast {
     eventType: "onVideoStats",
     callback: (stats: VideoStats) => void
   ): () => void;
+  addListener(
+    eventType: "onTransmissionStatistics",
+    callback: (stats: TransmissionStatistics) => void
+  ): () => void;
+  addListener(
+    eventType: "onAudioDeviceStats",
+    callback: (stats: AudioDeviceStats) => void
+  ): () => void;
+  addListener(
+    eventType: "onNetworkTestResult",
+    callback: (result: NetworkTestResult) => void
+  ): () => void;
   addListener(eventType: string, callback: (data: any) => void): () => void {
     if (!eventEmitter) {
-      console.warn("EventEmitter is not available. Native module may not be linked.");
+      console.warn(
+        "EventEmitter is not available. Native module may not be linked."
+      );
       // Modül yoksa boş bir cleanup fonksiyonu döndür
       return () => {};
     }
@@ -278,7 +505,7 @@ class IVSBroadcast {
    */
   removeListener(eventType: string, callback?: (data: any) => void): void {
     if (!eventEmitter) return;
-    
+
     const callbacks = this.listeners.get(eventType);
     if (callbacks) {
       if (callback) {
@@ -298,7 +525,7 @@ class IVSBroadcast {
    */
   removeAllListeners(eventType?: string): void {
     if (!eventEmitter) return;
-    
+
     if (eventType) {
       this.listeners.delete(eventType);
       eventEmitter.removeAllListeners(eventType);

package/src/types.ts

@@ -55,6 +55,11 @@ export interface PreviewViewProps {
    */
   isMirrored?: boolean;
 
+  /**
+   * Picture-in-Picture konfigürasyonu
+   */
+  pictureInPicture?: PictureInPictureConfig;
+
   /**
    * View stili
    */
@@ -71,6 +76,18 @@ export interface PreviewViewRef {
    * Preview'ı yeniden yükle
    */
   refresh: () => void;
+  /**
+   * Picture-in-Picture modunu başlat
+   */
+  startPictureInPicture?: () => Promise<void>;
+  /**
+   * Picture-in-Picture modunu durdur
+   */
+  stopPictureInPicture?: () => Promise<void>;
+  /**
+   * Picture-in-Picture durumunu al
+   */
+  getPictureInPictureState?: () => Promise<PictureInPictureState>;
 }
 
 export type BroadcastEventType =
@@ -78,7 +95,9 @@ export type BroadcastEventType =
   | "onError"
   | "onNetworkHealth"
   | "onAudioStats"
-  | "onVideoStats";
+  | "onVideoStats"
+  | "onTransmissionStatistics"
+  | "onAudioDeviceStats";
 
 export interface BroadcastEvent {
   type: BroadcastEventType;
@@ -103,3 +122,101 @@ export interface VideoStats {
   width: number;
   height: number;
 }
+
+// Gelişmiş İstatistikler
+export interface TransmissionStatistics {
+  /** Ölçülen ortalama gönderme bitrate'i */
+  measuredBitrate: number;
+  /** SDK tarafından önerilen bitrate */
+  recommendedBitrate: number;
+  /** Ortalama round trip time (ms) */
+  rtt: number;
+  /** Yayın kalitesi */
+  broadcastQuality: BroadcastQuality;
+  /** Ağ sağlığı */
+  networkHealth: NetworkHealthLevel;
+}
+
+export type BroadcastQuality =
+  | "nearMaximum"
+  | "high"
+  | "medium"
+  | "low"
+  | "nearMinimum";
+
+export type NetworkHealthLevel =
+  | "excellent"
+  | "high"
+  | "medium"
+  | "low"
+  | "bad";
+
+// Ses Cihazı İstatistikleri
+export interface AudioDeviceStats {
+  /** Ses peak seviyesi (dBFS, -100 ile 0 arası) */
+  peak: number;
+  /** Ses RMS seviyesi (dBFS, -100 ile 0 arası) */
+  rms: number;
+}
+
+// Ağ Kalite Testi
+export interface NetworkTestResult {
+  /** Test ilerleme durumu (0-1 arası) */
+  progress: number;
+  /** Önerilen video konfigürasyonları */
+  recommendations: VideoConfig[];
+  /** Test durumu */
+  status: NetworkTestStatus;
+  /** Hata varsa */
+  error?: string;
+}
+
+export type NetworkTestStatus = "connecting" | "testing" | "success" | "error";
+
+// Cihaz Bilgileri
+export interface DeviceDescriptor {
+  /** Cihaz tipi */
+  type: DeviceType;
+  /** Cihaz pozisyonu (kameralar için) */
+  position?: DevicePosition;
+  /** Cihaz ID'si */
+  deviceId: string;
+  /** Kullanıcı dostu isim */
+  friendlyName: string;
+  /** Varsayılan cihaz mı */
+  isDefault: boolean;
+}
+
+export type DeviceType = "camera" | "microphone" | "userVideo" | "userAudio";
+export type DevicePosition = "front" | "back" | "unknown";
+
+// Kamera Özellikleri
+export interface CameraCapabilities {
+  /** Minimum zoom faktörü */
+  minZoomFactor: number;
+  /** Maximum zoom faktörü */
+  maxZoomFactor: number;
+  /** Flaş desteği var mı */
+  isTorchSupported: boolean;
+}
+
+// Zamanlı Metadata
+export interface TimedMetadata {
+  /** Metadata içeriği */
+  content: string;
+  /** Gönderim zamanı (opsiyonel) */
+  timestamp?: number;
+}
+
+// Picture-in-Picture
+export interface PictureInPictureConfig {
+  /** PiP modunu etkinleştir */
+  enabled?: boolean;
+  /** PiP boyutları (iOS için) */
+  aspectRatio?: {
+    width: number;
+    height: number;
+  };
+}
+
+export type PictureInPictureState = "idle" | "starting" | "active" | "stopping" | "stopped";