@stream-io/video-react-native-sdk 0.1.14 → 0.2.1

package/expo-config-plugin/dist/withIosScreenCapture/index.js

@@ -0,0 +1,20 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withPlistUpdates_1 = __importDefault(require("./withPlistUpdates"));
+const withFilesMod_1 = __importDefault(require("./withFilesMod"));
+const withTarget_1 = __importDefault(require("./withTarget"));
+const withIosScreenCapture = (config, props) => {
+    if (!props?.enableScreenshare) {
+        return config;
+    }
+    return (0, config_plugins_1.withPlugins)(config, [
+        () => (0, withFilesMod_1.default)(config, props),
+        () => (0, withTarget_1.default)(config, props),
+        () => (0, withPlistUpdates_1.default)(config, props),
+    ]);
+};
+exports.default = withIosScreenCapture;

package/expo-config-plugin/dist/withIosScreenCapture/withFilesMod.d.ts

@@ -0,0 +1,4 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { ConfigProps } from '../common/types';
+declare const withFilesMod: ConfigPlugin<ConfigProps>;
+export default withFilesMod;

package/expo-config-plugin/dist/withIosScreenCapture/withFilesMod.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const plist_1 = __importDefault(require("@expo/plist"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const withFilesMod = (config) => (0, config_plugins_1.withPlugins)(config, [
+    withBroadcastExtensionHandler,
+    withBroadcastExtensionPlist,
+]);
+exports.default = withFilesMod;
+// creates the extension handler directory and adds the SampleHandler.swift file
+const withBroadcastExtensionHandler = (configuration) => {
+    return (0, config_plugins_1.withDangerousMod)(configuration, [
+        'ios',
+        (config) => {
+            const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'broadcast');
+            fs.mkdirSync(extensionRootPath, { recursive: true });
+            fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SampleHandler.swift'), path.join(extensionRootPath, 'SampleHandler.swift'));
+            return config;
+        },
+    ]);
+};
+// adds the Info.plist to the extension handler directory
+const withBroadcastExtensionPlist = (configuration) => {
+    return (0, config_plugins_1.withDangerousMod)(configuration, [
+        'ios',
+        (config) => {
+            const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'broadcast');
+            const extensionPlistPath = path.join(extensionRootPath, 'Info.plist');
+            const extensionPlist = {
+                NSExtension: {
+                    NSExtensionPointIdentifier: 'com.apple.broadcast-services-upload',
+                    NSExtensionPrincipalClass: '$(PRODUCT_MODULE_NAME).SampleHandler',
+                    RPBroadcastProcessMode: 'RPBroadcastProcessModeSampleBuffer',
+                },
+            };
+            fs.mkdirSync(path.dirname(extensionPlistPath), {
+                recursive: true,
+            });
+            fs.writeFileSync(extensionPlistPath, plist_1.default.build(extensionPlist));
+            return config;
+        },
+    ]);
+};

package/expo-config-plugin/dist/withIosScreenCapture/withPlistUpdates.d.ts

@@ -0,0 +1,4 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { ConfigProps } from '../common/types';
+declare const withPlistUpdates: ConfigPlugin<ConfigProps>;
+export default withPlistUpdates;

package/expo-config-plugin/dist/withIosScreenCapture/withPlistUpdates.js

@@ -0,0 +1,33 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const withPlistUpdates = (config, _props) => (0, config_plugins_1.withPlugins)(config, [withAppEntitlements, withInfoPlistRTC]);
+exports.default = withPlistUpdates;
+// adds the app group identifier to the app's entitlements file
+const withAppEntitlements = (configuration) => {
+    return (0, config_plugins_1.withEntitlementsPlist)(configuration, (config) => {
+        const appGroupIdentifier = `group.${config.ios
+            .bundleIdentifier}.appgroup`;
+        config.modResults['com.apple.security.application-groups'] = [
+            appGroupIdentifier,
+        ];
+        return config;
+    });
+};
+const withInfoPlistRTC = (configuration) => {
+    return (0, config_plugins_1.withInfoPlist)(configuration, (config) => {
+        const appGroupIdentifier = `group.${config.ios
+            .bundleIdentifier}.appgroup`;
+        const extensionBundleIdentifier = `${config.ios
+            .bundleIdentifier}.broadcast`;
+        config.modResults.RTCAppGroupIdentifier = appGroupIdentifier;
+        config.modResults.RTCScreenSharingExtension = extensionBundleIdentifier;
+        if (!config.modResults.UIBackgroundModes) {
+            config.modResults.UIBackgroundModes = [];
+        }
+        if (!config.modResults.UIBackgroundModes.includes('voip')) {
+            config.modResults.UIBackgroundModes.push('voip');
+        }
+        return config;
+    });
+};

package/expo-config-plugin/dist/withIosScreenCapture/withTarget.d.ts

@@ -0,0 +1,4 @@
+import { ConfigPlugin } from '@expo/config-plugins';
+import { ConfigProps } from '../common/types';
+declare const withTarget: ConfigPlugin<ConfigProps>;
+export default withTarget;

package/expo-config-plugin/dist/withIosScreenCapture/withTarget.js

@@ -0,0 +1,122 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const config_plugins_1 = require("@expo/config-plugins");
+const plist_1 = __importDefault(require("@expo/plist"));
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const addBroadcastExtensionXcodeTarget_1 = __importDefault(require("./addBroadcastExtensionXcodeTarget"));
+// adds the extension's entitlements file
+const withTarget = (configuration, props) => {
+    return (0, config_plugins_1.withXcodeProject)(configuration, (config) => {
+        const appName = config.modRequest.projectName;
+        const extensionName = 'broadcast';
+        const extensionBundleIdentifier = `${config.ios
+            .bundleIdentifier}.broadcast`;
+        const currentProjectVersion = config.ios.buildNumber || '1';
+        const marketingVersion = config.version;
+        const proj = config.modResults;
+        const developmentTeamId = props?.appleTeamId;
+        if (!developmentTeamId) {
+            throw new Error('No appleTeamId was provided in the Expo config. Please provide one to create the screenshare broadcast extension');
+        }
+        (0, addBroadcastExtensionXcodeTarget_1.default)(proj, {
+            appName,
+            extensionName,
+            extensionBundleIdentifier,
+            currentProjectVersion,
+            marketingVersion,
+            developmentTeamId,
+        });
+        const appGroupIdentifier = `group.${config.ios
+            .bundleIdentifier}.appgroup`;
+        const extensionRootPath = path.join(config.modRequest.platformProjectRoot, 'broadcast');
+        addBroadcastEntitlementsFile({
+            proj,
+            extensionRootPath,
+            appGroupIdentifier,
+        });
+        addBroadcastSourceFiles({
+            proj,
+            extensionRootPath,
+            appGroupIdentifier,
+        });
+        return config;
+    });
+};
+exports.default = withTarget;
+const addBroadcastEntitlementsFile = ({ proj, extensionRootPath, appGroupIdentifier, }) => {
+    const entitlementsPath = path.join(extensionRootPath, 'broadcast.entitlements');
+    const extensionEntitlements = {
+        'com.apple.security.application-groups': [appGroupIdentifier],
+    };
+    // create file
+    fs.mkdirSync(path.dirname(entitlementsPath), {
+        recursive: true,
+    });
+    fs.writeFileSync(entitlementsPath, plist_1.default.build(extensionEntitlements));
+    // add file to extension group
+    const targetUuid = proj.findTargetKey('broadcast');
+    const groupUuid = proj.findPBXGroupKey({ name: 'broadcast' });
+    proj.addFile('broadcast.entitlements', groupUuid, {
+        target: targetUuid,
+        lastKnownFileType: 'text.plist.entitlements',
+    });
+};
+const addBroadcastSourceFiles = ({ proj, extensionRootPath, appGroupIdentifier, }) => {
+    fs.mkdirSync(extensionRootPath, { recursive: true });
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'Atomic.swift'), path.join(extensionRootPath, 'Atomic.swift'));
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'DarwinNotificationCenter.swift'), path.join(extensionRootPath, 'DarwinNotificationCenter.swift'));
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SampleUploader.swift'), path.join(extensionRootPath, 'SampleUploader.swift'));
+    fs.copyFileSync(path.join(__dirname, '..', '..', 'static', 'SocketConnection.swift'), path.join(extensionRootPath, 'SocketConnection.swift'));
+    // Update app group bundle id in SampleHandler code
+    const code = fs.readFileSync(path.join(extensionRootPath, 'SampleHandler.swift'), { encoding: 'utf-8' });
+    fs.writeFileSync(path.join(extensionRootPath, 'SampleHandler.swift'), code.replace('group.com.example.broadcast.appgroup', appGroupIdentifier));
+    const targetUuid = proj.findTargetKey('broadcast');
+    const groupUuid = proj.findPBXGroupKey({ name: 'broadcast' });
+    if (!targetUuid) {
+        console.error('Failed to find "broadcast" target!');
+        return;
+    }
+    if (!groupUuid) {
+        console.error('Failed to find "broadcast" group!');
+        return;
+    }
+    proj.addSourceFile('Atomic.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('DarwinNotificationCenter.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('SampleUploader.swift', {
+        target: targetUuid,
+    }, groupUuid);
+    proj.addSourceFile('SocketConnection.swift', {
+        target: targetUuid,
+    }, groupUuid);
+};

package/expo-config-plugin/static/Atomic.swift

@@ -0,0 +1,36 @@
+//
+//  Atomic.swift
+//  Broadcast Extension
+//
+//  Created by Maksym Shcheglov.
+//  https://www.onswiftwings.com/posts/atomic-property-wrapper/
+//
+import Foundation
+
+@propertyWrapper
+struct Atomic<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/expo-config-plugin/static/DarwinNotificationCenter.swift

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

package/expo-config-plugin/static/SampleHandler.swift

@@ -0,0 +1,99 @@
+//
+//  SampleHandler.swift
+//  Broadcast Extension
+//
+import ReplayKit
+import OSLog
+
+let broadcastLogger = OSLog(subsystem: "io.getstream.reactnative", category: "Broadcast")
+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.com.example.broadcast.appgroup"
+}
+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)
+        }
+        os_log(.debug, log: broadcastLogger, "%{public}s", socketFilePath)
+    }
+
+    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:
+            uploader?.send(sample: sampleBuffer)
+        default:
+            break
+        }
+    }
+}
+
+private extension SampleHandler {
+
+    func setupConnection() {
+        clientConnection?.didClose = { [weak self] error in
+            os_log(.debug, log: broadcastLogger, "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/expo-config-plugin/static/SampleUploader.swift

@@ -0,0 +1,143 @@
+//
+//  SampleUploader.swift
+//  Broadcast Extension
+//
+import Foundation
+import ReplayKit
+import OSLog
+
+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: "org.getstream.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 {
+            os_log(.debug, log: broadcastLogger, "writeBufferToStream failure")
+        }
+
+        return true
+    }
+
+    func prepare(sample buffer: CMSampleBuffer) -> Data? {
+        guard let imageBuffer = CMSampleBufferGetImageBuffer(buffer) else {
+            os_log(.debug, log: broadcastLogger, "image buffer not available")
+            return nil
+        }
+
+        CVPixelBufferLockBaseAddress(imageBuffer, .readOnly)
+
+        let scaleFactor = 1.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 {
+            os_log(.debug, log: broadcastLogger, "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)
+    }
+}