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

package/ios/screenshare/DyteSocketConnection.swift

@@ -0,0 +1,190 @@
+import Foundation
+
+class DyteSocketConnection: 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 DyteSocketConnection: 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 occured: \(String(describing: aStream.streamError))")
+            close()
+            notifyDidClose(error: aStream.streamError)
+
+        default:
+            break
+        }
+    }
+}
+
+private extension DyteSocketConnection {
+  
+    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/lib/BackgroundHandler.d.ts

@@ -0,0 +1,20 @@
+declare class BackgroundTimer {
+    uniqueId: number;
+    callbacks: {
+        [key: string]: any;
+    };
+    backgroundTimer: number | NodeJS.Timeout | null;
+    backgroundListener: any;
+    constructor();
+    start(delay?: number): any;
+    stop(): any;
+    runBackgroundTimer(callback: any, delay: any): void;
+    backgroundClockMethod(callback: any, delay: any): void;
+    stopBackgroundTimer(): void;
+    setTimeout(callback: any, timeout: any): number;
+    clearTimeout(timeoutId: any): void;
+    setInterval(callback: any, timeout: any): number;
+    clearInterval(intervalId: any): void;
+}
+declare const _default: BackgroundTimer;
+export default _default;

package/lib/BackgroundHandler.js

@@ -0,0 +1,87 @@
+import { DeviceEventEmitter, NativeAppEventEmitter, NativeEventEmitter, NativeModules, Platform, } from 'react-native';
+const { DyteRNBackgroundTimer } = NativeModules;
+const Emitter = new NativeEventEmitter(DyteRNBackgroundTimer);
+class BackgroundTimer {
+    constructor() {
+        this.uniqueId = 0;
+        this.callbacks = {};
+        Emitter.addListener('backgroundTimer.timeout', (id) => {
+            if (this.callbacks[id]) {
+                const callbackById = this.callbacks[id];
+                const { callback } = callbackById;
+                if (!this.callbacks[id].interval) {
+                    delete this.callbacks[id];
+                }
+                else {
+                    DyteRNBackgroundTimer.backgroundTimerSetTimeout(id, this.callbacks[id].timeout);
+                }
+                callback();
+            }
+        });
+    }
+    // Original API
+    start(delay = 0) {
+        return DyteRNBackgroundTimer.start(delay);
+    }
+    stop() {
+        Emitter.removeAllListeners('backgroundTimer.timeout');
+        return DyteRNBackgroundTimer.stop();
+    }
+    runBackgroundTimer(callback, delay) {
+        const EventEmitter = Platform.select({
+            ios: () => NativeAppEventEmitter,
+            android: () => DeviceEventEmitter,
+        })();
+        this.start(0);
+        this.backgroundListener = EventEmitter.addListener('backgroundTimer', () => {
+            this.backgroundListener.remove();
+            this.backgroundClockMethod(callback, delay);
+        });
+    }
+    backgroundClockMethod(callback, delay) {
+        this.backgroundTimer = this.setTimeout(() => {
+            callback();
+            this.backgroundClockMethod(callback, delay);
+        }, delay);
+    }
+    stopBackgroundTimer() {
+        this.stop();
+        this.clearTimeout(this.backgroundTimer);
+    }
+    // New API, allowing for multiple timers
+    setTimeout(callback, timeout) {
+        this.uniqueId += 1;
+        const timeoutId = this.uniqueId;
+        this.callbacks[timeoutId] = {
+            callback,
+            interval: false,
+            timeout,
+        };
+        DyteRNBackgroundTimer.setTimeout(timeoutId, timeout);
+        return timeoutId;
+    }
+    clearTimeout(timeoutId) {
+        if (this.callbacks[timeoutId]) {
+            delete this.callbacks[timeoutId];
+            // DyteRNBackgroundTimer.clearTimeout(timeoutId);
+        }
+    }
+    setInterval(callback, timeout) {
+        this.uniqueId += 1;
+        const intervalId = this.uniqueId;
+        this.callbacks[intervalId] = {
+            callback,
+            interval: true,
+            timeout,
+        };
+        DyteRNBackgroundTimer.backgroundTimerSetTimeout(intervalId, timeout);
+        return intervalId;
+    }
+    clearInterval(intervalId) {
+        if (this.callbacks[intervalId]) {
+            delete this.callbacks[intervalId];
+            // DyteRNBackgroundTimer.clearTimeout(intervalId);
+        }
+    }
+}
+export default new BackgroundTimer();

package/lib/LocalMediaError.d.ts

@@ -0,0 +1,4 @@
+export default class LocalMediaError extends Error {
+    code: string;
+    constructor(message: string, code: string);
+}

package/lib/LocalMediaError.js

@@ -0,0 +1,6 @@
+export default class LocalMediaError extends Error {
+    constructor(message, code) {
+        super(message);
+        this.code = code;
+    }
+}

package/lib/LocalMediaHandler.d.ts

@@ -0,0 +1,118 @@
+import { EventEmitter } from 'events';
+import LocalMediaUtils from './LocalMediaUtils';
+import { MediaPermission } from './LocalMediaInterfaces';
+import type { MediaStreamTrack } from '@dyteinternals/react-native-webrtc';
+import type { MediaDeviceInfo } from './LocalMediaInterfaces';
+export declare enum MediaEvents {
+    AUDIO_TRACK_CHANGE = 0,
+    VIDEO_TRACK_CHANGE = 1,
+    SCREENSHARE_TRACK_CHANGE = 2,
+    SCREENSHARE_ENDED = 3,
+    DEVICE_CHANGE = 4,
+    SCREENSHARE_STARTED = 5,
+    MEDIA_PERMISSION_UPDATE = 6,
+    DEVICE_LIST_UPDATED = 7
+}
+export default class LocalMediaHandler extends EventEmitter {
+    #private;
+    audioTrack: MediaStreamTrack;
+    rawAudioTrack: MediaStreamTrack;
+    videoTrack: MediaStreamTrack;
+    rawVideoTrack: MediaStreamTrack;
+    screenShareTracks: {
+        audio?: MediaStreamTrack;
+        video?: MediaStreamTrack;
+    };
+    audioEnabled: boolean;
+    videoEnabled: boolean;
+    screenShareEnabled: boolean;
+    currentDevices: {
+        audio?: MediaDeviceInfo;
+        video?: MediaDeviceInfo;
+        speaker?: MediaDeviceInfo;
+    };
+    permissions: {
+        audio?: MediaPermission;
+        video?: MediaPermission;
+    };
+    _handleAppStateChange: (nextAppState: any) => void;
+    private configureForeground;
+    constructor(localMediaUtils: LocalMediaUtils);
+    destructor(): void;
+    private handlePermissionErrors;
+    private conditionallyRestartAudio;
+    private conditionallyRestartVideo;
+    private shouldReacquireTrack;
+    removeDocumentEventListeners(): Promise<void>;
+    private onUnmute;
+    private removeMediaStreamTrackListeners;
+    private addMediaStreamTrackListeners;
+    setupAudioStream(deviceId?: string, forceStopTrack?: boolean): Promise<void>;
+    private onVisibilityChange;
+    setupVideoStream(deviceId?: string, forceStopTrack?: boolean): Promise<void>;
+    setupSpeaker(deviceId?: string): Promise<void>;
+    getOperationalWebcamDeviceId(): Promise<{
+        isOperational: boolean;
+        deviceId: string;
+    }>;
+    getOperationalMicDeviceId(): Promise<{
+        isOperational: boolean;
+        deviceId: string;
+    }>;
+    setupStreams({ audio, video, }: {
+        audio: boolean;
+        video: boolean;
+    }): Promise<void>;
+    private stopAudioTrack;
+    private stopVideoTrack;
+    private stopScreenShareTracks;
+    removeAudioTrack(): void;
+    removeVideoTrack(): void;
+    removeScreenShareTracks(tracks?: {
+        audio?: boolean;
+        video?: boolean;
+    }): void;
+    removeAllTracks(): void;
+    private setAudioTrack;
+    private setVideoTrack;
+    private setScreenShareTracks;
+    private onScreenShareEnded;
+    disableAudio(): void;
+    enableAudio(): Promise<void>;
+    enableVideo(): Promise<void>;
+    disableVideo(): Promise<void>;
+    toggleAudio(): Promise<void>;
+    toggleVideo(): Promise<void>;
+    setAudioDevice(device: MediaDeviceInfo): Promise<void>;
+    setVideoDevice(device: MediaDeviceInfo): Promise<void>;
+    setSpeakerDevice(device?: MediaDeviceInfo): Promise<void>;
+    setDevice(route: MediaDeviceInfo): Promise<any>;
+    private oniOSBroadcastStart;
+    private oniOSBroadcastStop;
+    toggleScreenShare(): Promise<void>;
+    enableScreenShare(): Promise<void>;
+    disableScreenShare(): Promise<void>;
+    destruct(): void;
+    getAllDevices(): MediaDeviceInfo[];
+    getCurrentDevices(): {
+        audio?: MediaDeviceInfo;
+        video?: MediaDeviceInfo;
+        speaker?: MediaDeviceInfo;
+    };
+    getDeviceById(deviceId: string, kind: 'audioinput' | 'audiooutput' | 'videoinput'): MediaDeviceInfo;
+    getAudioDevices(): MediaDeviceInfo[];
+    getVideoDevices(): MediaDeviceInfo[];
+    getSpeakerDevices(): MediaDeviceInfo[];
+    onDeviceChange(changedDevices: {
+        added: MediaDeviceInfo[];
+        removed: MediaDeviceInfo[];
+    }, forceDeviceChange: boolean): Promise<void>;
+    cleanUpTracks(): void;
+    destructMediaHandler(): Promise<void>;
+    static init(_: any): Promise<LocalMediaHandler>;
+    emit(event: keyof typeof MediaEvents, ...args: any[]): boolean;
+    on(event: keyof typeof MediaEvents, listener: (...args: any[]) => void): this;
+}
+export interface RNLocalMediaHandler {
+    new (): LocalMediaHandler;
+}