@cloudflare/realtimekit-react-native 0.0.0 → 0.0.1-staging.2

package/ios/permissions/DyteRNPermissionHandlerBluetoothPeripheral.h

@@ -0,0 +1,4 @@
+#import "DyteRNPermissions.h"
+@interface DyteRNPermissionHandlerBluetoothPeripheral : NSObject<DyteRNPermissionHandler>
+
+@end

package/ios/permissions/DyteRNPermissionHandlerBluetoothPeripheral.m

@@ -0,0 +1,87 @@
+#import "DyteRNPermissionHandlerBluetoothPeripheral.h"
+
+@import CoreBluetooth;
+
+@interface DyteRNPermissionHandlerBluetoothPeripheral() <CBPeripheralManagerDelegate>
+
+@property (nonatomic, strong) CBPeripheralManager* manager;
+@property (nonatomic, strong) void (^resolve)(RNPermissionStatus status);
+@property (nonatomic, strong) void (^reject)(NSError *error);
+
+@end
+
+@implementation DyteRNPermissionHandlerBluetoothPeripheral
+
++ (NSArray<NSString *> * _Nonnull)usageDescriptionKeys {
+  return @[
+    @"NSBluetoothPeripheralUsageDescription",
+    @"NSBluetoothAlwaysUsageDescription",
+  ];
+}
+
++ (NSString * _Nonnull)handlerUniqueId {
+  return @"ios.permission.BLUETOOTH_PERIPHERAL";
+}
+
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                 rejecter:(void (__unused ^ _Nonnull)(NSError * _Nonnull))reject {
+#if TARGET_OS_SIMULATOR
+  return resolve(RNPermissionStatusNotAvailable);
+#else
+
+  if (@available(iOS 13.1, *)) {
+    switch ([CBManager authorization]) {
+      case CBManagerAuthorizationNotDetermined:
+        return resolve(RNPermissionStatusNotDetermined);
+      case CBManagerAuthorizationRestricted:
+        return resolve(RNPermissionStatusRestricted);
+      case CBManagerAuthorizationDenied:
+        return resolve(RNPermissionStatusDenied);
+      case CBManagerAuthorizationAllowedAlways:
+        return resolve(RNPermissionStatusAuthorized);
+    }
+  } else {
+    switch ([CBPeripheralManager authorizationStatus]) {
+      case CBPeripheralManagerAuthorizationStatusNotDetermined:
+        return resolve(RNPermissionStatusNotDetermined);
+      case CBPeripheralManagerAuthorizationStatusRestricted:
+        return resolve(RNPermissionStatusRestricted);
+      case CBPeripheralManagerAuthorizationStatusDenied:
+        return resolve(RNPermissionStatusDenied);
+      case CBPeripheralManagerAuthorizationStatusAuthorized:
+        return resolve(RNPermissionStatusAuthorized);
+    }
+  }
+#endif
+}
+
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject {
+#if TARGET_OS_SIMULATOR
+  return resolve(RNPermissionStatusNotAvailable);
+#else
+  _resolve = resolve;
+  _reject = reject;
+
+  _manager = [[CBPeripheralManager alloc] initWithDelegate:self queue:nil options:@{
+    CBPeripheralManagerOptionShowPowerAlertKey: @false,
+  }];
+#endif
+}
+
+- (void)peripheralManagerDidUpdateState:(nonnull CBPeripheralManager *)peripheral {
+  switch (peripheral.state) {
+    case CBManagerStatePoweredOff:
+    case CBManagerStateResetting:
+    case CBManagerStateUnsupported:
+      return _resolve(RNPermissionStatusNotAvailable);
+    case CBManagerStateUnknown:
+      return _resolve(RNPermissionStatusNotDetermined);
+    case CBManagerStateUnauthorized:
+      return _resolve(RNPermissionStatusDenied);
+    case CBManagerStatePoweredOn:
+      return [self checkWithResolver:_resolve rejecter:_reject];
+  }
+}
+
+@end

package/ios/permissions/DyteRNPermissionHandlerCamera.h

@@ -0,0 +1,5 @@
+#import "DyteRNPermissions.h"
+
+@interface DyteRNPermissionHandlerCamera : NSObject<DyteRNPermissionHandler>
+
+@end

package/ios/permissions/DyteRNPermissionHandlerCamera.m

@@ -0,0 +1,38 @@
+#import "DyteRNPermissionHandlerCamera.h"
+//#import <React/RCTLog.h>
+
+@import AVFoundation;
+
+@implementation DyteRNPermissionHandlerCamera
+
++ (NSArray<NSString *> * _Nonnull)usageDescriptionKeys {
+  return @[@"NSCameraUsageDescription"];
+}
+
++ (NSString * _Nonnull)handlerUniqueId {
+  return @"ios.permission.CAMERA";
+}
+
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                 rejecter:(void (__unused ^ _Nonnull)(NSError * _Nonnull))reject {
+  switch ([AVCaptureDevice authorizationStatusForMediaType:AVMediaTypeVideo]) {
+    case AVAuthorizationStatusNotDetermined:
+      return resolve(RNPermissionStatusNotDetermined);
+    case AVAuthorizationStatusRestricted:
+      return resolve(RNPermissionStatusRestricted);
+    case AVAuthorizationStatusDenied:
+      return resolve(RNPermissionStatusDenied);
+    case AVAuthorizationStatusAuthorized:
+      return resolve(RNPermissionStatusAuthorized);
+  }
+}
+
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject {
+  [AVCaptureDevice requestAccessForMediaType:AVMediaTypeVideo
+                           completionHandler:^(__unused BOOL granted) {
+    [self checkWithResolver:resolve rejecter:reject];
+  }];
+}
+
+@end

package/ios/permissions/DyteRNPermissionHandlerMicrophone.h

@@ -0,0 +1,5 @@
+#import "DyteRNPermissions.h"
+
+@interface DyteRNPermissionHandlerMicrophone : NSObject<DyteRNPermissionHandler>
+
+@end

package/ios/permissions/DyteRNPermissionHandlerMicrophone.m

@@ -0,0 +1,34 @@
+#import "DyteRNPermissionHandlerMicrophone.h"
+
+@import AVFoundation;
+
+@implementation DyteRNPermissionHandlerMicrophone
+
++ (NSArray<NSString *> * _Nonnull)usageDescriptionKeys {
+  return @[@"NSMicrophoneUsageDescription"];
+}
+
++ (NSString * _Nonnull)handlerUniqueId {
+  return @"ios.permission.MICROPHONE";
+}
+
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                 rejecter:(void (__unused ^ _Nonnull)(NSError * _Nonnull))reject {
+  switch ([[AVAudioSession sharedInstance] recordPermission]) {
+    case AVAudioSessionRecordPermissionUndetermined:
+      return resolve(RNPermissionStatusNotDetermined);
+    case AVAudioSessionRecordPermissionDenied:
+      return resolve(RNPermissionStatusDenied);
+    case AVAudioSessionRecordPermissionGranted:
+      return resolve(RNPermissionStatusAuthorized);
+  }
+}
+
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject {
+  [[AVAudioSession sharedInstance] requestRecordPermission:^(__unused BOOL granted) {
+    [self checkWithResolver:resolve rejecter:reject];
+  }];
+}
+
+@end

package/ios/permissions/DyteRNPermissionHandlerPhotoLibrary.h

@@ -0,0 +1,8 @@
+#import "DyteRNPermissions.h"
+
+@interface DyteRNPermissionHandlerPhotoLibrary : NSObject<DyteRNPermissionHandler>
+
+- (void)openLimitedPhotoLibraryPickerWithResolver:(RCTPromiseResolveBlock _Nonnull)resolve
+                                         rejecter:(RCTPromiseRejectBlock _Nonnull)reject;
+
+@end

package/ios/permissions/DyteRNPermissionHandlerPhotoLibrary.m

@@ -0,0 +1,70 @@
+#import "DyteRNPermissionHandlerPhotoLibrary.h"
+#import <React/RCTUtils.h>
+
+@import Photos;
+@import PhotosUI;
+
+@implementation DyteRNPermissionHandlerPhotoLibrary
+
++ (NSArray<NSString *> * _Nonnull)usageDescriptionKeys {
+  return @[@"NSPhotoLibraryUsageDescription"];
+}
+
++ (NSString * _Nonnull)handlerUniqueId {
+  return @"ios.permission.PHOTO_LIBRARY";
+}
+
+- (void)checkWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                 rejecter:(void (__unused ^ _Nonnull)(NSError * _Nonnull))reject {
+  PHAuthorizationStatus status;
+
+  if (@available(iOS 14.0, *)) {
+    status = [PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelReadWrite];
+  } else {
+    status = [PHPhotoLibrary authorizationStatus];
+  }
+
+  switch (status) {
+    case PHAuthorizationStatusNotDetermined:
+      return resolve(RNPermissionStatusNotDetermined);
+    case PHAuthorizationStatusRestricted:
+      return resolve(RNPermissionStatusRestricted);
+    case PHAuthorizationStatusDenied:
+      return resolve(RNPermissionStatusDenied);
+    case PHAuthorizationStatusLimited:
+      return resolve(RNPermissionStatusLimited);
+    case PHAuthorizationStatusAuthorized:
+      return resolve(RNPermissionStatusAuthorized);
+  }
+}
+
+- (void)requestWithResolver:(void (^ _Nonnull)(RNPermissionStatus))resolve
+                   rejecter:(void (^ _Nonnull)(NSError * _Nonnull))reject {
+  if (@available(iOS 14.0, *)) {
+    [PHPhotoLibrary requestAuthorizationForAccessLevel:PHAccessLevelReadWrite handler:^(__unused PHAuthorizationStatus status) {
+      [self checkWithResolver:resolve rejecter:reject];
+    }];
+  } else {
+    [PHPhotoLibrary requestAuthorization:^(__unused PHAuthorizationStatus status) {
+      [self checkWithResolver:resolve rejecter:reject];
+    }];
+  }
+}
+
+- (void)openLimitedPhotoLibraryPickerWithResolver:(RCTPromiseResolveBlock _Nonnull)resolve
+                                         rejecter:(RCTPromiseRejectBlock _Nonnull)reject {
+  if (@available(iOS 14, *)) {
+    if ([PHPhotoLibrary authorizationStatusForAccessLevel:PHAccessLevelReadWrite] != PHAuthorizationStatusLimited) {
+      return reject(@"cannot_open_limited_picker", @"Photo library permission isn't limited", nil);
+    }
+
+    UIViewController *presentedViewController = RCTPresentedViewController();
+    [[PHPhotoLibrary sharedPhotoLibrary] presentLimitedLibraryPickerFromViewController:presentedViewController];
+
+    resolve(@(true));
+  } else {
+    reject(@"cannot_open_limited_picker", @"Only available on iOS 14 or higher", nil);
+  }
+}
+
+@end

package/ios/screenshare/DyteDarwinNotificationCenter.swift

@@ -0,0 +1,21 @@
+import Foundation
+
+enum DyteDarwinNotification: String {
+    case broadcastStarted = "iOS_BroadcastStarted"
+    case broadcastStopped = "iOS_BroadcastStopped"
+}
+
+class DyteDarwinNotificationCenter {
+    
+    static let shared = DyteDarwinNotificationCenter()
+    
+    private let notificationCenter: CFNotificationCenter
+    
+    init() {
+        notificationCenter = CFNotificationCenterGetDarwinNotifyCenter()
+    }
+    
+    func postNotification(_ name: DyteDarwinNotification) {
+        CFNotificationCenterPostNotification(notificationCenter, CFNotificationName(rawValue: name.rawValue as CFString), nil, nil, true)
+    }
+}

package/ios/screenshare/DyteScreenshareAtomic.swift

@@ -0,0 +1,29 @@
+import Foundation
+
+@propertyWrapper
+struct DyteScreenshareAtomic<Value> {
+
+    private var value: Value
+    private let lock = NSLock()
+
+    init(wrappedValue value: Value) {
+        self.value = value
+    }
+
+    var wrappedValue: Value {
+        get { load() }
+        set { store(newValue: newValue) }
+    }
+
+    func load() -> Value {
+        lock.lock()
+        defer { lock.unlock() }
+        return value
+    }
+
+    mutating func store(newValue: Value) {
+        lock.lock()
+        defer { lock.unlock() }
+        value = newValue
+    }
+}

package/ios/screenshare/DyteScreenshareHandler.swift

@@ -0,0 +1,103 @@
+import ReplayKit
+
+open class DyteScreenshareHandler: RPBroadcastSampleHandler {
+    
+    private var clientConnection: DyteSocketConnection?
+    private var uploader: DyteScreenshareUploader?
+    private var frameCount: Int = 0
+    
+    private let appGroupIdentifier: String
+    private let bundleIdentifier: String
+    
+    public override init() {
+        appGroupIdentifier = ""
+        bundleIdentifier = ""
+        super.init()
+    }
+    
+    public init(appGroupIdentifier: String, bundleIdentifier: String) {
+        self.appGroupIdentifier = appGroupIdentifier
+        self.bundleIdentifier = bundleIdentifier
+        super.init()
+        if let connection = DyteSocketConnection(filePath: socketFilePath) {
+            clientConnection = connection
+            print("Setup Connection")
+            setupConnection()
+            uploader = DyteScreenshareUploader(connection: connection, bundleIdentifier: bundleIdentifier)
+        }
+    }
+    
+    private var socketFilePath: String {
+        let sharedContainer = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: appGroupIdentifier)
+        return sharedContainer?.appendingPathComponent("rtc_SSFD").path ?? ""
+    }
+    
+    public override func broadcastStarted(withSetupInfo setupInfo: [String: NSObject]?) {
+        // User has requested to start the broadcast. Setup info from the UI extension can be supplied but optional.
+        frameCount = 0
+        DyteDarwinNotificationCenter.shared.postNotification(.broadcastStarted)
+        openConnection()
+    }
+    
+    public override func broadcastPaused() {
+        // User has requested to pause the broadcast. Samples will stop being delivered.
+    }
+    
+    public override func broadcastResumed() {
+        // User has requested to resume the broadcast. Samples delivery will resume.
+    }
+    
+    public override func broadcastFinished() {
+        // User has requested to finish the broadcast.
+        print("Broadcast Stopped")
+        DyteDarwinNotificationCenter.shared.postNotification(.broadcastStopped)
+        clientConnection?.close()
+    }
+    
+    override public func processSampleBuffer(_ sampleBuffer: CMSampleBuffer, with sampleBufferType: RPSampleBufferType) {
+        switch sampleBufferType {
+        case RPSampleBufferType.video:
+            frameCount += 1
+            uploader?.send(sample: sampleBuffer)
+           if frameCount % 3 == 0 {
+               uploader?.send(sample: sampleBuffer)
+           }
+        default:
+            break
+        }
+    }
+}
+
+private extension DyteScreenshareHandler {
+  
+    func setupConnection() {
+        clientConnection?.didClose = { [weak self] error in
+            print("client connection did close \(String(describing: error))")
+          
+            if let error = error {
+                self?.finishBroadcastWithError(error)
+            } else {
+                // the displayed failure message is more user friendly when using NSError instead of Error
+                let DyteScreenSharingStopped = 10001
+                let customError = NSError(domain: RPRecordingErrorDomain, code: DyteScreenSharingStopped, userInfo: [NSLocalizedDescriptionKey: "Screen sharing stopped"])
+                self?.finishBroadcastWithError(customError)
+            }
+        }
+    }
+    
+    func openConnection() {
+        let queue = DispatchQueue(label: "broadcast.connectTimer")
+        let timer = DispatchSource.makeTimerSource(queue: queue)
+        timer.schedule(deadline: .now(), repeating: .milliseconds(100), leeway: .milliseconds(500))
+        timer.setEventHandler { [weak self] in
+            guard self?.clientConnection?.open() == true else {
+                return
+            }
+            
+            timer.cancel()
+        }
+        
+        timer.resume()
+    }
+}
+

package/ios/screenshare/DyteScreenshareUploader.swift

@@ -0,0 +1,139 @@
+import Foundation
+import ReplayKit
+
+private enum Constants {
+    static let bufferMaxLength = 10240
+}
+
+class DyteScreenshareUploader {
+    
+    private static var imageContext = CIContext(options: nil)
+    
+    @DyteScreenshareAtomic private var isReady = false
+    private var connection: DyteSocketConnection
+  
+    private var dataToSend: Data?
+    private var byteIndex = 0
+  
+    private let serialQueue: DispatchQueue
+    
+    init(connection: DyteSocketConnection, bundleIdentifier: String) {
+        self.connection = connection
+        self.serialQueue = DispatchQueue(label: bundleIdentifier)
+      
+        setupConnection()
+    }
+  
+    @discardableResult func send(sample buffer: CMSampleBuffer) -> Bool {
+        guard isReady else {
+            return false
+        }
+        
+        isReady = false
+
+        dataToSend = prepare(sample: buffer)
+        byteIndex = 0
+
+        serialQueue.async { [weak self] in
+            self?.sendDataChunk()
+        }
+        
+        return true
+    }
+}
+
+private extension DyteScreenshareUploader {
+    
+    func setupConnection() {
+        connection.didOpen = { [weak self] in
+            self?.isReady = true
+        }
+        connection.streamHasSpaceAvailable = { [weak self] in
+            self?.serialQueue.async {
+                if let success = self?.sendDataChunk() {
+                    self?.isReady = !success
+                }
+            }
+        }
+    }
+    
+    @discardableResult func sendDataChunk() -> Bool {
+        guard let dataToSend = dataToSend else {
+            return false
+        }
+      
+        var bytesLeft = dataToSend.count - byteIndex
+        var length = bytesLeft > Constants.bufferMaxLength ? Constants.bufferMaxLength : bytesLeft
+
+        length = dataToSend[byteIndex..<(byteIndex + length)].withUnsafeBytes {
+            guard let ptr = $0.bindMemory(to: UInt8.self).baseAddress else {
+                return 0
+            }
+
+            return connection.writeToStream(buffer: ptr, maxLength: length)
+        }
+
+        if length > 0 {
+            byteIndex += length
+            bytesLeft -= length
+
+            if bytesLeft == 0 {
+                self.dataToSend = nil
+                byteIndex = 0
+            }
+        } else {
+            print("writeBufferToStream failure")
+        }
+      
+        return true
+    }
+    
+    func prepare(sample buffer: CMSampleBuffer) -> Data? {
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(buffer) else {
+            print("image buffer not available")
+            return nil
+        }
+        
+        CVPixelBufferLockBaseAddress(imageBuffer, .readOnly)
+        
+        let scaleFactor = 2.0
+        let width = CVPixelBufferGetWidth(imageBuffer)/Int(scaleFactor)
+        let height = CVPixelBufferGetHeight(imageBuffer)/Int(scaleFactor)
+        let orientation = CMGetAttachment(buffer, key: RPVideoSampleOrientationKey as CFString, attachmentModeOut: nil)?.uintValue ?? 0
+                                    
+        let scaleTransform = CGAffineTransform(scaleX: CGFloat(1.0/scaleFactor), y: CGFloat(1.0/scaleFactor))
+        let bufferData = self.jpegData(from: imageBuffer, scale: scaleTransform)
+        
+        CVPixelBufferUnlockBaseAddress(imageBuffer, .readOnly)
+        
+        guard let messageData = bufferData else {
+            print("corrupted image buffer")
+            return nil
+        }
+              
+        let httpResponse = CFHTTPMessageCreateResponse(nil, 200, nil, kCFHTTPVersion1_1).takeRetainedValue()
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Content-Length" as CFString, String(messageData.count) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Width" as CFString, String(width) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Height" as CFString, String(height) as CFString)
+        CFHTTPMessageSetHeaderFieldValue(httpResponse, "Buffer-Orientation" as CFString, String(orientation) as CFString)
+        
+        CFHTTPMessageSetBody(httpResponse, messageData as CFData)
+        
+        let serializedMessage = CFHTTPMessageCopySerializedMessage(httpResponse)?.takeRetainedValue() as Data?
+      
+        return serializedMessage
+    }
+    
+    func jpegData(from buffer: CVPixelBuffer, scale scaleTransform: CGAffineTransform) -> Data? {
+        let image = CIImage(cvPixelBuffer: buffer).transformed(by: scaleTransform)
+        
+        guard let colorSpace = image.colorSpace else {
+            return nil
+        }
+      
+        let options: [CIImageRepresentationOption: Float] = [kCGImageDestinationLossyCompressionQuality as CIImageRepresentationOption: 1.0]
+
+        return DyteScreenshareUploader.imageContext.jpegRepresentation(of: image, colorSpace: colorSpace, options: options)
+    }
+}
+