react-native-altibbi 0.1.0

package/ios/OTSubscriber.m

@@ -0,0 +1,15 @@
+//
+//  OTSubscriber.m
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 1/18/18.
+//  Copyright © 2018 Facebook. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+#import <React/RCTViewManager.h>
+
+@interface RCT_EXTERN_MODULE(OTSubscriberSwift, RCTViewManager)
+RCT_EXPORT_VIEW_PROPERTY(streamId, NSString)
+@end
+

package/ios/OTSubscriberManager.swift

@@ -0,0 +1,21 @@
+//
+//  OTSubscriberManager.swift
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 1/18/18.
+//  Copyright © 2018 Facebook. All rights reserved.
+//
+
+import Foundation
+
+@objc(OTSubscriberSwift)
+class OTSubscriberManager: RCTViewManager {
+  override func view() -> UIView {
+    return OTSubscriberView();
+  }
+  
+  override static func requiresMainQueueSetup() -> Bool {
+    return true;
+  }
+}
+

package/ios/OTSubscriberView.swift

@@ -0,0 +1,29 @@
+//
+//  OTSubscriberView.swift
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 1/18/18.
+//  Copyright © 2018 Facebook. All rights reserved.
+//
+
+import Foundation
+
+@objc(OTSubscriberView)
+class OTSubscriberView: UIView {
+  @objc var streamId: NSString?
+  override init(frame: CGRect) {
+    super.init(frame: frame)
+  }
+  
+  required init?(coder aDecoder: NSCoder) {
+    fatalError("init(coder:) has not been implemented")
+  }
+  
+  override func layoutSubviews() {
+    if let subscriberView = OTRN.sharedState.subscribers[streamId! as String]?.view {
+      subscriberView.frame = self.bounds
+      addSubview(subscriberView)
+    }
+  }
+}
+

package/ios/OpenTokReactNative.h

@@ -0,0 +1,13 @@
+//
+//  OpenTokReactNative.h
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 5/16/18.
+//  Copyright © 2018 TokBox Inc. All rights reserved.
+//
+
+#import <Foundation/Foundation.h>
+
+@interface OpenTokReactNative : NSObject
+
+@end

package/ios/OpenTokReactNative.m

@@ -0,0 +1,13 @@
+//
+//  OpenTokReactNative.m
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 5/16/18.
+//  Copyright © 2018 TokBox Inc. All rights reserved.
+//
+
+#import "OpenTokReactNative.h"
+
+@implementation OpenTokReactNative
+
+@end

package/ios/SocketReactNative.m

@@ -0,0 +1,38 @@
+#import <React/RCTBridgeModule.h>
+#import <React/RCTEventEmitter.h>
+
+@interface RCT_EXTERN_MODULE(SocketReactNative, RCTEventEmitter)
+
+RCT_EXTERN_METHOD(initialize:(NSDictionary *)args
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(connect:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(disconnect:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(subscribe:(NSString*)channelName
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(unsubscribe:(NSString*)channelName
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(trigger:(NSString*)channelName
+                  eventName:(NSString*)eventName
+                  data:id
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN_METHOD(onAuthorizer:(NSString*)channelName
+                  socketID:(NSString*)socketID
+                  data:(NSDictionary*)data
+                  resolve:(RCTPromiseResolveBlock)resolve
+                  reject:(RCTPromiseRejectBlock)reject)
+
+RCT_EXTERN__BLOCKING_SYNCHRONOUS_METHOD(getSocketId)
+
+@end

package/ios/SocketReactNative.swift

@@ -0,0 +1,276 @@
+import PusherSwift
+import Foundation
+
+@objc(SocketReactNative)
+@objcMembers class SocketReactNative: RCTEventEmitter, PusherDelegate, Authorizer {
+    private static var shared: SocketReactNative!
+    private static var pusher: Pusher!
+
+    private var authorizerCompletionHandlers = [String: ([String:String]) -> Void]()
+    private var authorizerCompletionHandlerTimeout = 10 // seconds
+
+    private let subscriptionErrorType = "SubscriptionError"
+    private let authErrorType = "AuthError"
+    private let socketEventPrefix = "SocketReactNative"
+
+    override init() {
+        super.init()
+
+        SocketReactNative.shared = self
+    }
+
+    override func supportedEvents() -> [String]! {
+        return ["\(socketEventPrefix):onConnectionStateChange",
+                "\(socketEventPrefix):onSubscriptionError",
+                "\(socketEventPrefix):onSubscriptionCount",
+                "\(socketEventPrefix):onAuthorizer",
+                "\(socketEventPrefix):onError",
+                "\(socketEventPrefix):onDecryptionFailure",
+                "\(socketEventPrefix):onEvent",
+                "\(socketEventPrefix):onMemberAdded",
+                "\(socketEventPrefix):onMemberRemoved"]
+    }
+
+    private func callback(name:String, body:Any) -> Void {
+        let socketEventName = "\(socketEventPrefix):\(name)"
+        SocketReactNative.shared.sendEvent(withName:socketEventName, body:body)
+    }
+
+    func initialize(_ args:[String: Any], resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        if SocketReactNative.pusher != nil {
+            SocketReactNative.pusher.unsubscribeAll()
+            SocketReactNative.pusher.disconnect()
+        }
+        var authMethod:AuthMethod = .noMethod
+        if args["authEndpoint"] is String {
+            authMethod = .endpoint(authEndpoint: args["authEndpoint"] as! String)
+        } else if args["authorizer"] is Bool {
+            authMethod = .authorizer(authorizer: SocketReactNative.shared)
+        }
+        var host:PusherHost = .defaultHost
+        if args["host"] is String {
+            host = .host(args["host"] as! String)
+        } else if args["cluster"] != nil {
+            host = .cluster(args["cluster"] as! String)
+        }
+        var useTLS:Bool = true
+        if args["useTLS"] is Bool {
+            useTLS = args["useTLS"] as! Bool
+        }
+        var port:Int
+        if useTLS {
+            port = 443
+            if args["wssPort"] is Int {
+                port = args["wssPort"] as! Int
+            }
+        } else {
+            port = 80
+            if args["wsPort"] is Int {
+                port = args["wsPort"] as! Int
+            }
+        }
+        var activityTimeout:TimeInterval? = nil
+        if args["activityTimeout"] is TimeInterval {
+            activityTimeout = args["activityTimeout"] as! Double / 1000.0
+        }
+        var path:String? = nil
+        if args["path"] is String {
+            path = (args["path"] as! String)
+        }
+        let options = PusherClientOptions(
+            authMethod: authMethod,
+            host: host,
+            port: port,
+            path: path,
+            useTLS: useTLS,
+            activityTimeout: activityTimeout
+        )
+        SocketReactNative.pusher = Pusher(key: args["apiKey"] as! String, options: options)
+        if args["maxReconnectionAttempts"] is Int {
+            SocketReactNative.pusher.connection.reconnectAttemptsMax = (args["maxReconnectionAttempts"] as! Int)
+        }
+        if args["maxReconnectGapInSeconds"] is TimeInterval {
+            SocketReactNative.pusher.connection.maxReconnectGapInSeconds = (args["maxReconnectGapInSeconds"] as! TimeInterval)
+        }
+        if args["pongTimeout"] is Int {
+            SocketReactNative.pusher.connection.pongResponseTimeoutInterval = args["pongTimeout"] as! TimeInterval / 1000.0
+        }
+
+        if let authorizerTimeoutInSeconds = args["authorizerTimeoutInSeconds"] as? Int {
+            SocketReactNative.shared.authorizerCompletionHandlerTimeout = authorizerTimeoutInSeconds
+        }
+
+        SocketReactNative.pusher.connection.delegate = SocketReactNative.shared
+        SocketReactNative.pusher.bind(eventCallback: onEvent)
+        resolve(nil)
+    }
+
+    override static func requiresMainQueueSetup() -> Bool {
+        return false
+    }
+
+    public func fetchAuthValue(socketID: String, channelName: String, completionHandler: @escaping (PusherAuth?) -> Void) {
+        SocketReactNative.shared.callback(name:"onAuthorizer", body: [
+            "socketId": socketID,
+            "channelName": channelName
+        ])
+
+        let key = channelName + socketID
+        let authCallback = { (authParams:[String:String]) in
+            if let authParam = authParams["auth"] {
+                completionHandler(PusherAuth(auth: authParam, channelData: authParams["channel_data"], sharedSecret: authParams["shared_secret"]))
+            } else {
+                completionHandler(PusherAuth(auth: "<missing_auth_param>:error", channelData: authParams["channel_data"], sharedSecret: authParams["shared_secret"]))
+            }
+        }
+        authorizerCompletionHandlers[key] = authCallback
+
+        // the JS thread might not call onAuthorizer – we need to cleanup the completion handler after timeout
+        let timeout = DispatchTimeInterval.seconds(SocketReactNative.shared.authorizerCompletionHandlerTimeout)
+        DispatchQueue.main.asyncAfter(deadline: .now() + timeout) {
+            if let storedAuthHandler = SocketReactNative.shared.authorizerCompletionHandlers.removeValue(forKey: key) {
+                storedAuthHandler(["auth": "<authorizer_timeout>:error"])
+            }
+        }
+    }
+
+    public func onAuthorizer(_ channelName: String, socketID: String, data:[String:String], resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        let key = channelName + socketID
+        if let storedAuthHandler = authorizerCompletionHandlers.removeValue(forKey: key) {
+            storedAuthHandler(data)
+        }
+    }
+
+    public func changedConnectionState(from old: ConnectionState, to new: ConnectionState) {
+        SocketReactNative.shared.callback(name:"onConnectionStateChange", body:[
+            "previousState": old.stringValue(),
+            "currentState": new.stringValue()
+        ])
+    }
+
+    public func debugLog(message: String) {
+        //print("DEBUG:", message)
+    }
+
+    public func subscribedToChannel(name: String) {
+        // Handled by global handler
+    }
+
+    public func failedToSubscribeToChannel(name: String, response: URLResponse?, data: String?, error: NSError?) {
+        var code = ""
+        var type = subscriptionErrorType
+        if let httpResponse = response as? HTTPURLResponse {
+            code = String(httpResponse.statusCode)
+            type = authErrorType
+        }
+
+        SocketReactNative.shared.callback(name:"onSubscriptionError", body:[
+            "message": (error != nil) ? error!.localizedDescription : ((data != nil) ? data! : error.debugDescription),
+            "type": type,
+            "code": code,
+            "channelName": name
+        ])
+    }
+
+    public func receivedError(error: PusherError) {
+        SocketReactNative.shared.callback(
+            name:"onError", body:[
+                "message": error.message,
+                "code": error.code ?? -1,
+                "error": error.debugDescription
+            ]
+        )
+    }
+
+    public func failedToDecryptEvent(eventName: String, channelName: String, data: String?) {
+        SocketReactNative.shared.callback(
+            name:"onDecryptionFailure", body:[
+                "eventName": eventName,
+                "reason": data
+            ]
+        )
+    }
+
+    public func connect(_ resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        SocketReactNative.pusher.connect()
+        resolve(nil)
+    }
+
+    public func disconnect(_ resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        SocketReactNative.pusher.disconnect()
+        resolve(nil)
+    }
+
+    public func getSocketId() -> String? {
+        return SocketReactNative.pusher.connection.socketId
+    }
+
+    func onEvent(event:PusherEvent) {
+        var userId:String? = nil
+        var mappedEventName:String? = nil
+        if event.eventName == "pusher:subscription_succeeded" {
+            if let channel = SocketReactNative.pusher.connection.channels.findPresence(name: event.channelName!) {
+                userId = channel.myId
+            }
+            mappedEventName = "pusher_internal:subscription_succeeded"
+        }
+        SocketReactNative.shared.callback(
+            name:"onEvent",body:[
+                "channelName": event.channelName,
+                "eventName": mappedEventName ?? event.eventName,
+                "userId": event.userId ?? userId,
+                "data": event.data
+            ]
+        )
+    }
+
+    func subscribe(_ channelName:String, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        if channelName.hasPrefix("presence-") {
+            let onMemberAdded:(PusherPresenceChannelMember) -> () = { user in
+                SocketReactNative.shared.callback(name:"onMemberAdded", body: [
+                    "channelName": channelName,
+                    "user": ["userId": user.userId, "userInfo": user.userInfo ]
+                ])
+            }
+            let onMemberRemoved:(PusherPresenceChannelMember) -> () = { user in
+                SocketReactNative.shared.callback(name:"onMemberRemoved", body: [
+                    "channelName": channelName,
+                    "user": ["userId": user.userId, "userInfo": user.userInfo ]
+                ])
+            }
+            SocketReactNative.pusher.subscribeToPresenceChannel(
+                channelName: channelName,
+                onMemberAdded: onMemberAdded,
+                onMemberRemoved: onMemberRemoved
+            )
+        } else {
+            let onSubscriptionCount:(Int) -> () = { subscriptionCount in
+                SocketReactNative.shared.callback(
+                    name:"onEvent",body:[
+                        "channelName": channelName,
+                        "eventName": "pusher_internal:subscription_count",
+                        "userId": nil,
+                        "data": [
+                            "subscription_count": subscriptionCount
+                        ]
+                    ]
+                )
+            }
+            SocketReactNative.pusher.subscribe(channelName: channelName,
+                                                        onSubscriptionCountChanged: onSubscriptionCount)
+        }
+        resolve(nil)
+    }
+
+    func unsubscribe(_ channelName:String, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        SocketReactNative.pusher.unsubscribe(channelName)
+        resolve(nil)
+    }
+
+    func trigger(_ channelName:String, eventName:String, data:Any, resolve:RCTPromiseResolveBlock,reject:RCTPromiseRejectBlock) {
+        if let channel = SocketReactNative.pusher.connection.channels.find(name: channelName) {
+            channel.trigger(eventName: eventName, data: data)
+        }
+        resolve(nil)
+    }
+}

package/ios/Utils/EventUtils.swift

@@ -0,0 +1,143 @@
+//
+//  EventUtils.swift
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 11/3/18.
+//  Copyright © 2018 TokBox Inc. All rights reserved.
+//
+
+import Foundation
+
+class EventUtils {
+    
+    static var sessionPreface: String = "session:";
+    static var publisherPreface: String = "publisher:";
+    static var subscriberPreface: String = "subscriber:";
+    
+    static func prepareJSConnectionEventData(_ connection: OTConnection) -> Dictionary<String, Any> {
+        var connectionInfo: Dictionary<String, Any> = [:];
+        guard connection != nil else { return connectionInfo }
+        connectionInfo["connectionId"] = connection.connectionId;
+        connectionInfo["creationTime"] = convertDateToString(connection.creationTime);
+        connectionInfo["data"] = connection.data;
+        return connectionInfo;
+    }
+    
+    static func prepareJSStreamEventData(_ stream: OTStream) -> Dictionary<String, Any> {
+        var streamInfo: Dictionary<String, Any> = [:];
+        guard OTRN.sharedState.sessions[stream.session.sessionId] != nil else { return streamInfo }
+        streamInfo["streamId"] = stream.streamId;
+        streamInfo["name"] = stream.name;
+        streamInfo["connectionId"] = stream.connection.connectionId;
+        streamInfo["connection"] = prepareJSConnectionEventData(stream.connection);
+        streamInfo["hasAudio"] = stream.hasAudio;
+        streamInfo["sessionId"] = stream.session.sessionId;
+        streamInfo["hasVideo"] = stream.hasVideo;
+        streamInfo["creationTime"] = convertDateToString(stream.creationTime);
+        streamInfo["height"] = stream.videoDimensions.height;
+        streamInfo["width"] = stream.videoDimensions.width;
+        streamInfo["videoType"] = stream.videoType == OTStreamVideoType.screen ? "screen" : "camera"
+        return streamInfo;
+    }
+    
+    static func prepareJSErrorEventData(_ error: OTError) -> Dictionary<String, Any> {
+        var errorInfo: Dictionary<String, Any> = [:];
+        errorInfo["code"] = error.code;
+        errorInfo["message"] = error.localizedDescription;
+        return errorInfo;
+    }
+    
+    static func prepareStreamPropertyChangedEventData(_ changedProperty: String, oldValue: Any, newValue: Any, stream: Dictionary<String, Any>) -> Dictionary<String, Any> {
+        var streamPropertyEventData: Dictionary<String, Any> = [:];
+        streamPropertyEventData["oldValue"] = oldValue;
+        streamPropertyEventData["newValue"] = newValue;
+        streamPropertyEventData["stream"] = stream;
+        streamPropertyEventData["changedProperty"] = changedProperty;
+        return streamPropertyEventData
+    }
+
+    static func preparePublisherRtcStats(_ rtcStatsReport: [OTPublisherRtcStats]) -> [Dictionary<String, Any>] {
+        var statsArray:[Dictionary<String, Any>] = [];
+        for value in rtcStatsReport {
+            var stats:Dictionary<String, Any> = [:];
+            stats["connectionId"] = value.connectionId;
+            stats["jsonArrayOfReports"] = value.jsonArrayOfReports;
+            statsArray.append(stats);
+        }
+        return statsArray;
+    }
+
+    static func preparePublisherVideoNetworkStats(_ videoStats: [OTPublisherKitVideoNetworkStats]) -> [Dictionary<String, Any>] {
+        var statsArray:[Dictionary<String, Any>] = [];
+        for value in videoStats {
+            var stats: Dictionary<String, Any> = [:];
+            stats["connectionId"] = value.connectionId;
+            stats["subscriberId"] = value.subscriberId;
+            stats["videoPacketsLost"] = value.videoPacketsLost;
+            stats["videoBytesSent"] = value.videoBytesSent;
+            stats["videoPacketsSent"] = value.videoPacketsSent;
+            stats["timestamp"] = value.timestamp;
+            statsArray.append(stats);
+        }
+        return statsArray;
+    }
+
+    static func preparePublisherAudioNetworkStats(_ audioStats: [OTPublisherKitAudioNetworkStats]) -> [Dictionary<String, Any>] {
+        var statsArray:[Dictionary<String, Any>] = [];
+        for value in audioStats {
+            var stats: Dictionary<String, Any> = [:];
+            stats["connectionId"] = value.connectionId;
+            stats["subscriberId"] = value.subscriberId;
+            stats["audioPacketsLost"] = value.audioPacketsLost;
+            stats["audioPacketsSent"] = value.audioPacketsSent;
+            stats["audioBytesSent"] = value.audioBytesSent;
+            stats["timestamp"] = value.timestamp;
+            statsArray.append(stats);
+        }
+        return statsArray;
+    }
+    
+    static func prepareSubscriberVideoNetworkStatsEventData(_ videoStats: OTSubscriberKitVideoNetworkStats) -> Dictionary<String, Any> {
+        var videoStatsEventData: Dictionary<String, Any> = [:];
+        videoStatsEventData["videoPacketsLost"] = videoStats.videoPacketsLost;
+        videoStatsEventData["videoBytesReceived"] = videoStats.videoBytesReceived;
+        videoStatsEventData["videoPacketsReceived"] = videoStats.videoPacketsReceived;
+        videoStatsEventData["timestamp"] = videoStats.timestamp;
+        return videoStatsEventData;
+    }
+    
+    static func prepareSubscriberAudioNetworkStatsEventData(_ audioStats: OTSubscriberKitAudioNetworkStats) -> Dictionary<String, Any> {
+        var audioStatsEventData: Dictionary<String, Any> = [:];
+        audioStatsEventData["audioPacketsLost"] = audioStats.audioPacketsLost;
+        audioStatsEventData["audioBytesReceived"] = audioStats.audioBytesReceived;
+        audioStatsEventData["audioPacketsReceived"] = audioStats.audioPacketsReceived;
+        audioStatsEventData["timestamp"] = audioStats.timestamp;
+        return audioStatsEventData;
+    }
+    
+    static func prepareJSSessionEventData(_ session: OTSession) -> Dictionary<String, Any> {
+        var sessionInfo: Dictionary<String, Any> = [:];
+        sessionInfo["sessionId"] = session.sessionId;
+        guard let connection = session.connection else { return sessionInfo };
+        sessionInfo["connection"] = prepareJSConnectionEventData(connection);
+        return sessionInfo;
+    }
+    
+    static func getSupportedEvents() -> [String] {
+        return ["\(sessionPreface)streamCreated", "\(sessionPreface)streamDestroyed", "\(sessionPreface)sessionDidConnect", "\(sessionPreface)sessionDidDisconnect", "\(sessionPreface)connectionCreated", "\(sessionPreface)connectionDestroyed", "\(sessionPreface)didFailWithError", "\(publisherPreface)streamCreated", "\(sessionPreface)signal", "\(publisherPreface)streamDestroyed", "\(publisherPreface)didFailWithError", "\(publisherPreface)audioLevelUpdated", "\(publisherPreface)rtcStatsReport", "\(subscriberPreface)subscriberDidConnect", "\(subscriberPreface)subscriberDidDisconnect", "\(subscriberPreface)didFailWithError", "\(subscriberPreface)videoNetworkStatsUpdated", "\(subscriberPreface)audioNetworkStatsUpdated", "\(subscriberPreface)audioLevelUpdated", "\(subscriberPreface)subscriberVideoEnabled", "\(subscriberPreface)subscriberVideoDisabled", "\(subscriberPreface)subscriberVideoDisableWarning", "\(subscriberPreface)subscriberVideoDisableWarningLifted", "\(subscriberPreface)subscriberVideoDataReceived", "\(sessionPreface)archiveStartedWithId", "\(sessionPreface)archiveStoppedWithId", "\(sessionPreface)sessionDidBeginReconnecting", "\(sessionPreface)sessionDidReconnect", "\(sessionPreface)streamPropertyChanged", "\(subscriberPreface)subscriberDidReconnect", "\(subscriberPreface)subscriberCaptionReceived"];
+    }
+    
+    static func convertDateToString(_ creationTime: Date) -> String {
+        let dateFormatter: DateFormatter = DateFormatter();
+        dateFormatter.dateFormat = "yyyy-MM-dd HH:mm:ss";
+        dateFormatter.timeZone = TimeZone(abbreviation: "UTC");
+        return dateFormatter.string(from:creationTime);
+    }
+
+    static func createErrorMessage(_ message: String) -> Dictionary<String, String> {
+        var errorInfo: Dictionary<String, String> = [:]
+        errorInfo["message"] = message
+        return errorInfo
+    }
+    
+}

package/ios/Utils/Utils.swift

@@ -0,0 +1,126 @@
+//
+//  Utils.swift
+//  OpenTokReactNative
+//
+//  Created by Manik Sachdeva on 11/3/18.
+//  Copyright © 2018 TokBox Inc. All rights reserved.
+//
+
+import Foundation
+
+class Utils {
+    static func sanitizeCameraResolution(_ resolution: Any) -> OTCameraCaptureResolution {
+        guard let cameraResolution = resolution as? String else { return .medium };
+        switch cameraResolution {
+        case "HIGH_1080P":
+            return .high1080p;
+        case "HIGH":
+            return .high;
+        case "LOW":
+            return .low;
+        default:
+            return .medium;
+        }
+    }
+    
+    static func sanitizeFrameRate(_ frameRate: Any) -> OTCameraCaptureFrameRate {
+        guard let cameraFrameRate = frameRate as? Int else { return OTCameraCaptureFrameRate(rawValue: 30)!; }
+        return OTCameraCaptureFrameRate(rawValue: cameraFrameRate)!;
+    }
+    
+    static func sanitizePreferredFrameRate(_ frameRate: Any) -> Float {
+        guard let sanitizedFrameRate = frameRate as? Float else { return Float.greatestFiniteMagnitude; }
+        return sanitizedFrameRate;
+    }
+    
+    static func sanitizePreferredResolution(_ resolution: Any) -> CGSize {
+        guard let preferredRes = resolution as? Dictionary<String, Any> else { return CGSize(width: CGFloat.greatestFiniteMagnitude, height: CGFloat.greatestFiniteMagnitude) };
+        return CGSize(width: preferredRes["width"] as! CGFloat, height: preferredRes["height"] as! CGFloat);
+    }
+    
+    static func sanitizeBooleanProperty(_ property: Any) -> Bool {
+        guard let prop = property as? Bool else { return true; }
+        return prop;
+    }
+
+    static func sanitizeStringProperty(_ property: Any) -> String {
+        guard let prop = property as? String else { return ""; }
+        return prop;
+    }
+    
+    static func getPublisherId(_ publisher: OTPublisher) -> String {
+        let publisherIds = OTRN.sharedState.publishers.filter {$0.value == publisher}
+        guard let publisherId = publisherIds.first else { return ""; }
+        return publisherId.key;
+    }
+
+    
+    static func convertOTSubscriberVideoEventReasonToString(_ reason: OTSubscriberVideoEventReason) -> String {
+        switch reason {
+        case OTSubscriberVideoEventReason.publisherPropertyChanged:
+            return "PublisherPropertyChanged"
+        case OTSubscriberVideoEventReason.subscriberPropertyChanged:
+            return "SubscriberPropertyChanged"
+        case OTSubscriberVideoEventReason.qualityChanged:
+            return "QualityChanged"
+        case OTSubscriberVideoEventReason.codecNotSupported:
+            return "CodecNotSupported"
+        }
+    }
+    
+    static func sanitizeIncludeServer(_ value: Any)  -> OTSessionICEIncludeServers {
+        var includeServers = OTSessionICEIncludeServers.all;
+        if let includeServer = value as? String, includeServer == "custom" {
+            includeServers = OTSessionICEIncludeServers.custom;
+        }
+        return includeServers;
+    }
+    
+    static func sanitizeTransportPolicy(_ value: Any)  -> OTSessionICETransportPolicy {
+        var transportPolicy = OTSessionICETransportPolicy.all;
+        if let policy = value as? String, policy == "relay" {
+            transportPolicy = OTSessionICETransportPolicy.relay;
+        }
+        return transportPolicy;
+    }
+    
+    static func sanitiseServerList(_ serverList: Any) -> [(urls: [String], userName: String, credential: String)] {
+        var iceServerList: [([String], String, String)] = []
+        
+        if let serverList = serverList as? [[String: Any]] {
+            for server in serverList {
+                if let urls = server["urls"] as? [String], let username = server["username"] as? String, let credential = server["credential"] as? String {
+                    iceServerList.append((urls, username, credential))
+                }
+            }
+        }
+        return iceServerList
+    }
+    
+    static func sanitizeIceServer(_ serverList: Any, _ transportPolicy: Any, _ includeServer: Any) -> OTSessionICEConfig {
+        let myICEServerConfiguration: OTSessionICEConfig = OTSessionICEConfig();
+        myICEServerConfiguration.includeServers = Utils.sanitizeIncludeServer(includeServer);
+        myICEServerConfiguration.transportPolicy = Utils.sanitizeTransportPolicy(transportPolicy);
+        let serverList = Utils.sanitiseServerList(serverList);
+        for server in serverList {
+            for url in server.urls {
+                myICEServerConfiguration.addICEServer(withURL: url, userName: server.userName, credential: server.credential, error: nil);
+            }
+        }
+        return myICEServerConfiguration;
+    }
+    
+    static func convertVideoContentHint(_ videoContentHint: Any) -> OTVideoContentHint {
+        guard let contentHint = videoContentHint as? String else { return OTVideoContentHint.none };
+        switch contentHint {
+            case "motion":
+                return OTVideoContentHint.motion
+            case "detail":
+                return OTVideoContentHint.detail
+            case "text":
+                return OTVideoContentHint.text
+            default:
+                return OTVideoContentHint.none
+        }
+    }
+}