@sbhjt-gr/react-native-webrtc 137.0.2

package/ios/RCTWebRTC/ScreenCaptureController.m

@@ -0,0 +1,83 @@
+#if TARGET_OS_IOS
+
+#import "ScreenCaptureController.h"
+#import "ScreenCapturer.h"
+#import "SocketConnection.h"
+
+NSString *const kRTCScreensharingSocketFD = @"rtc_SSFD";
+NSString *const kRTCAppGroupIdentifier = @"RTCAppGroupIdentifier";
+
+@interface ScreenCaptureController ()
+
+@property(nonatomic, retain) ScreenCapturer *capturer;
+
+@end
+
+@interface ScreenCaptureController (CapturerEventsDelegate)<CapturerEventsDelegate>
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer;
+@end
+
+@interface ScreenCaptureController (Private)
+
+@property(nonatomic, readonly) NSString *appGroupIdentifier;
+
+@end
+
+@implementation ScreenCaptureController
+
+- (instancetype)initWithCapturer:(nonnull ScreenCapturer *)capturer {
+    self = [super init];
+    if (self) {
+        self.capturer = capturer;
+        self.deviceId = @"screen-capture";
+    }
+
+    return self;
+}
+
+- (void)dealloc {
+    [self.capturer stopCapture];
+}
+
+- (void)startCapture {
+    if (!self.appGroupIdentifier) {
+        return;
+    }
+
+    self.capturer.eventsDelegate = self;
+    NSString *socketFilePath = [self filePathForApplicationGroupIdentifier:self.appGroupIdentifier];
+    SocketConnection *connection = [[SocketConnection alloc] initWithFilePath:socketFilePath];
+    [self.capturer startCaptureWithConnection:connection];
+}
+
+- (void)stopCapture {
+    [self.capturer stopCapture];
+}
+
+- (NSDictionary *)getSettings {
+    return @{@"deviceId" : self.deviceId, @"groupId" : @"", @"frameRate" : @(30)};
+}
+// MARK: CapturerEventsDelegate Methods
+
+- (void)capturerDidEnd:(RTCVideoCapturer *)capturer {
+    [self.eventsDelegate capturerDidEnd:capturer];
+}
+
+// MARK: Private Methods
+
+- (NSString *)appGroupIdentifier {
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    return infoDictionary[kRTCAppGroupIdentifier];
+}
+
+- (NSString *)filePathForApplicationGroupIdentifier:(nonnull NSString *)identifier {
+    NSURL *sharedContainer =
+        [[NSFileManager defaultManager] containerURLForSecurityApplicationGroupIdentifier:identifier];
+    NSString *socketFilePath = [[sharedContainer URLByAppendingPathComponent:kRTCScreensharingSocketFD] path];
+
+    return socketFilePath;
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/ScreenCapturePickerViewManager.h

@@ -0,0 +1,7 @@
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+API_AVAILABLE(ios(12))
+@interface ScreenCapturePickerViewManager : RCTViewManager
+
+@end

package/ios/RCTWebRTC/ScreenCapturePickerViewManager.m

@@ -0,0 +1,60 @@
+#if TARGET_OS_IOS
+
+#import <React/RCTUIManager.h>
+#import <ReplayKit/ReplayKit.h>
+
+#import "ScreenCapturePickerViewManager.h"
+
+NSString *const kRTCScreenSharingExtension = @"RTCScreenSharingExtension";
+
+@implementation ScreenCapturePickerViewManager {
+    RPSystemBroadcastPickerView *_broadcastPickerView;
+}
+
+RCT_EXPORT_MODULE()
+
+- (UIView *)view {
+    _broadcastPickerView = [[RPSystemBroadcastPickerView alloc] init];
+    _broadcastPickerView.preferredExtension = self.preferredExtension;
+    _broadcastPickerView.showsMicrophoneButton = false;
+    _broadcastPickerView.userInteractionEnabled = false;
+
+    return _broadcastPickerView;
+}
+
+// MARK: Private Methods
+
+- (NSString *)preferredExtension {
+    NSDictionary *infoDictionary = [[NSBundle mainBundle] infoDictionary];
+    return infoDictionary[kRTCScreenSharingExtension];
+}
+
+RCT_EXPORT_METHOD(show : (nonnull NSNumber *)reactTag) {
+    [self.bridge.uiManager
+        addUIBlock:^(__unused RCTUIManager *uiManager, NSDictionary<NSNumber *, UIView *> *viewRegistry) {
+            id view = viewRegistry[reactTag];
+            if (![view isKindOfClass:[RPSystemBroadcastPickerView class]]) {
+                RCTLogError(@"Invalid view returned from registry, expecting "
+                            @"RPSystemBroadcastPickerView, got: %@",
+                            view);
+            } else {
+                // Simulate a click
+                UIButton *btn = nil;
+
+                for (UIView *subview in ((RPSystemBroadcastPickerView *)view).subviews) {
+                    if ([subview isKindOfClass:[UIButton class]]) {
+                        btn = (UIButton *)subview;
+                    }
+                }
+                if (btn != nil) {
+                    [btn sendActionsForControlEvents:UIControlEventTouchUpInside];
+                } else {
+                    RCTLogError(@"RPSystemBroadcastPickerView button not found");
+                }
+            }
+        }];
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/ScreenCapturer.h

@@ -0,0 +1,19 @@
+#import <AVFoundation/AVFoundation.h>
+#import <WebRTC/RTCVideoCapturer.h>
+#import "CapturerEventsDelegate.h"
+
+NS_ASSUME_NONNULL_BEGIN
+
+@class SocketConnection;
+
+@interface ScreenCapturer : RTCVideoCapturer
+
+@property(nonatomic, weak) id<CapturerEventsDelegate> eventsDelegate;
+
+- (instancetype)initWithDelegate:(__weak id<RTCVideoCapturerDelegate>)delegate;
+- (void)startCaptureWithConnection:(nonnull SocketConnection *)connection;
+- (void)stopCapture;
+
+@end
+
+NS_ASSUME_NONNULL_END

package/ios/RCTWebRTC/ScreenCapturer.m

@@ -0,0 +1,264 @@
+#if TARGET_OS_IOS
+
+#include <mach/mach_time.h>
+
+#import <ReplayKit/ReplayKit.h>
+#import <WebRTC/RTCCVPixelBuffer.h>
+#import <WebRTC/RTCVideoFrameBuffer.h>
+
+#import "ScreenCapturer.h"
+#import "SocketConnection.h"
+
+const NSUInteger kMaxReadLength = 10 * 1024;
+
+@interface Message : NSObject
+
+@property(nonatomic, assign, readonly) CVImageBufferRef imageBuffer;
+@property(nonatomic, copy, nullable) void (^didComplete)(BOOL succes, Message *message);
+
+- (NSInteger)appendBytes:(UInt8 *)buffer length:(NSUInteger)length;
+
+@end
+
+@interface Message ()
+
+@property(nonatomic, assign) CVImageBufferRef imageBuffer;
+@property(nonatomic, assign) int imageOrientation;
+@property(nonatomic, assign) CFHTTPMessageRef framedMessage;
+
+@end
+
+@implementation Message
+
+- (instancetype)init {
+    self = [super init];
+    if (self) {
+        self.imageBuffer = NULL;
+    }
+
+    return self;
+}
+
+- (void)dealloc {
+    CVPixelBufferRelease(_imageBuffer);
+}
+
+/** Returns the amount of missing bytes to complete the message, or -1 when not enough bytes were provided to compute
+ * the message length */
+- (NSInteger)appendBytes:(UInt8 *)buffer length:(NSUInteger)length {
+    if (!_framedMessage) {
+        _framedMessage = CFHTTPMessageCreateEmpty(kCFAllocatorDefault, false);
+    }
+
+    CFHTTPMessageAppendBytes(_framedMessage, buffer, length);
+    if (!CFHTTPMessageIsHeaderComplete(_framedMessage)) {
+        return -1;
+    }
+
+    NSInteger contentLength =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Content-Length"))
+            integerValue];
+    NSInteger bodyLength = (NSInteger)[CFBridgingRelease(CFHTTPMessageCopyBody(_framedMessage)) length];
+
+    NSInteger missingBytesCount = contentLength - bodyLength;
+    if (missingBytesCount == 0) {
+        BOOL success = [self unwrapMessage:self.framedMessage];
+        self.didComplete(success, self);
+
+        CFRelease(self.framedMessage);
+        self.framedMessage = NULL;
+    }
+
+    return missingBytesCount;
+}
+
+// MARK: Private Methods
+
+- (CIContext *)imageContext {
+    // Initializing a CIContext object is costly, so we use a singleton instead
+    static CIContext *imageContext = nil;
+    static dispatch_once_t onceToken;
+    dispatch_once(&onceToken, ^{
+        imageContext = [[CIContext alloc] initWithOptions:nil];
+    });
+
+    return imageContext;
+}
+
+- (BOOL)unwrapMessage:(CFHTTPMessageRef)framedMessage {
+    size_t width =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Width"))
+            integerValue];
+    size_t height =
+        [CFBridgingRelease(CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Height"))
+            integerValue];
+    _imageOrientation = [CFBridgingRelease(
+        CFHTTPMessageCopyHeaderFieldValue(_framedMessage, (__bridge CFStringRef) @"Buffer-Orientation")) intValue];
+
+    NSData *messageData = CFBridgingRelease(CFHTTPMessageCopyBody(_framedMessage));
+
+    // Copy the pixel buffer
+    CVReturn status =
+        CVPixelBufferCreate(kCFAllocatorDefault, width, height, kCVPixelFormatType_32BGRA, NULL, &_imageBuffer);
+    if (status != kCVReturnSuccess) {
+        NSLog(@"CVPixelBufferCreate failed");
+        return false;
+    }
+
+    [self copyImageData:messageData toPixelBuffer:&_imageBuffer];
+
+    return true;
+}
+
+- (void)copyImageData:(NSData *)data toPixelBuffer:(CVPixelBufferRef *)pixelBuffer {
+    CVPixelBufferLockBaseAddress(*pixelBuffer, 0);
+
+    CIImage *image = [CIImage imageWithData:data];
+    [self.imageContext render:image toCVPixelBuffer:*pixelBuffer];
+
+    CVPixelBufferUnlockBaseAddress(*pixelBuffer, 0);
+}
+
+@end
+
+// MARK: -
+
+@interface ScreenCapturer ()<NSStreamDelegate>
+
+@property(nonatomic, strong) SocketConnection *connection;
+@property(nonatomic, strong) Message *message;
+
+@end
+
+@implementation ScreenCapturer {
+    mach_timebase_info_data_t _timebaseInfo;
+    NSInteger _readLength;
+    int64_t _startTimeStampNs;
+}
+
+- (instancetype)initWithDelegate:(__weak id<RTCVideoCapturerDelegate>)delegate {
+    self = [super initWithDelegate:delegate];
+    if (self) {
+        mach_timebase_info(&_timebaseInfo);
+    }
+
+    return self;
+}
+
+- (void)setConnection:(SocketConnection *)connection {
+    if (_connection != connection) {
+        [_connection close];
+        _connection = connection;
+    }
+}
+
+- (void)startCaptureWithConnection:(SocketConnection *)connection {
+    _startTimeStampNs = -1;
+
+    self.connection = connection;
+    self.message = nil;
+
+    [self.connection openWithStreamDelegate:self];
+}
+
+- (void)stopCapture {
+    self.connection = nil;
+}
+
+// MARK: Private Methods
+
+- (void)readBytesFromStream:(NSInputStream *)stream {
+    if (!stream.hasBytesAvailable) {
+        return;
+    }
+
+    if (!self.message) {
+        self.message = [[Message alloc] init];
+        _readLength = kMaxReadLength;
+
+        __weak __typeof__(self) weakSelf = self;
+        self.message.didComplete = ^(BOOL success, Message *message) {
+            if (success) {
+                [weakSelf didCaptureVideoFrame:message.imageBuffer withOrientation:message.imageOrientation];
+            }
+
+            weakSelf.message = nil;
+        };
+    }
+
+    uint8_t buffer[_readLength];
+    NSInteger numberOfBytesRead = [stream read:buffer maxLength:_readLength];
+    if (numberOfBytesRead < 0) {
+        NSLog(@"error reading bytes from stream");
+        return;
+    }
+
+    _readLength = [self.message appendBytes:buffer length:numberOfBytesRead];
+    if (_readLength == -1 || _readLength > kMaxReadLength) {
+        _readLength = kMaxReadLength;
+    }
+}
+
+- (void)didCaptureVideoFrame:(CVPixelBufferRef)pixelBuffer withOrientation:(CGImagePropertyOrientation)orientation {
+    int64_t currentTime = mach_absolute_time();
+    int64_t currentTimeStampNs = currentTime * _timebaseInfo.numer / _timebaseInfo.denom;
+
+    if (_startTimeStampNs < 0) {
+        _startTimeStampNs = currentTimeStampNs;
+    }
+
+    RTCCVPixelBuffer *rtcPixelBuffer = [[RTCCVPixelBuffer alloc] initWithPixelBuffer:pixelBuffer];
+    int64_t frameTimeStampNs = currentTimeStampNs - _startTimeStampNs;
+
+    RTCVideoRotation rotation;
+    switch (orientation) {
+        case kCGImagePropertyOrientationLeft:
+            rotation = RTCVideoRotation_90;
+            break;
+        case kCGImagePropertyOrientationDown:
+            rotation = RTCVideoRotation_180;
+            break;
+        case kCGImagePropertyOrientationRight:
+            rotation = RTCVideoRotation_270;
+            break;
+        default:
+            rotation = RTCVideoRotation_0;
+            break;
+    }
+
+    RTCVideoFrame *videoFrame = [[RTCVideoFrame alloc] initWithBuffer:rtcPixelBuffer
+                                                             rotation:rotation
+                                                          timeStampNs:frameTimeStampNs];
+
+    [self.delegate capturer:self didCaptureVideoFrame:videoFrame];
+}
+
+@end
+
+@implementation ScreenCapturer (NSStreamDelegate)
+
+- (void)stream:(NSStream *)aStream handleEvent:(NSStreamEvent)eventCode {
+    switch (eventCode) {
+        case NSStreamEventOpenCompleted:
+            NSLog(@"server stream open completed");
+            break;
+        case NSStreamEventHasBytesAvailable:
+            [self readBytesFromStream:(NSInputStream *)aStream];
+            break;
+        case NSStreamEventEndEncountered:
+            NSLog(@"server stream end encountered");
+            [self stopCapture];
+            [self.eventsDelegate capturerDidEnd:self];
+            break;
+        case NSStreamEventErrorOccurred:
+            NSLog(@"server stream error encountered: %@", aStream.streamError.localizedDescription);
+            break;
+
+        default:
+            break;
+    }
+}
+
+@end
+
+#endif

package/ios/RCTWebRTC/SerializeUtils.h

@@ -0,0 +1,28 @@
+#import <WebRTC/RTCMediaStreamTrack.h>
+#import <WebRTC/RTCPeerConnectionFactory.h>
+#import <WebRTC/RTCRtpReceiver.h>
+#import <WebRTC/RTCRtpTransceiver.h>
+#import <WebRTC/RTCVideoCodecInfo.h>
+#import "WebRTCModule+RTCPeerConnection.h"
+
+@interface SerializeUtils : NSObject
+
++ (NSString *_Nonnull)transceiverToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                transceiver:(RTCRtpTransceiver *_Nonnull)transceiver;
++ (NSDictionary *_Nonnull)senderToJSONWithPeerConnectionId:(nonnull NSNumber *)id sender:(RTCRtpSender *_Nonnull)sender;
++ (NSDictionary *_Nonnull)receiverToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                    receiver:(RTCRtpReceiver *_Nonnull)receiver;
++ (NSDictionary *_Nonnull)trackToJSONWithPeerConnectionId:(nonnull NSNumber *)id
+                                                    track:(RTCMediaStreamTrack *_Nonnull)track;
++ (NSDictionary *_Nonnull)capabilitiesToJSON:(RTCRtpCapabilities *_Nonnull)capabilities;
++ (NSDictionary *_Nonnull)codecCapabilityToJSON:(RTCRtpCodecCapability *_Nonnull)codec;
++ (NSString *_Nonnull)serializeDirection:(RTCRtpTransceiverDirection)direction;
++ (RTCRtpTransceiverDirection)parseDirection:(NSString *_Nonnull)direction;
++ (RTCRtpTransceiverInit *_Nonnull)parseTransceiverOptions:(NSDictionary *_Nonnull)parameters;
++ (NSDictionary *_Nonnull)parametersToJSON:(RTCRtpParameters *_Nonnull)parameters;
++ (NSMutableArray *_Nonnull)constructTransceiversInfoArrayWithPeerConnection:
+    (RTCPeerConnection *_Nonnull)peerConnection;
++ (NSDictionary *_Nonnull)streamToJSONWithPeerConnectionId:(NSNumber *_Nonnull)id
+                                                    stream:(RTCMediaStream *_Nonnull)stream
+                                            streamReactTag:(NSString *_Nonnull)streamReactTag;
+@end