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

package/README.md

@@ -4,6 +4,7 @@ React Native için Amazon IVS Broadcast SDK köprü paketi. Canlı yayın başla
 
 ## Özellikler
 
+### Temel Özellikler
 - ✅ Broadcast başlatma/durdurma
 - ✅ Kamera önizleme component'i
 - ✅ Kamera kontrolü (ön/arka değiştirme)
@@ -11,6 +12,17 @@ React Native için Amazon IVS Broadcast SDK köprü paketi. Canlı yayın başla
 - ✅ Video ve ses konfigürasyonu
 - ✅ Event-based API
 
+### Gelişmiş Özellikler
+- ✅ Kamera zoom kontrolü
+- ✅ Flaş (torch) kontrolü
+- ✅ Ses gain ayarı (0.0 - 2.0)
+- ✅ Cihaz listeleme (kullanılabilir ve bağlı cihazlar)
+- ✅ Kamera yetenekleri sorgulama
+- ✅ Zamanlı metadata gönderme
+- ✅ Gelişmiş istatistikler (transmission stats)
+- ✅ Ses cihazı istatistikleri (peak, RMS)
+- ✅ Picture-in-Picture (PiP) desteği (iOS 15+, Android 8.0+)
+
 ## Kurulum
 
 ```bash
@@ -223,12 +235,19 @@ await IVSBroadcast.destroySession(sessionId);
 ### Kamera Kontrolü
 
 ```typescript
-// Kamera değiştir
+// Kamera değiştir (front/back arasında)
 await IVSBroadcast.switchCamera(sessionId);
 
 // Kamera pozisyonu ayarla
 await IVSBroadcast.setCameraPosition(sessionId, 'front');
 await IVSBroadcast.setCameraPosition(sessionId, 'back');
+
+// Kamera listesinden belirli bir kamerayı seç
+const devices = await IVSBroadcast.listAvailableDevices();
+const cameras = devices.filter(d => d.type === 'camera');
+
+// İstediğiniz kamerayı seçin
+await IVSBroadcast.selectCamera(sessionId, cameras[0].deviceId);
 ```
 
 ### Mikrofon Kontrolü
@@ -240,6 +259,58 @@ await IVSBroadcast.setMuted(sessionId, false);
 
 // Mikrofon durumunu kontrol et
 const isMuted = await IVSBroadcast.isMuted(sessionId);
+
+// Ses gain ayarla (0.0 = sessiz, 1.0 = normal, 2.0 = amplify)
+await IVSBroadcast.setAudioGain(sessionId, 1.5);
+
+// Mevcut gain seviyesini al
+const gain = await IVSBroadcast.getAudioGain(sessionId);
+
+// Mikrofon listesinden belirli bir mikrofonu seç
+const devices = await IVSBroadcast.listAvailableDevices();
+const microphones = devices.filter(d => d.type === 'microphone');
+
+// İstediğiniz mikrofonu seçin
+await IVSBroadcast.selectMicrophone(sessionId, microphones[0].deviceId);
+```
+
+### Gelişmiş Kamera Kontrolü
+
+```typescript
+// Zoom seviyesi ayarla
+await IVSBroadcast.setCameraZoom(sessionId, 2.0);
+
+// Flaşı aç/kapat
+await IVSBroadcast.setTorchEnabled(sessionId, true);
+
+// Kamera yeteneklerini al
+const capabilities = await IVSBroadcast.getCameraCapabilities(sessionId);
+console.log('Min zoom:', capabilities.minZoomFactor);
+console.log('Max zoom:', capabilities.maxZoomFactor);
+console.log('Torch supported:', capabilities.isTorchSupported);
+```
+
+### Cihaz Yönetimi
+
+```typescript
+// Kullanılabilir cihazları listele
+const availableDevices = await IVSBroadcast.listAvailableDevices();
+availableDevices.forEach(device => {
+  console.log(`${device.type}: ${device.friendlyName}`);
+});
+
+// Bağlı cihazları listele
+const attachedDevices = await IVSBroadcast.listAttachedDevices(sessionId);
+```
+
+### Zamanlı Metadata
+
+```typescript
+// Yayına senkronize metadata gönder
+await IVSBroadcast.sendTimedMetadata(sessionId, JSON.stringify({
+  timestamp: Date.now(),
+  customData: 'your data'
+}));
 ```
 
 ### Event Listener'lar
@@ -260,7 +331,7 @@ IVSBroadcast.addListener('onNetworkHealth', (health) => {
   console.log('Quality:', health.networkQuality);
 });
 
-// İstatistikler (iOS)
+// İstatistikler
 IVSBroadcast.addListener('onAudioStats', (stats) => {
   console.log('Audio bitrate:', stats.bitrate);
 });
@@ -268,13 +339,50 @@ IVSBroadcast.addListener('onAudioStats', (stats) => {
 IVSBroadcast.addListener('onVideoStats', (stats) => {
   console.log('Video bitrate:', stats.bitrate, 'FPS:', stats.fps);
 });
+
+// Gelişmiş istatistikler (transmission stats)
+IVSBroadcast.addListener('onTransmissionStatistics', (stats) => {
+  console.log('Measured bitrate:', stats.measuredBitrate);
+  console.log('Recommended bitrate:', stats.recommendedBitrate);
+  console.log('RTT:', stats.rtt);
+  console.log('Broadcast quality:', stats.broadcastQuality);
+  console.log('Network health:', stats.networkHealth);
+});
+
+// Ses cihazı istatistikleri
+IVSBroadcast.addListener('onAudioDeviceStats', (stats) => {
+  console.log('Peak:', stats.peak, 'RMS:', stats.rms);
+});
 ```
 
+### Picture-in-Picture (PiP)
+
+```typescript
+// PiP desteğini kontrol et
+const isSupported = await IVSBroadcast.isPictureInPictureSupported();
+if (isSupported) {
+  // PiP modunu başlat
+  await IVSBroadcast.startPictureInPicture(sessionId);
+  
+  // PiP durumunu kontrol et
+  const state = await IVSBroadcast.getPictureInPictureState(sessionId);
+  console.log('PiP state:', state); // 'idle', 'active', 'stopped'
+  
+  // PiP modunu durdur
+  await IVSBroadcast.stopPictureInPicture(sessionId);
+}
+```
+
+**Notlar:**
+- **iOS**: PiP desteği iOS 15.0+ gerektirir
+- **Android**: PiP desteği Android 8.0 (API 26)+ gerektirir
+- Android'de PiP için `AndroidManifest.xml` dosyanıza `android:supportsPictureInPicture="true"` eklemeniz gerekebilir
+
 ## Gereksinimler
 
 - React Native >= 0.60.0
-- Android: minSdkVersion 21
-- iOS: 11.0+
+- Android: minSdkVersion 21 (PiP için API 26+)
+- iOS: 11.0+ (PiP için iOS 15.0+)
 
 ## Lisans
 

package/android/src/main/java/com/reactnativeivsbroadcast/IVSBroadcastModule.kt

@@ -1,7 +1,11 @@
 package com.reactnativeivsbroadcast
 
 import android.Manifest
+import android.app.Activity
+import android.app.PictureInPictureParams
 import android.content.pm.PackageManager
+import android.os.Build
+import android.util.Rational
 import androidx.core.content.ContextCompat
 import com.amazonaws.ivs.broadcast.*
 import com.facebook.react.bridge.*
@@ -245,6 +249,7 @@ class IVSBroadcastModule(reactContext: ReactApplicationContext) :
             val url = sessionUrls[sessionId]
                 ?: throw IllegalArgumentException("Session URL not found: $sessionId")
 
+            // Android SDK'da URL direkt URI olarak kullanılıyor, streamKey URL içinde
             session.start(url)
             promise.resolve(null)
         } catch (e: Exception) {
@@ -362,6 +367,101 @@ class IVSBroadcastModule(reactContext: ReactApplicationContext) :
         }
     }
 
+    @ReactMethod
+    fun selectCamera(sessionId: String, deviceId: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            // Tüm kullanılabilir cihazları listele
+            val availableDevices = session.listAvailableDevices()
+            val targetCamera = availableDevices.find { 
+                it.type == Device.Descriptor.DeviceType.CAMERA && 
+                it.deviceId == deviceId
+            } ?: throw IllegalStateException("Camera with deviceId '$deviceId' not found")
+
+            // Mevcut kamerayı bul
+            val attachedDevices = session.listAttachedDevices()
+            val currentCamera = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.CAMERA 
+            }
+
+            // Kamera pozisyonunu güncelle
+            val position = if (targetCamera.position == Device.Descriptor.Position.FRONT) "front" else "back"
+
+            if (currentCamera != null) {
+                // Mevcut kamerayı yeni kamerayla değiştir
+                session.exchangeDevices(currentCamera, targetCamera) { newDevice ->
+                    if (newDevice != null) {
+                        currentCameraPosition[sessionId] = position
+                        // PreviewView'ları güncelle
+                        notifyPreviewViews(sessionId)
+                        promise.resolve(null)
+                    } else {
+                        promise.reject("SELECT_CAMERA_ERROR", "Failed to select camera")
+                    }
+                }
+            } else {
+                // Kamera yoksa yeni kamerayı ekle
+                session.attachDevice(targetCamera) { device ->
+                    if (device != null) {
+                        currentCameraPosition[sessionId] = position
+                        // PreviewView'ları güncelle
+                        notifyPreviewViews(sessionId)
+                        promise.resolve(null)
+                    } else {
+                        promise.reject("SELECT_CAMERA_ERROR", "Failed to attach camera")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("SELECT_CAMERA_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun selectMicrophone(sessionId: String, deviceId: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            // Tüm kullanılabilir cihazları listele
+            val availableDevices = session.listAvailableDevices()
+            val targetMicrophone = availableDevices.find { 
+                it.type == Device.Descriptor.DeviceType.MICROPHONE && 
+                it.deviceId == deviceId
+            } ?: throw IllegalStateException("Microphone with deviceId '$deviceId' not found")
+
+            // Mevcut mikrofonu bul
+            val attachedDevices = session.listAttachedDevices()
+            val currentMicrophone = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.MICROPHONE 
+            }
+
+            if (currentMicrophone != null) {
+                // Mevcut mikrofonu yeni mikrofonla değiştir
+                session.exchangeDevices(currentMicrophone, targetMicrophone) { newDevice ->
+                    if (newDevice != null) {
+                        promise.resolve(null)
+                    } else {
+                        promise.reject("SELECT_MICROPHONE_ERROR", "Failed to select microphone")
+                    }
+                }
+            } else {
+                // Mikrofon yoksa yeni mikrofonu ekle
+                session.attachDevice(targetMicrophone) { device ->
+                    if (device != null) {
+                        promise.resolve(null)
+                    } else {
+                        promise.reject("SELECT_MICROPHONE_ERROR", "Failed to attach microphone")
+                    }
+                }
+            }
+        } catch (e: Exception) {
+            promise.reject("SELECT_MICROPHONE_ERROR", e.message, e)
+        }
+    }
+
     private fun switchToCamera(session: BroadcastSession, sessionId: String, position: String) {
         val targetPosition = if (position == "front") 
             Device.Descriptor.Position.FRONT 
@@ -384,12 +484,16 @@ class IVSBroadcastModule(reactContext: ReactApplicationContext) :
             session.exchangeDevices(currentCamera, targetCamera) { newDevice ->
                 if (newDevice != null) {
                     currentCameraPosition[sessionId] = position
+                    // PreviewView'ları güncelle
+                    notifyPreviewViews(sessionId)
                 }
             }
         } else {
             session.attachDevice(targetCamera) { device ->
                 if (device != null) {
                     currentCameraPosition[sessionId] = position
+                    // PreviewView'ları güncelle
+                    notifyPreviewViews(sessionId)
                 }
             }
         }
@@ -459,4 +563,294 @@ class IVSBroadcastModule(reactContext: ReactApplicationContext) :
             // Event gönderimi başarısız olursa sessizce geç
         }
     }
+
+    // MARK: - Gelişmiş Özellikler
+
+    @ReactMethod
+    fun listAvailableDevices(promise: Promise) {
+        try {
+            val context = reactApplicationContext
+            val session = BroadcastSession(context, null, BroadcastConfiguration(), null)
+            val devices = session.listAvailableDevices()
+            
+            val deviceArray = Arguments.createArray()
+            devices.forEach { device ->
+                val deviceMap = Arguments.createMap().apply {
+                    putString("type", deviceTypeToString(device.type))
+                    putString("position", devicePositionToString(device.position))
+                    putString("deviceId", device.deviceId ?: "")
+                    putString("friendlyName", device.friendlyName ?: "")
+                    putBoolean("isDefault", device.isDefault)
+                }
+                deviceArray.pushMap(deviceMap)
+            }
+            
+            session.release()
+            promise.resolve(deviceArray)
+        } catch (e: Exception) {
+            promise.reject("LIST_DEVICES_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun listAttachedDevices(sessionId: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val devices = session.listAttachedDevices()
+            val deviceArray = Arguments.createArray()
+            
+            devices.forEach { device ->
+                val deviceMap = Arguments.createMap().apply {
+                    putString("type", deviceTypeToString(device.descriptor.type))
+                    putString("position", devicePositionToString(device.descriptor.position))
+                    putString("deviceId", device.descriptor.deviceId ?: "")
+                    putString("friendlyName", device.descriptor.friendlyName ?: "")
+                    putBoolean("isDefault", device.descriptor.isDefault)
+                }
+                deviceArray.pushMap(deviceMap)
+            }
+            
+            promise.resolve(deviceArray)
+        } catch (e: Exception) {
+            promise.reject("LIST_ATTACHED_DEVICES_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setCameraZoom(sessionId: String, zoomFactor: Double, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val attachedDevices = session.listAttachedDevices()
+            val cameraDevice = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.CAMERA 
+            } as? ImageDevice
+
+            if (cameraDevice != null) {
+                cameraDevice.setZoomFactor(zoomFactor.toFloat())
+                promise.resolve(null)
+            } else {
+                promise.reject("SET_ZOOM_ERROR", "Camera not found")
+            }
+        } catch (e: Exception) {
+            promise.reject("SET_ZOOM_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setTorchEnabled(sessionId: String, enabled: Boolean, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val attachedDevices = session.listAttachedDevices()
+            val cameraDevice = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.CAMERA 
+            } as? ImageDevice
+
+            if (cameraDevice != null) {
+                cameraDevice.setTorchEnabled(enabled)
+                promise.resolve(null)
+            } else {
+                promise.reject("SET_TORCH_ERROR", "Camera not found")
+            }
+        } catch (e: Exception) {
+            promise.reject("SET_TORCH_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getCameraCapabilities(sessionId: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val attachedDevices = session.listAttachedDevices()
+            val cameraDevice = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.CAMERA 
+            } as? ImageDevice
+
+            if (cameraDevice != null) {
+                val capabilities = Arguments.createMap().apply {
+                    putDouble("minZoomFactor", cameraDevice.minZoomFactor.toDouble())
+                    putDouble("maxZoomFactor", cameraDevice.maxZoomFactor.toDouble())
+                    putBoolean("isTorchSupported", cameraDevice.isTorchSupported)
+                }
+                promise.resolve(capabilities)
+            } else {
+                promise.reject("GET_CAPABILITIES_ERROR", "Camera not found")
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_CAPABILITIES_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun sendTimedMetadata(sessionId: String, metadata: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            session.sendTimedMetadata(metadata)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("SEND_METADATA_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun setAudioGain(sessionId: String, gain: Double, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val attachedDevices = session.listAttachedDevices()
+            val audioDevice = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.MICROPHONE 
+            } as? AudioDevice
+
+            if (audioDevice != null) {
+                audioDevice.setGain(gain.toFloat())
+                promise.resolve(null)
+            } else {
+                promise.reject("SET_GAIN_ERROR", "Microphone not found")
+            }
+        } catch (e: Exception) {
+            promise.reject("SET_GAIN_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getAudioGain(sessionId: String, promise: Promise) {
+        try {
+            val session = sessions[sessionId]
+                ?: throw IllegalArgumentException("Session not found: $sessionId")
+
+            val attachedDevices = session.listAttachedDevices()
+            val audioDevice = attachedDevices.find { 
+                it.descriptor.type == Device.Descriptor.DeviceType.MICROPHONE 
+            } as? AudioDevice
+
+            if (audioDevice != null) {
+                promise.resolve(audioDevice.gain.toDouble())
+            } else {
+                promise.reject("GET_GAIN_ERROR", "Microphone not found")
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_GAIN_ERROR", e.message, e)
+        }
+    }
+
+    // Helper methods
+    private fun deviceTypeToString(type: Device.Descriptor.DeviceType): String {
+        return when (type) {
+            Device.Descriptor.DeviceType.CAMERA -> "camera"
+            Device.Descriptor.DeviceType.MICROPHONE -> "microphone"
+            Device.Descriptor.DeviceType.USER_AUDIO -> "userAudio"
+            Device.Descriptor.DeviceType.USER_VIDEO -> "userVideo"
+            Device.Descriptor.DeviceType.USER_IMAGE -> "userVideo" // Android'de USER_IMAGE de USER_VIDEO olarak map ediyoruz
+            else -> "unknown"
+        }
+    }
+
+    private fun devicePositionToString(position: Device.Descriptor.Position): String {
+        return when (position) {
+            Device.Descriptor.Position.FRONT -> "front"
+            Device.Descriptor.Position.BACK -> "back"
+            else -> "unknown"
+        }
+    }
+
+    // MARK: - Picture-in-Picture
+
+    @ReactMethod
+    fun isPictureInPictureSupported(promise: Promise) {
+        try {
+            val supported = Build.VERSION.SDK_INT >= Build.VERSION_CODES.O
+            promise.resolve(supported)
+        } catch (e: Exception) {
+            promise.resolve(false)
+        }
+    }
+
+    @ReactMethod
+    fun startPictureInPicture(sessionId: String, promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                promise.reject("START_PIP_ERROR", "Picture-in-Picture requires Android 8.0 (API 26) or later")
+                return
+            }
+
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                promise.reject("START_PIP_ERROR", "Activity not found")
+                return
+            }
+
+            // PiP parametrelerini ayarla (16:9 aspect ratio)
+            val aspectRatio = Rational(16, 9)
+            val pipParams = PictureInPictureParams.Builder()
+                .setAspectRatio(aspectRatio)
+                .build()
+
+            activity.enterPictureInPictureMode(pipParams)
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("START_PIP_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun stopPictureInPicture(sessionId: String, promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                promise.reject("STOP_PIP_ERROR", "Picture-in-Picture requires Android 8.0 (API 26) or later")
+                return
+            }
+
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                promise.reject("STOP_PIP_ERROR", "Activity not found")
+                return
+            }
+
+            // Android'de PiP'den çıkmak için Activity'yi normal moda döndürmek gerekir
+            // Bu genellikle kullanıcı tarafından yapılır, ama programatik olarak da yapılabilir
+            if (activity.isInPictureInPictureMode) {
+                // Activity'yi normal moda döndür
+                activity.moveTaskToBack(true)
+            }
+            
+            promise.resolve(null)
+        } catch (e: Exception) {
+            promise.reject("STOP_PIP_ERROR", e.message, e)
+        }
+    }
+
+    @ReactMethod
+    fun getPictureInPictureState(sessionId: String, promise: Promise) {
+        try {
+            if (Build.VERSION.SDK_INT < Build.VERSION_CODES.O) {
+                promise.resolve("unsupported")
+                return
+            }
+
+            val activity = reactApplicationContext.currentActivity
+            if (activity == null) {
+                promise.resolve("idle")
+                return
+            }
+
+            if (activity.isInPictureInPictureMode) {
+                promise.resolve("active")
+            } else {
+                promise.resolve("idle")
+            }
+        } catch (e: Exception) {
+            promise.reject("GET_PIP_STATE_ERROR", e.message, e)
+        }
+    }
 }