@sbhjt-gr/react-native-webrtc 124.0.2 → 124.0.4

package/ios/RCTWebRTC/WLVAudioDevice.h

@@ -1,12 +1,12 @@
-#import <Foundation/Foundation.h>
-#import <WebRTC/RTCAudioDevice.h>
-
-NS_ASSUME_NONNULL_BEGIN
-
-@interface WLVAudioDevice : NSObject <RTCAudioDevice>
-
-- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels;
-
-@end
-
-NS_ASSUME_NONNULL_END
+#import <Foundation/Foundation.h>
+#import <WebRTC/RTCAudioDevice.h>
+
+NS_ASSUME_NONNULL_BEGIN
+
+@interface WLVAudioDevice : NSObject <RTCAudioDevice>
+
+- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/WLVAudioDevice.m

@@ -1,137 +1,137 @@
-#import "WLVAudioDevice.h"
-
-#import <AudioUnit/AudioUnit.h>
-#import <WebRTC/WebRTC.h>
-
-@implementation WLVAudioDevice {
-    id<RTCAudioDeviceDelegate> _delegate;
-    double _sampleRate;
-    NSInteger _channels;
-    BOOL _isInitialized;
-    BOOL _isRecording;
-}
-
-#pragma mark - RTCAudioDevice properties
-
-- (double)deviceInputSampleRate {
-    return _sampleRate > 0 ? _sampleRate : 48000.0;
-}
-
-- (NSTimeInterval)inputIOBufferDuration {
-    return 0.01;
-}
-
-- (NSInteger)inputNumberOfChannels {
-    return _channels > 0 ? _channels : 1;
-}
-
-- (NSTimeInterval)inputLatency {
-    return 0.0;
-}
-
-- (double)deviceOutputSampleRate {
-    return 48000.0;
-}
-
-- (NSTimeInterval)outputIOBufferDuration {
-    return 0.01;
-}
-
-- (NSInteger)outputNumberOfChannels {
-    return 1;
-}
-
-- (NSTimeInterval)outputLatency {
-    return 0.0;
-}
-
-- (BOOL)isInitialized {
-    return _isInitialized;
-}
-
-- (BOOL)initializeWithDelegate:(id<RTCAudioDeviceDelegate>)delegate {
-    _delegate = delegate;
-    _isInitialized = YES;
-    return YES;
-}
-
-- (BOOL)terminateDevice {
-    _delegate = nil;
-    _isInitialized = NO;
-    _isRecording = NO;
-    return YES;
-}
-
-- (BOOL)isPlayoutInitialized {
-    return YES;
-}
-
-- (BOOL)initializePlayout {
-    return YES;
-}
-
-- (BOOL)isPlaying {
-    return NO;
-}
-
-- (BOOL)startPlayout {
-    return YES;
-}
-
-- (BOOL)stopPlayout {
-    return YES;
-}
-
-- (BOOL)isRecordingInitialized {
-    return YES;
-}
-
-- (BOOL)initializeRecording {
-    return YES;
-}
-
-- (BOOL)isRecording {
-    return _isRecording;
-}
-
-- (BOOL)startRecording {
-    _isRecording = YES;
-    return YES;
-}
-
-- (BOOL)stopRecording {
-    _isRecording = NO;
-    return YES;
-}
-
-#pragma mark - Push API
-
-- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels {
-    id<RTCAudioDeviceDelegate> delegate = _delegate;
-    if (!delegate || data.length == 0 || channels <= 0) {
-        return;
-    }
-
-    _sampleRate = sampleRate;
-    _channels = channels;
-
-    NSUInteger frameCount = data.length / (sizeof(int16_t) * (NSUInteger)channels);
-    if (frameCount == 0) {
-        return;
-    }
-
-    AudioBufferList bufferList;
-    bufferList.mNumberBuffers = 1;
-    bufferList.mBuffers[0].mNumberChannels = (UInt32)channels;
-    bufferList.mBuffers[0].mDataByteSize = (UInt32)data.length;
-    bufferList.mBuffers[0].mData = (void *)data.bytes;
-
-    AudioUnitRenderActionFlags flags = 0;
-    AudioTimeStamp timestamp = {0};
-    timestamp.mFlags = kAudioTimeStampSampleTimeValid;
-
-    RTCAudioDeviceDeliverRecordedDataBlock deliverBlock = delegate.deliverRecordedData;
-    deliverBlock(&flags, &timestamp, 0, (UInt32)frameCount, &bufferList, nil, nil);
-}
-
-@end
+#import "WLVAudioDevice.h"
+
+#import <AudioUnit/AudioUnit.h>
+#import <WebRTC/WebRTC.h>
+
+@implementation WLVAudioDevice {
+    id<RTCAudioDeviceDelegate> _delegate;
+    double _sampleRate;
+    NSInteger _channels;
+    BOOL _isInitialized;
+    BOOL _isRecording;
+}
+
+#pragma mark - RTCAudioDevice properties
+
+- (double)deviceInputSampleRate {
+    return _sampleRate > 0 ? _sampleRate : 48000.0;
+}
+
+- (NSTimeInterval)inputIOBufferDuration {
+    return 0.01;
+}
+
+- (NSInteger)inputNumberOfChannels {
+    return _channels > 0 ? _channels : 1;
+}
+
+- (NSTimeInterval)inputLatency {
+    return 0.0;
+}
+
+- (double)deviceOutputSampleRate {
+    return 48000.0;
+}
+
+- (NSTimeInterval)outputIOBufferDuration {
+    return 0.01;
+}
+
+- (NSInteger)outputNumberOfChannels {
+    return 1;
+}
+
+- (NSTimeInterval)outputLatency {
+    return 0.0;
+}
+
+- (BOOL)isInitialized {
+    return _isInitialized;
+}
+
+- (BOOL)initializeWithDelegate:(id<RTCAudioDeviceDelegate>)delegate {
+    _delegate = delegate;
+    _isInitialized = YES;
+    return YES;
+}
+
+- (BOOL)terminateDevice {
+    _delegate = nil;
+    _isInitialized = NO;
+    _isRecording = NO;
+    return YES;
+}
+
+- (BOOL)isPlayoutInitialized {
+    return YES;
+}
+
+- (BOOL)initializePlayout {
+    return YES;
+}
+
+- (BOOL)isPlaying {
+    return NO;
+}
+
+- (BOOL)startPlayout {
+    return YES;
+}
+
+- (BOOL)stopPlayout {
+    return YES;
+}
+
+- (BOOL)isRecordingInitialized {
+    return YES;
+}
+
+- (BOOL)initializeRecording {
+    return YES;
+}
+
+- (BOOL)isRecording {
+    return _isRecording;
+}
+
+- (BOOL)startRecording {
+    _isRecording = YES;
+    return YES;
+}
+
+- (BOOL)stopRecording {
+    _isRecording = NO;
+    return YES;
+}
+
+#pragma mark - Push API
+
+- (void)pushAudioData:(NSData *)data sampleRate:(double)sampleRate channels:(NSInteger)channels {
+    id<RTCAudioDeviceDelegate> delegate = _delegate;
+    if (!delegate || data.length == 0 || channels <= 0) {
+        return;
+    }
+
+    _sampleRate = sampleRate;
+    _channels = channels;
+
+    NSUInteger frameCount = data.length / (sizeof(int16_t) * (NSUInteger)channels);
+    if (frameCount == 0) {
+        return;
+    }
+
+    AudioBufferList bufferList;
+    bufferList.mNumberBuffers = 1;
+    bufferList.mBuffers[0].mNumberChannels = (UInt32)channels;
+    bufferList.mBuffers[0].mDataByteSize = (UInt32)data.length;
+    bufferList.mBuffers[0].mData = (void *)data.bytes;
+
+    AudioUnitRenderActionFlags flags = 0;
+    AudioTimeStamp timestamp = {0};
+    timestamp.mFlags = kAudioTimeStampSampleTimeValid;
+
+    RTCAudioDeviceDeliverRecordedDataBlock deliverBlock = delegate.deliverRecordedData;
+    deliverBlock(&flags, &timestamp, 0, (UInt32)frameCount, &bufferList, nil, nil);
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule+Palabra.h

@@ -1,4 +1,4 @@
-#import "WebRTCModule.h"
-
-@interface WebRTCModule (Palabra)
-@end
+#import "WebRTCModule.h"
+
+@interface WebRTCModule (Palabra)
+@end

package/ios/RCTWebRTC/WebRTCModule+Palabra.m

@@ -1,83 +1,92 @@
-#import "WebRTCModule+Palabra.h"
-#import "WebRTCModule+RTCPeerConnection.h"
-#import "PalabraClient.h"
-
-@implementation WebRTCModule (Palabra)
-
-RCT_EXPORT_METHOD(startPalabraTranslation
-                  : (nonnull NSNumber *)peerConnectionId trackId
-                  : (NSString *)trackId clientId
-                  : (NSString *)clientId clientSecret
-                  : (NSString *)clientSecret sourceLang
-                  : (NSString *)sourceLang targetLang
-                  : (NSString *)targetLang apiUrl
-                  : (NSString *)apiUrl resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    
-    RTCPeerConnection *peerConnection = self.peerConnections[peerConnectionId];
-    if (!peerConnection) {
-        reject(@"E_INVALID", @"pc_not_found", nil);
-        return;
-    }
-    
-    RTCMediaStreamTrack *track = peerConnection.remoteTracks[trackId];
-    if (!track) {
-        reject(@"E_INVALID", @"track_not_found", nil);
-        return;
-    }
-    
-    if (![track.kind isEqualToString:@"audio"]) {
-        reject(@"E_INVALID", @"not_audio_track", nil);
-        return;
-    }
-    
-    RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
-    
-    if (self.palabraClient) {
-        [self.palabraClient stop];
-    }
-    
-    self.palabraClient = [[PalabraClient alloc] initWithClientId:clientId
-                                                    clientSecret:clientSecret
-                                                          apiUrl:apiUrl
-                                                          module:self];
-    self.palabraClient.delegate = self;
-    
-    [self.palabraClient startWithTrack:audioTrack
-                            sourceLang:sourceLang
-                            targetLang:targetLang];
-    
-    resolve(nil);
-}
-
-RCT_EXPORT_METHOD(stopPalabraTranslation
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-    
-    if (self.palabraClient) {
-        [self.palabraClient stop];
-        self.palabraClient = nil;
-    }
-    
-    resolve(nil);
-}
-
-#pragma mark - PalabraClientDelegate
-
-- (void)palabraDidReceiveTranscription:(NSDictionary *)transcription {
-    [self sendEventWithName:kEventPalabraTranscription body:transcription];
-}
-
-- (void)palabraDidChangeConnectionState:(NSString *)state {
-    [self sendEventWithName:kEventPalabraConnectionState body:@{@"state": state}];
-}
-
-- (void)palabraDidFailWithError:(NSError *)error {
-    [self sendEventWithName:kEventPalabraError body:@{
-        @"code": @(error.code),
-        @"message": error.localizedDescription ?: @"unknown_error"
-    }];
-}
-
-@end
+#import "WebRTCModule+Palabra.h"
+#import "WebRTCModule+RTCPeerConnection.h"
+#import "PalabraClient.h"
+
+@implementation WebRTCModule (Palabra)
+
+RCT_EXPORT_METHOD(startPalabraTranslation
+                  : (nonnull NSNumber *)peerConnectionId trackId
+                  : (NSString *)trackId clientId
+                  : (NSString *)clientId clientSecret
+                  : (NSString *)clientSecret sourceLang
+                  : (NSString *)sourceLang targetLang
+                  : (NSString *)targetLang apiUrl
+                  : (NSString *)apiUrl resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    
+    RTCPeerConnection *peerConnection = self.peerConnections[peerConnectionId];
+    if (!peerConnection) {
+        reject(@"E_INVALID", @"pc_not_found", nil);
+        return;
+    }
+    
+    RTCMediaStreamTrack *track = peerConnection.remoteTracks[trackId];
+    if (!track) {
+        reject(@"E_INVALID", @"track_not_found", nil);
+        return;
+    }
+    
+    if (![track.kind isEqualToString:@"audio"]) {
+        reject(@"E_INVALID", @"not_audio_track", nil);
+        return;
+    }
+    
+    RTCAudioTrack *audioTrack = (RTCAudioTrack *)track;
+    
+    if (self.palabraClient) {
+        if ([self.palabraClient matchesSessionWithTrackId:trackId
+                                               sourceLang:sourceLang
+                                               targetLang:targetLang
+                                                    apiUrl:apiUrl] && self.palabraClient.isRunning) {
+            NSLog(@"palabra_start_reuse");
+            resolve(nil);
+            return;
+        }
+        NSLog(@"palabra_start_restart");
+        [self.palabraClient stop];
+    }
+    
+    self.palabraClient = [[PalabraClient alloc] initWithClientId:clientId
+                                                    clientSecret:clientSecret
+                                                          apiUrl:apiUrl
+                                                          module:self];
+    self.palabraClient.delegate = self;
+    
+    [self.palabraClient startWithTrack:audioTrack
+                            sourceLang:sourceLang
+                            targetLang:targetLang];
+    
+    resolve(nil);
+}
+
+RCT_EXPORT_METHOD(stopPalabraTranslation
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+    
+    if (self.palabraClient) {
+        [self.palabraClient stop];
+        self.palabraClient = nil;
+    }
+    
+    resolve(nil);
+}
+
+#pragma mark - PalabraClientDelegate
+
+- (void)palabraDidReceiveTranscription:(NSDictionary *)transcription {
+    [self sendEventWithName:kEventPalabraTranscription body:transcription];
+}
+
+- (void)palabraDidChangeConnectionState:(NSString *)state {
+    [self sendEventWithName:kEventPalabraConnectionState body:@{@"state": state}];
+}
+
+- (void)palabraDidFailWithError:(NSError *)error {
+    [self sendEventWithName:kEventPalabraError body:@{
+        @"code": @(error.code),
+        @"message": error.localizedDescription ?: @"unknown_error"
+    }];
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule+Permissions.m

@@ -1,75 +1,75 @@
-
-#import <AVFoundation/AVFoundation.h>
-
-#import "WebRTCModule.h"
-
-static NSString *const PERMISSION_DENIED = @"denied";
-static NSString *const PERMISSION_GRANTED = @"granted";
-static NSString *const PERMISSION_PROMPT = @"prompt";
-
-@implementation WebRTCModule (Permissions)
-
-- (AVMediaType)avMediaType:(NSString *)mediaType {
-    if ([mediaType isEqualToString:@"microphone"]) {
-        return AVMediaTypeAudio;
-    } else if ([mediaType isEqualToString:@"camera"]) {
-        return AVMediaTypeVideo;
-    } else {
-        return nil;
-    }
-}
-
-RCT_EXPORT_METHOD(checkPermission
-                  : (NSString *)mediaType resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-#if TARGET_OS_TV
-    resolve(@"tvOS is not supported");
-    return;
-#else
-    AVMediaType mediaType_ = [self avMediaType:mediaType];
-
-    if (mediaType_ == nil) {
-        reject(@"invalid_type", @"Invalid media type", nil);
-        return;
-    }
-    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:mediaType_];
-    switch (status) {
-        case AVAuthorizationStatusAuthorized:
-            resolve(PERMISSION_GRANTED);
-            break;
-
-        case AVAuthorizationStatusNotDetermined:
-            resolve(PERMISSION_PROMPT);
-            break;
-
-        default:
-            resolve(PERMISSION_DENIED);
-            break;
-    }
-#endif
-}
-
-RCT_EXPORT_METHOD(requestPermission
-                  : (NSString *)mediaType resolver
-                  : (RCTPromiseResolveBlock)resolve rejecter
-                  : (RCTPromiseRejectBlock)reject) {
-#if TARGET_OS_TV
-    resolve(@"tvOS is not supported");
-    return;
-#else
-    AVMediaType mediaType_ = [self avMediaType:mediaType];
-
-    if (mediaType_ == nil) {
-        reject(@"invalid_type", @"Invalid media type", nil);
-        return;
-    }
-
-    [AVCaptureDevice requestAccessForMediaType:mediaType_
-                             completionHandler:^(BOOL granted) {
-                                 resolve(@(granted));
-                             }];
-#endif
-}
-
-@end
+
+#import <AVFoundation/AVFoundation.h>
+
+#import "WebRTCModule.h"
+
+static NSString *const PERMISSION_DENIED = @"denied";
+static NSString *const PERMISSION_GRANTED = @"granted";
+static NSString *const PERMISSION_PROMPT = @"prompt";
+
+@implementation WebRTCModule (Permissions)
+
+- (AVMediaType)avMediaType:(NSString *)mediaType {
+    if ([mediaType isEqualToString:@"microphone"]) {
+        return AVMediaTypeAudio;
+    } else if ([mediaType isEqualToString:@"camera"]) {
+        return AVMediaTypeVideo;
+    } else {
+        return nil;
+    }
+}
+
+RCT_EXPORT_METHOD(checkPermission
+                  : (NSString *)mediaType resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    resolve(@"tvOS is not supported");
+    return;
+#else
+    AVMediaType mediaType_ = [self avMediaType:mediaType];
+
+    if (mediaType_ == nil) {
+        reject(@"invalid_type", @"Invalid media type", nil);
+        return;
+    }
+    AVAuthorizationStatus status = [AVCaptureDevice authorizationStatusForMediaType:mediaType_];
+    switch (status) {
+        case AVAuthorizationStatusAuthorized:
+            resolve(PERMISSION_GRANTED);
+            break;
+
+        case AVAuthorizationStatusNotDetermined:
+            resolve(PERMISSION_PROMPT);
+            break;
+
+        default:
+            resolve(PERMISSION_DENIED);
+            break;
+    }
+#endif
+}
+
+RCT_EXPORT_METHOD(requestPermission
+                  : (NSString *)mediaType resolver
+                  : (RCTPromiseResolveBlock)resolve rejecter
+                  : (RCTPromiseRejectBlock)reject) {
+#if TARGET_OS_TV
+    resolve(@"tvOS is not supported");
+    return;
+#else
+    AVMediaType mediaType_ = [self avMediaType:mediaType];
+
+    if (mediaType_ == nil) {
+        reject(@"invalid_type", @"Invalid media type", nil);
+        return;
+    }
+
+    [AVCaptureDevice requestAccessForMediaType:mediaType_
+                             completionHandler:^(BOOL granted) {
+                                 resolve(@(granted));
+                             }];
+#endif
+}
+
+@end

package/ios/RCTWebRTC/WebRTCModule+RTCAudioSession.m

@@ -1,20 +1,20 @@
-#import <objc/runtime.h>
-
-#import <React/RCTBridge.h>
-#import <React/RCTBridgeModule.h>
-
-#import "WebRTCModule.h"
-
-@implementation WebRTCModule (RTCAudioSession)
-
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(audioSessionDidActivate) {
-    [[RTCAudioSession sharedInstance] audioSessionDidActivate:[AVAudioSession sharedInstance]];
-    return nil;
-}
-
-RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(audioSessionDidDeactivate) {
-    [[RTCAudioSession sharedInstance] audioSessionDidDeactivate:[AVAudioSession sharedInstance]];
-    return nil;
-}
-
-@end
+#import <objc/runtime.h>
+
+#import <React/RCTBridge.h>
+#import <React/RCTBridgeModule.h>
+
+#import "WebRTCModule.h"
+
+@implementation WebRTCModule (RTCAudioSession)
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(audioSessionDidActivate) {
+    [[RTCAudioSession sharedInstance] audioSessionDidActivate:[AVAudioSession sharedInstance]];
+    return nil;
+}
+
+RCT_EXPORT_BLOCKING_SYNCHRONOUS_METHOD(audioSessionDidDeactivate) {
+    [[RTCAudioSession sharedInstance] audioSessionDidDeactivate:[AVAudioSession sharedInstance]];
+    return nil;
+}
+
+@end