@fishjam-cloud/react-native-client 0.23.0 → 0.25.0-rc.1

package/plugin/broadcastExtensionFiles/SampleHandler.swift

@@ -0,0 +1,104 @@
+//
+//  SampleHandler.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 04.06.2021.
+//
+
+import ReplayKit
+
+private enum Constants {
+    // the App Group ID value that the app and the broadcast extension targets are setup with. It differs for each app.
+    static let appGroupIdentifier = "{{GROUP_IDENTIFIER}}"
+}
+
+class SampleHandler: RPBroadcastSampleHandler {
+    
+    private var clientConnection: SocketConnection?
+    private var uploader: SampleUploader?
+    
+    private var frameCount: Int = 0
+    
+    var socketFilePath: String {
+      let sharedContainer = FileManager.default.containerURL(forSecurityApplicationGroupIdentifier: Constants.appGroupIdentifier)
+        return sharedContainer?.appendingPathComponent("rtc_SSFD").path ?? ""
+    }
+    
+    override init() {
+      super.init()
+        if let connection = SocketConnection(filePath: socketFilePath) {
+          clientConnection = connection
+          setupConnection()
+          
+          uploader = SampleUploader(connection: connection)
+        }
+    }
+
+    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
+        
+        DarwinNotificationCenter.shared.postNotification(.broadcastStarted)
+        openConnection()
+    }
+    
+    override func broadcastPaused() {
+        // User has requested to pause the broadcast. Samples will stop being delivered.
+    }
+    
+    override func broadcastResumed() {
+        // User has requested to resume the broadcast. Samples delivery will resume.
+    }
+    
+    override func broadcastFinished() {
+        // User has requested to finish the broadcast.
+        DarwinNotificationCenter.shared.postNotification(.broadcastStopped)
+        clientConnection?.close()
+    }
+    
+    override func processSampleBuffer(_ sampleBuffer: CMSampleBuffer, with sampleBufferType: RPSampleBufferType) {
+        switch sampleBufferType {
+        case RPSampleBufferType.video:
+            // very simple mechanism for adjusting frame rate by using every third frame
+            frameCount += 1
+            if frameCount % 3 == 0 {
+                uploader?.send(sample: sampleBuffer)
+            }
+        default:
+            break
+        }
+    }
+}
+
+private extension SampleHandler {
+  
+    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 JMScreenSharingStopped = 10001
+                let customError = NSError(domain: RPRecordingErrorDomain, code: JMScreenSharingStopped, 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/plugin/broadcastExtensionFiles/SampleUploader.swift

@@ -0,0 +1,146 @@
+//
+//  SampleUploader.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 22/03/2021.
+//  Copyright © 2021 8x8, Inc. All rights reserved.
+//
+
+import Foundation
+import ReplayKit
+
+private enum Constants {
+    static let bufferMaxLength = 10240
+}
+
+class SampleUploader {
+    
+    private static var imageContext = CIContext(options: nil)
+    
+    @Atomic private var isReady = false
+    private var connection: SocketConnection
+  
+    private var dataToSend: Data?
+    private var byteIndex = 0
+  
+    private let serialQueue: DispatchQueue
+    
+    init(connection: SocketConnection) {
+        self.connection = connection
+        self.serialQueue = DispatchQueue(label: "{{BUNDLE_IDENTIFIER}}.broadcast.sampleUploader")
+      
+        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 SampleUploader {
+    
+    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 SampleUploader.imageContext.jpegRepresentation(of: image, colorSpace: colorSpace, options: options)
+    }
+}

package/plugin/broadcastExtensionFiles/SocketConnection.swift

@@ -0,0 +1,198 @@
+//
+//  SocketConnection.swift
+//  Broadcast Extension
+//
+//  Created by Alex-Dan Bumbu on 22/03/2021.
+//  Copyright © 2021 Atlassian Inc. All rights reserved.
+//
+
+import Foundation
+
+class SocketConnection: NSObject {
+    var didOpen: (() -> Void)?
+    var didClose: ((Error?) -> Void)?
+    var streamHasSpaceAvailable: (() -> Void)?
+
+    private let filePath: String
+    private var socketHandle: Int32 = -1
+    private var address: sockaddr_un?
+
+    private var inputStream: InputStream?
+    private var outputStream: OutputStream?
+    
+    private var networkQueue: DispatchQueue?
+    private var shouldKeepRunning = false
+
+    init?(filePath path: String) {
+        filePath = path
+        socketHandle = Darwin.socket(AF_UNIX, SOCK_STREAM, 0)
+
+        guard socketHandle != -1 else {
+            print("failure: create socket")
+            return nil
+        }
+    }
+
+    func open() -> Bool {
+        print("open socket connection")
+
+        guard FileManager.default.fileExists(atPath: filePath) else {
+            print("failure: socket file missing")
+            return false
+        }
+      
+        guard setupAddress() == true else {
+            return false
+        }
+        
+        guard connectSocket() == true else {
+            return false
+        }
+
+        setupStreams()
+        
+        inputStream?.open()
+        outputStream?.open()
+
+        return true
+    }
+
+    func close() {
+        unscheduleStreams()
+
+        inputStream?.delegate = nil
+        outputStream?.delegate = nil
+
+        inputStream?.close()
+        outputStream?.close()
+        
+        inputStream = nil
+        outputStream = nil
+    }
+
+    func writeToStream(buffer: UnsafePointer<UInt8>, maxLength length: Int) -> Int {
+        outputStream?.write(buffer, maxLength: length) ?? 0
+    }
+}
+
+extension SocketConnection: StreamDelegate {
+
+    func stream(_ aStream: Stream, handle eventCode: Stream.Event) {
+        switch eventCode {
+        case .openCompleted:
+            print("client stream open completed")
+            if aStream == outputStream {
+                didOpen?()
+            }
+        case .hasBytesAvailable:
+            if aStream == inputStream {
+                var buffer: UInt8 = 0
+                let numberOfBytesRead = inputStream?.read(&buffer, maxLength: 1)
+                if numberOfBytesRead == 0 && aStream.streamStatus == .atEnd {
+                    print("server socket closed")
+                    close()
+                    notifyDidClose(error: nil)
+                }
+            }
+        case .hasSpaceAvailable:
+            if aStream == outputStream {
+                streamHasSpaceAvailable?()
+            }
+        case .errorOccurred:
+            print("client stream error occurred: \(String(describing: aStream.streamError))")
+            close()
+            notifyDidClose(error: aStream.streamError)
+
+        default:
+            break
+        }
+    }
+}
+
+private extension SocketConnection {
+  
+    func setupAddress() -> Bool {
+        var addr = sockaddr_un()
+        guard filePath.count < MemoryLayout.size(ofValue: addr.sun_path) else {
+            print("failure: fd path is too long")
+            return false
+        }
+
+        _ = withUnsafeMutablePointer(to: &addr.sun_path.0) { ptr in
+            filePath.withCString {
+                strncpy(ptr, $0, filePath.count)
+            }
+        }
+        
+        address = addr
+        return true
+    }
+
+    func connectSocket() -> Bool {
+        guard var addr = address else {
+            return false
+        }
+        
+        let status = withUnsafePointer(to: &addr) { ptr in
+            ptr.withMemoryRebound(to: sockaddr.self, capacity: 1) {
+                Darwin.connect(socketHandle, $0, socklen_t(MemoryLayout<sockaddr_un>.size))
+            }
+        }
+
+        guard status == noErr else {
+            print("failure: \(status)")
+            return false
+        }
+        
+        return true
+    }
+
+    func setupStreams() {
+        var readStream: Unmanaged<CFReadStream>?
+        var writeStream: Unmanaged<CFWriteStream>?
+
+        CFStreamCreatePairWithSocket(kCFAllocatorDefault, socketHandle, &readStream, &writeStream)
+
+        inputStream = readStream?.takeRetainedValue()
+        inputStream?.delegate = self
+        inputStream?.setProperty(kCFBooleanTrue, forKey: Stream.PropertyKey(kCFStreamPropertyShouldCloseNativeSocket as String))
+
+        outputStream = writeStream?.takeRetainedValue()
+        outputStream?.delegate = self
+        outputStream?.setProperty(kCFBooleanTrue, forKey: Stream.PropertyKey(kCFStreamPropertyShouldCloseNativeSocket as String))
+
+        scheduleStreams()
+    }
+  
+    func scheduleStreams() {
+        shouldKeepRunning = true
+        
+        networkQueue = DispatchQueue.global(qos: .userInitiated)
+        networkQueue?.async { [weak self] in
+            self?.inputStream?.schedule(in: .current, forMode: .common)
+            self?.outputStream?.schedule(in: .current, forMode: .common)
+            RunLoop.current.run()
+            
+            var isRunning = false
+                        
+            repeat {
+                isRunning = self?.shouldKeepRunning ?? false && RunLoop.current.run(mode: .default, before: .distantFuture)
+            } while (isRunning)
+        }
+    }
+    
+    func unscheduleStreams() {
+        networkQueue?.sync { [weak self] in
+            self?.inputStream?.remove(from: .current, forMode: .common)
+            self?.outputStream?.remove(from: .current, forMode: .common)
+        }
+        
+        shouldKeepRunning = false
+    }
+    
+    func notifyDidClose(error: Error?) {
+        if didClose != nil {
+            didClose?(error)
+        }
+    }
+}

package/plugin/build/types.d.ts

@@ -1,15 +1,17 @@
 export type FishjamPluginOptions = {
     android?: {
         enableForegroundService?: boolean;
+        enableScreensharing?: boolean;
         supportsPictureInPicture?: boolean;
     };
     ios?: {
-        iphoneDeploymentTarget?: string;
         enableScreensharing?: boolean;
         supportsPictureInPicture?: boolean;
-        enableVoIPBackgroundMode?: boolean;
+        broadcastExtensionTargetName?: string;
+        broadcastExtensionDisplayName?: string;
         appGroupContainerId?: string;
         mainTargetName?: string;
-        broadcastExtensionTargetName?: string;
+        iphoneDeploymentTarget?: string;
+        enableVoIPBackgroundMode?: boolean;
     };
 } | undefined;

package/plugin/build/withFishjam.d.ts

@@ -1,4 +1,33 @@
-import { ConfigPlugin } from '@expo/config-plugins';
-import { FishjamPluginOptions } from './types';
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { FishjamPluginOptions } from './types';
+/**
+ * Main Fishjam Expo config plugin.
+ *
+ * This plugin configures both iOS and Android platforms for Picture-in-Picture support.
+ *
+ * ## Usage
+ *
+ * ```json
+ * {
+ *   "plugins": [
+ *     [
+ *       "@fishjam-cloud/react-native-client",
+ *       {
+ *         "android": {
+ *           "supportsPictureInPicture": true
+ *         },
+ *         "ios": {
+ *           "supportsPictureInPicture": true
+ *         }
+ *       }
+ *     ]
+ *   ]
+ * }
+ * ```
+ *
+ * @param config - Expo config object
+ * @param options - Plugin configuration options
+ * @returns Modified config object
+ */
 declare const withFishjam: ConfigPlugin<FishjamPluginOptions>;
 export default withFishjam;

package/plugin/build/withFishjam.js

@@ -1,13 +1,39 @@
 "use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
 Object.defineProperty(exports, "__esModule", { value: true });
 const withFishjamAndroid_1 = require("./withFishjamAndroid");
-const withFishjamIos_1 = __importDefault(require("./withFishjamIos"));
+const withFishjamIos_1 = require("./withFishjamIos");
+/**
+ * Main Fishjam Expo config plugin.
+ *
+ * This plugin configures both iOS and Android platforms for Picture-in-Picture support.
+ *
+ * ## Usage
+ *
+ * ```json
+ * {
+ *   "plugins": [
+ *     [
+ *       "@fishjam-cloud/react-native-client",
+ *       {
+ *         "android": {
+ *           "supportsPictureInPicture": true
+ *         },
+ *         "ios": {
+ *           "supportsPictureInPicture": true
+ *         }
+ *       }
+ *     ]
+ *   ]
+ * }
+ * ```
+ *
+ * @param config - Expo config object
+ * @param options - Plugin configuration options
+ * @returns Modified config object
+ */
 const withFishjam = (config, options) => {
-    (0, withFishjamAndroid_1.withFishjamAndroid)(config, options);
-    (0, withFishjamIos_1.default)(config, options);
+    config = (0, withFishjamAndroid_1.withFishjamAndroid)(config, options);
+    config = (0, withFishjamIos_1.withFishjamIos)(config, options);
     return config;
 };
 exports.default = withFishjam;

package/plugin/build/withFishjamAndroid.d.ts

@@ -1,3 +1,3 @@
-import { ConfigPlugin } from '@expo/config-plugins';
-import { FishjamPluginOptions } from './types';
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { FishjamPluginOptions } from './types';
 export declare const withFishjamAndroid: ConfigPlugin<FishjamPluginOptions>;

package/plugin/build/withFishjamAndroid.js

@@ -3,39 +3,86 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.withFishjamAndroid = void 0;
 const config_plugins_1 = require("@expo/config-plugins");
 const Manifest_1 = require("@expo/config-plugins/build/android/Manifest");
+const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
+    const activity = config_plugins_1.AndroidConfig.Manifest.getMainActivityOrThrow(configuration.modResults);
+    if (props?.android?.supportsPictureInPicture) {
+        activity.$['android:supportsPictureInPicture'] = 'true';
+    }
+    else {
+        delete activity.$['android:supportsPictureInPicture'];
+    }
+    return configuration;
+});
 const withFishjamForegroundService = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, async (configuration) => {
     if (!props?.android?.enableForegroundService) {
         return configuration;
     }
     const mainApplication = (0, Manifest_1.getMainApplicationOrThrow)(configuration.modResults);
     mainApplication.service = mainApplication.service || [];
-    const newService = {
+    const webRTCForegroundService = {
         $: {
-            'android:name': 'io.fishjam.reactnative.foregroundService.FishjamForegroundService',
-            'android:foregroundServiceType': 'camera|microphone|mediaProjection',
+            'android:name': 'com.oney.WebRTCModule.foregroundService.WebRTCForegroundService',
+            'android:foregroundServiceType': 'camera|microphone',
             'android:stopWithTask': 'true',
         },
     };
-    const existingServiceIndex = mainApplication.service.findIndex((service) => service.$['android:name'] === newService.$['android:name']);
-    if (existingServiceIndex !== -1) {
-        mainApplication.service[existingServiceIndex] = newService;
+    const existingWebRTCForegroundServiceIndex = mainApplication.service.findIndex((service) => service.$['android:name'] === webRTCForegroundService.$['android:name']);
+    if (existingWebRTCForegroundServiceIndex !== -1) {
+        mainApplication.service[existingWebRTCForegroundServiceIndex] = webRTCForegroundService;
     }
     else {
-        mainApplication.service.push(newService);
+        mainApplication.service.push(webRTCForegroundService);
+    }
+    if (props?.android?.enableScreensharing) {
+        const mediaProjectionService = {
+            $: {
+                'android:name': 'com.oney.WebRTCModule.MediaProjectionService',
+                'android:foregroundServiceType': 'mediaProjection',
+                'android:stopWithTask': 'true',
+            },
+        };
+        const existingMediaProjectionServiceIndex = mainApplication.service.findIndex((service) => service.$['android:name'] === mediaProjectionService.$['android:name']);
+        if (existingMediaProjectionServiceIndex !== -1) {
+            mainApplication.service[existingMediaProjectionServiceIndex] = mediaProjectionService;
+        }
+        else {
+            mainApplication.service.push(mediaProjectionService);
+        }
     }
     return configuration;
 });
-const withFishjamPictureInPicture = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
-    const activity = config_plugins_1.AndroidConfig.Manifest.getMainActivityOrThrow(configuration.modResults);
-    if (props?.android?.supportsPictureInPicture) {
-        activity.$['android:supportsPictureInPicture'] = 'true';
+const withFishjamForegroundServicePermission = (config, props) => (0, config_plugins_1.withAndroidManifest)(config, (configuration) => {
+    if (!props?.android?.enableForegroundService) {
+        return configuration;
     }
-    else {
-        delete activity.$['android:supportsPictureInPicture'];
+    const mainApplication = configuration.modResults;
+    if (!mainApplication.manifest) {
+        return configuration;
+    }
+    if (!mainApplication.manifest['uses-permission']) {
+        mainApplication.manifest['uses-permission'] = [];
     }
+    const permissions = mainApplication.manifest['uses-permission'];
+    const foregroundServicePermissions = [
+        'android.permission.FOREGROUND_SERVICE',
+        'android.permission.FOREGROUND_SERVICE_CAMERA',
+        'android.permission.FOREGROUND_SERVICE_MEDIA_PROJECTION',
+        'android.permission.FOREGROUND_SERVICE_MICROPHONE',
+    ];
+    foregroundServicePermissions.forEach((permissionName) => {
+        const hasPermission = permissions.some((perm) => perm.$?.['android:name'] === permissionName);
+        if (!hasPermission) {
+            permissions.push({
+                $: {
+                    'android:name': permissionName,
+                },
+            });
+        }
+    });
     return configuration;
 });
 const withFishjamAndroid = (config, props) => {
+    config = withFishjamForegroundServicePermission(config, props);
     config = withFishjamForegroundService(config, props);
     config = withFishjamPictureInPicture(config, props);
     return config;

package/plugin/build/withFishjamIos.d.ts

@@ -1,9 +1,4 @@
-import { ConfigPlugin } from '@expo/config-plugins';
-import { FishjamPluginOptions } from './types';
-export declare function getSbePodfileSnippet(props: FishjamPluginOptions): string;
-/**
- * Applies screen sharing plugin if enabled. In order for screensharing to work, we need to copy extension files to your iOS project.
- * Allows for dynamically changing deploymentTarget.
- */
+import type { ConfigPlugin } from '@expo/config-plugins';
+import type { FishjamPluginOptions } from './types';
 declare const withFishjamIos: ConfigPlugin<FishjamPluginOptions>;
-export default withFishjamIos;
+export { withFishjamIos };