@100mslive/react-native-hms 2.0.0-alpha.0 → 2.0.0-alpha.1

package/ios/HMSHelper.swift

@@ -1,8 +1,10 @@
 import HMSSDK
 import Foundation
+import HMSNoiseCancellationModels
 
 class HMSHelper: NSObject {
     static var audioMixerSourceHashMap: [String: HMSAudioNode]?
+    static var iterator: HMSPeerListIterator?
 
     static func getUnavailableRequiredKey(_ data: NSDictionary, _ requiredKeys: [String]) -> String {
         for (key) in requiredKeys {
@@ -17,7 +19,7 @@ class HMSHelper: NSObject {
         return "SEND_ALL_REQUIRED_KEYS"
     }
 
-    static func getPeerFromPeerId(_ peerID: String?, remotePeers: [HMSRemotePeer]?, localPeer: HMSLocalPeer?) -> HMSPeer? {
+    static func getPeerFromPeerId(_ peerID: String?, remotePeers: [HMSRemotePeer]?, localPeer: HMSLocalPeer? = nil) -> HMSPeer? {
 
         guard let peerID = peerID, let peers = remotePeers else { return nil }
         if peerID == localPeer?.peerID {
@@ -26,11 +28,26 @@ class HMSHelper: NSObject {
         return peers.first { $0.peerID == peerID }
     }
 
-    static func getRemotePeerFromPeerId(_ peerID: String?, remotePeers: [HMSRemotePeer]?) -> HMSPeer? {
+    static func getRemotePeerFromPeerId(_ peerID: String?, hmsSDK: HMSSDK?, completion: @escaping (_ peer: HMSPeer?) -> Void) {
+        guard let peerID = peerID, let hms = hmsSDK, let peers = hms.remotePeers else {
+            completion(nil)
+            return
+        }
 
-        guard let peerID = peerID, let peers = remotePeers else { return nil }
+        if let peerFromList = peers.first(where: { $0.peerID == peerID }) {
+            completion(peerFromList)
+            return
+        }
 
-        return peers.first { $0.peerID == peerID }
+        iterator = hms.getPeerListIterator(options: HMSPeerListIteratorOptions(filterByPeerIds: [peerID], limit: 1))
+        iterator?.next { peers, _ in
+
+            guard let nonnilPeers = peers, let firstPeer = nonnilPeers.first else {
+                completion(nil)
+                return
+            }
+            completion(firstPeer)
+        }
     }
 
     static func getRolesFromRoleNames(_ targetedRoles: [String]?, roles: [HMSRole]?) -> [HMSRole] {
@@ -150,7 +167,7 @@ class HMSHelper: NSObject {
                                 isPrebuilt: isPrebuilt)
     }
 
-    static func getLocalVideoSettings(_ settings: NSDictionary?) -> HMSVideoTrackSettings? {
+    static func getLocalVideoSettings(_ settings: NSDictionary?, _ videoPlugin: HMSVideoPlugin?) -> HMSVideoTrackSettings? {
         if settings === nil {
             return nil
         }
@@ -163,19 +180,20 @@ class HMSHelper: NSObject {
         let cameraFacingEncoded = HMSHelper.getCameraFacing(cameraFacing)
         let initialState = settings?.value(forKey: "initialState") as? String
         let initialStateEncoded = HMSHelper.getHMSTrackSettingsInitState(initialState)
+        let videoPlugins: [HMSVideoPlugin]? = if let videoPlugin = videoPlugin { [videoPlugin] } else { nil }
         let hmsTrackSettings = HMSVideoTrackSettings(codec: codec,
-                                                     resolution: resolution,
-                                                     maxBitrate: maxBitrate,
-                                                     maxFrameRate: maxFrameRate,
-                                                     cameraFacing: cameraFacingEncoded,
-                                                     simulcastSettings: nil,
-                                                     trackDescription: trackDescription,
-                                                     initialMuteState: initialStateEncoded,
-                                                     videoPlugins: nil)
+                                                    resolution: resolution,
+                                                    maxBitrate: maxBitrate,
+                                                    maxFrameRate: maxFrameRate,
+                                                    cameraFacing: cameraFacingEncoded,
+                                                    simulcastSettings: nil,
+                                                    trackDescription: trackDescription,
+                                                    initialMuteState: initialStateEncoded,
+                                                    videoPlugins: videoPlugins)
         return hmsTrackSettings
     }
 
-    static func getLocalAudioSettings(_ settings: NSDictionary?, _ hms: HMSSDK?, _ delegate: HMSManager?, _ id: String) -> HMSAudioTrackSettings? {
+    static func getLocalAudioSettings(_ settings: NSDictionary?, _ noiseCancellationPlugin: HMSNoiseCancellationPlugin?, _ hms: HMSSDK?, _ delegate: HMSManager?, _ id: String) -> HMSAudioTrackSettings? {
 
         guard let settings = settings
         else {
@@ -223,6 +241,10 @@ class HMSHelper: NSObject {
                         if let audioMode = audioMode {
                             builder.audioMode = audioMode
                         }
+
+                        if let noiseCancellationPlugin = noiseCancellationPlugin {
+                            builder.noiseCancellationPlugin = noiseCancellationPlugin
+                        }
                     }
 
                 } catch {
@@ -239,6 +261,59 @@ class HMSHelper: NSObject {
             if let audioMode = audioMode {
                 builder.audioMode = audioMode
             }
+
+            if let noiseCancellationPlugin = noiseCancellationPlugin {
+                builder.noiseCancellationPlugin = noiseCancellationPlugin
+            }
+        }
+    }
+
+    static func getHMSNoiseCancellationPlugin(_ modelData: NSDictionary?) -> HMSNoiseCancellationPlugin? {
+        guard let modelData = modelData
+        else {
+            print(#function, "No Noise Cancellation Model data passed!")
+            return nil
+        }
+        guard let modeName = modelData.value(forKey: "modelName") as? String else {
+            print(#function, "Noise Cancellation Model Name not passed!")
+            return nil
+        }
+        guard let initState = modelData.value(forKey: "initialState") as? String else {
+            print(#function, "Noise Cancellation Model initialState not passed!")
+            return nil
+        }
+
+        if let pathForNCModel = HMSNoiseCancellationModels.path(for: getHMSNoiseCancellationModelName(modeName)) {
+            return HMSNoiseCancellationPlugin(modelPath: pathForNCModel,
+                                              initialState: getHMSNoiseCancellationInitialState(initState))
+        } else {
+            assertionFailure("noise cancellation model was not found")
+        }
+        return nil
+    }
+
+    static func getHMSVideoPlugin(_ videoPluginData: NSDictionary?) -> HMSVideoPlugin? {
+        guard let videoPluginDict = videoPluginData else {
+            print(#function, "No Video Plugin data passed!")
+            return nil
+        }
+        guard let videoPluginType = videoPluginDict.value(forKey: "type") as? String else {
+            print(#function, "No HMSVideoPlugin `type` passed!")
+            return nil
+        }
+        switch videoPluginType {
+        case "HMSVirtualBackgroundPlugin":
+            if #available(iOS 15.0, *) {
+                return HMSVirtualBackgroundPlugin(backgroundImage: nil, blurRadius: 100)
+            } else {
+                print(#function, "HMSVirtualBackgroundPlugin is not available below iOS 15.0")
+                return nil
+            }
+        case "HMSVideoFilterPlugin":
+            return HMSVideoFilterPlugin()
+        default:
+            print(#function, "Unknown HMSVideoPlugin `type` passed!")
+            return nil
         }
     }
 
@@ -256,6 +331,28 @@ class HMSHelper: NSObject {
         return HMSVideoResolution.init(width: width, height: height)
     }
 
+    static func getHMSNoiseCancellationModelName(_ modelNameString: String?) -> HMSNoiseCancellationModels.ModelName {
+        switch modelNameString {
+        case "SMALL_FULL_BAND":
+            return .smallFullBand
+        default:
+            print(#function, "Unknown Noise Cancellation Model name passed, using smallFullBand as default!")
+            return .smallFullBand
+        }
+    }
+
+    static func getHMSNoiseCancellationInitialState(_ initState: String?) -> HMSNoiseCancellationInitialState {
+        switch initState {
+        case "ENABLED":
+            return .enabled
+        case "DISABLED":
+            return .disabled
+        default:
+            print(#function, "Unknown Noise Cancellation Model initState passed, using Enabled as default!")
+            return .enabled
+        }
+    }
+
     static func getVideoCodec(_ codecString: String?) -> HMSCodec {
         switch codecString {
         case "H264":
@@ -347,6 +444,21 @@ class HMSHelper: NSObject {
         return nil
     }
 
+    static func getPeerListIteratorOptions(_ data: NSDictionary?) -> HMSPeerListIteratorOptions? {
+        guard let config = data else {
+            return nil
+        }
+
+        let role = config["byRoleName"] as? String
+        let peerIds = config["peerIds"] as? [String]
+
+        if let limit = config["limit"] as? Int {
+            return HMSPeerListIteratorOptions(filterByRoleName: role, filterByPeerIds: peerIds, limit: limit)
+        }
+
+        return HMSPeerListIteratorOptions(filterByRoleName: role, filterByPeerIds: peerIds)
+    }
+
     private static func getAudioMode(from mode: String?) -> HMSAudioMode? {
         switch mode {
         case "voice":

package/ios/HMSInteractivityDecoder.swift

@@ -0,0 +1,314 @@
+//
+//  HMSInteractivityDecoder.swift
+//  react-native-hms
+//
+//  Created by Jatin Nagar on 18/01/24.
+//
+
+import Foundation
+import HMSSDK
+
+class HMSInteractivityDecoder {
+    static func getHMSPoll(_ poll: HMSPoll) -> [String: Any] {
+        var dict: [String: Any] = [
+            "anonymous": poll.anonymous,
+            "type": poll.category.rawValue,
+            "duration": poll.duration,
+            "pollId": poll.pollID,
+            "rolesThatCanViewResponses": HMSDecoder.getAllRoles(poll.rolesThatCanViewResponses),
+            "rolesThatCanVote": HMSDecoder.getAllRoles(poll.rolesThatCanVote),
+            "state": poll.state.rawValue,
+            "title": poll.title
+        ]
+        if let createdBy = poll.createdBy {
+            dict["createdBy"] = HMSDecoder.getHmsPeerSubset(createdBy)
+        }
+        if let mode = poll.mode {
+            dict["mode"] = mode.rawValue
+        }
+        if let questionCount = poll.questionCount {
+            dict["questionCount"] = questionCount
+        }
+        if let questions = poll.questions {
+            dict["questions"] = getHMSPollQuestions(questions)
+        }
+        if let result = poll.result {
+            dict["result"] = getHMSPollResult(result)
+        }
+        if let startedAt = poll.startedAt {
+            dict["startedAt"] = startedAt.timeIntervalSince1970 * 1000
+        }
+        if let startedBy = poll.startedBy {
+            dict["startedBy"] = HMSDecoder.getHmsPeerSubset(startedBy)
+        }
+        if let stoppedAt = poll.stoppedAt {
+            dict["stoppedAt"] = stoppedAt.timeIntervalSince1970 * 1000
+        }
+        if let stoppedBy = poll.stoppedBy {
+            dict["stoppedBy"] = HMSDecoder.getHmsPeerSubset(stoppedBy)
+        }
+        return dict
+    }
+
+    static func getHMSPollQuestions(_ hmsPollQuestions: [HMSPollQuestion]) -> [[String: AnyHashable]] {
+        var questions = [[String: AnyHashable]]()
+
+        hmsPollQuestions.forEach { question in
+            questions.append(getHMSPollQuestion(question))
+        }
+        return questions
+    }
+
+    static func getHMSPollQuestion(_ hmsPollQuestion: HMSPollQuestion) -> [String: AnyHashable] {
+        var dict: [String: AnyHashable] = [
+            "duration": hmsPollQuestion.duration,
+            "index": hmsPollQuestion.index,
+            "myResponses": getHMSPollQuestionResponses(hmsPollQuestion.myResponses),
+            "once": hmsPollQuestion.once,
+            "skippable": hmsPollQuestion.skippable,
+            "text": hmsPollQuestion.text,
+            "type": hmsPollQuestion.type.rawValue,
+            "voted": hmsPollQuestion.voted,
+            "weight": hmsPollQuestion.weight
+        ]
+        if let answer = hmsPollQuestion.answer {
+            dict["answer"] = getHMSPollQuestionAnswer(answer)
+        }
+        if let answerMaxLen = hmsPollQuestion.answerMaxLen {
+            dict["answerMaxLen"] = answerMaxLen
+        }
+        if let answerMinLen = hmsPollQuestion.answerMinLen {
+            dict["answerMinLen"] = answerMinLen
+        }
+        if let options = hmsPollQuestion.options {
+            dict["options"] = getHMSPollQuestionOptions(options)
+        }
+        if let responses = hmsPollQuestion.responses {
+            dict["responses"] = getHMSPollQuestionResponses(responses)
+        }
+        return dict
+    }
+
+    static func getHMSPollQuestionAnswer(_ hmsPollQuestionAnswer: HMSPollQuestionAnswer) -> [String: AnyHashable] {
+        var dict: [String: AnyHashable] = [
+            "hidden": hmsPollQuestionAnswer.hidden
+        ]
+        if let option = hmsPollQuestionAnswer.option {
+            dict["option"] = option
+        }
+        if let options = hmsPollQuestionAnswer.options {
+            dict["options"] = options
+        }
+        return dict
+    }
+
+    static func getHMSPollQuestionOptions(_ hmsPollQuestionOptions: [HMSPollQuestionOption]) -> [[String: AnyHashable]] {
+        var dict = [[String: AnyHashable]]()
+        hmsPollQuestionOptions.forEach { hmsPollQuestionOption in
+            dict.append(getHMSPollQuestionOption(hmsPollQuestionOption))
+        }
+        return dict
+    }
+
+    static func getHMSPollQuestionOption(_ hmsPollQuestionOption: HMSPollQuestionOption) -> [String: AnyHashable] {
+        return [
+            "text": hmsPollQuestionOption.text,
+            "index": hmsPollQuestionOption.index,
+            "voteCount": hmsPollQuestionOption.voteCount,
+            "weight": hmsPollQuestionOption.weight
+        ]
+    }
+
+    static func getHMSPollQuestionResponses(_ hmsPollQuestionResponses: [HMSPollQuestionResponse]) -> [[String: AnyHashable]] {
+        var dict = [[String: AnyHashable]]()
+        hmsPollQuestionResponses.forEach { hmsPollQuestionResponse in
+            dict.append(getHMSPollQuestionResponse(hmsPollQuestionResponse))
+        }
+        return dict
+    }
+
+    static func getHMSPollQuestionResponse(_ hmsPollQuestionResponse: HMSPollQuestionResponse) -> [String: AnyHashable] {
+        var dict: [String: AnyHashable] = [
+            "duration": hmsPollQuestionResponse.duration,
+            "option": hmsPollQuestionResponse.option,
+            "questionId": hmsPollQuestionResponse.questionID,
+            "skipped": hmsPollQuestionResponse.skipped,
+            "text": hmsPollQuestionResponse.text,
+            "type": hmsPollQuestionResponse.type.rawValue,
+            "update": hmsPollQuestionResponse.update
+        ]
+        if let options = hmsPollQuestionResponse.options {
+            dict["options"] = options
+        }
+        if let peerInfo = hmsPollQuestionResponse.peer {
+            dict["peer"] = getHMSPollResponsePeerInfo(peerInfo)
+        }
+        if let responseFinal = hmsPollQuestionResponse.responseFinal {
+            dict["responseFinal"] = responseFinal
+        }
+        return dict
+    }
+
+    static func getHMSPollResponsePeerInfo(_ hmsPollResponsePeerInfo: HMSPollResponsePeerInfo) -> [String: AnyHashable] {
+        var dict = [String: AnyHashable]()
+
+        if let customerUserID = hmsPollResponsePeerInfo.customerUserID {
+            dict["customerUserId"] = customerUserID
+        }
+        if let peerID = hmsPollResponsePeerInfo.peerID {
+            dict["peerId"] = peerID
+        }
+        if let userHash = hmsPollResponsePeerInfo.userHash {
+            dict["userHash"] = userHash
+        }
+        if let userName = hmsPollResponsePeerInfo.userName {
+            dict["userName"] = userName
+        }
+        return dict
+    }
+
+    static func getHMSPollResult(_ hmsPollResult: HMSPollResult) -> [String: AnyHashable] {
+        return [
+            "maxUserCount": hmsPollResult.maxUserCount,
+            "questions": getHMSPollQuestionResults(hmsPollResult.questions),
+            "totalResponse": hmsPollResult.totalResponse,
+            "userCount": hmsPollResult.userCount
+        ]
+    }
+
+    static func getHMSPollQuestionResults(_ hmsPollQuestionResults: [HMSPollQuestionResult]) -> [[String: AnyHashable]] {
+        var results = [[String: AnyHashable]]()
+
+        hmsPollQuestionResults.forEach { result in
+            results.append(getHMSPollQuestionResult(result))
+        }
+        return results
+    }
+
+    static func getHMSPollQuestionResult(_ hmsPollQuestionResult: HMSPollQuestionResult) -> [String: AnyHashable] {
+        var result: [String: AnyHashable] = [
+            "type": hmsPollQuestionResult.type,
+            "correctVotes": hmsPollQuestionResult.correctVotes,
+            "question": hmsPollQuestionResult.question,
+            "skippedVotes": hmsPollQuestionResult.skippedVotes,
+            "totalVotes": hmsPollQuestionResult.totalVotes
+        ]
+        if let optionVoteCounts = hmsPollQuestionResult.optionVoteCounts {
+            result["optionVoteCounts"] = optionVoteCounts
+        }
+        return result
+    }
+
+    static func getHMSPollQuestionResponseResults(_ hmsPollQuestionResponseResults: [HMSPollQuestionResponseResult]) -> [[String: AnyHashable]] {
+        var results = [[String: AnyHashable]]()
+
+        hmsPollQuestionResponseResults.forEach { result in
+            results.append(getHMSPollQuestionResponseResult(result))
+        }
+        return results
+    }
+
+    static func getHMSPollQuestionResponseResult(_ hmsPollQuestionResponseResult: HMSPollQuestionResponseResult) -> [String: AnyHashable] {
+        var result: [String: AnyHashable] = [
+            "question": hmsPollQuestionResponseResult.question
+        ]
+        if let correct = hmsPollQuestionResponseResult.correct {
+            result["correct"] = correct
+        }
+        if let error = hmsPollQuestionResponseResult.error {
+            result["error"] = error.localizedDescription
+        }
+        return result
+    }
+
+    static func getLeaderboardResponse(_ response: HMSPollLeaderboardResponse) -> [String: AnyHashable] {
+        var result = [String: AnyHashable]()
+
+        result["hasNext"] = response.hasNext
+
+        result["summary"] = getLeaderboardSummary(response.summary)
+
+        result["entries"] = getLeaderboardEntries(response.entries)
+
+        return result
+    }
+
+    static func getLeaderboardSummary(_ summary: HMSPollLeaderboardSummary) -> [String: AnyHashable] {
+        var result = [String: AnyHashable]()
+
+        result["averageScore"] = summary.averageScore
+        result["averageTime"] = summary.averageTime
+        result["totalPeersCount"] = summary.totalPeersCount
+        result["respondedCorrectlyPeersCount"] = summary.respondedCorrectlyPeersCount
+        result["respondedPeersCount"] = summary.respondedPeersCount
+
+        return result
+    }
+
+    static func getLeaderboardEntries(_ entries: [HMSPollLeaderboardEntry]) -> [[String: AnyHashable]] {
+        var result = [[String: AnyHashable]]()
+
+        for entry in entries {
+            result.append(getLeaderboardEntry(entry))
+        }
+
+        return result
+    }
+
+    static func getLeaderboardEntry(_ entry: HMSPollLeaderboardEntry) -> [String: AnyHashable] {
+        var result = [String: AnyHashable]()
+
+        result["duration"] = entry.duration
+        result["totalResponses"] = entry.totalResponses
+        result["correctResponses"] = entry.correctResponses
+        result["position"] = entry.position
+        result["score"] = entry.score
+
+        if let peer = entry.peer {
+            result["peer"] = getHMSPollResponsePeerInfo(peer)
+        }
+
+        return result
+    }
+
+    static func getHMSWhiteboard(_ hmsWhiteboard: HMSWhiteboard) -> [String: Any] {
+        var result: [String: Any] = [
+            "id": hmsWhiteboard.id,
+            "state": getWhiteboardState(hmsWhiteboard.state)
+        ]
+        if let owner = hmsWhiteboard.owner {
+            result["owner"] = HMSDecoder.getHmsPeerSubset(owner)
+        }
+        if let title = hmsWhiteboard.title {
+            result["title"] = title
+        }
+        if let urlString = hmsWhiteboard.url?.absoluteString {
+            result["url"] = urlString
+        }
+        return result
+    }
+
+    static func getWhiteboardState(_ state: HMSWhiteboard.WhiteboardState) -> String {
+        switch state {
+        case .started:
+            return "STARTED"
+        case .stopped:
+            return "STOPPED"
+        @unknown default:
+            print("@unknown default case: Invalid HMSWhiteboardUpdateType")
+            return "STOPPED"
+        }
+    }
+
+    static func getWhiteboardUpdateType(_ type: HMSWhiteboardUpdateType) -> String {
+        switch type {
+        case .started:
+            return "STARTED"
+        case .stopped:
+            return "STOPPED"
+        @unknown default:
+            print("@unknown default case: Invalid HMSWhiteboardUpdateType")
+            return "STOPPED"
+        }
+    }
+}

package/ios/HMSInteractivityHelper.swift

@@ -0,0 +1,169 @@
+//
+//  HMSInteractivityHelper.swift
+//  react-native-hms
+//
+//  Created by Jatin Nagar on 09/01/24.
+//
+
+import Foundation
+import HMSSDK
+
+class HMSInteractivityHelper {
+    static func getPollBuilderFromDict(_ data: NSDictionary, sdkRoles: [HMSRole]?) -> HMSPollBuilder {
+        let pollBuilder = HMSPollBuilder()
+
+        if let title = data["title"] as? String {
+            _ = pollBuilder.withTitle(title)
+        }
+
+        if let anonymous = data["anonymous"] as? Bool {
+            _ = pollBuilder.withAnonymous(anonymous)
+        }
+
+        if let duration = data["duration"] as? Int {
+            _ = pollBuilder.withDuration(duration)
+        }
+
+        if let category = data["type"] as? Int {
+            if let pollCategory = HMSPollCategory.init(rawValue: category) {
+                _ = pollBuilder.withCategory(pollCategory)
+            } else {
+                print("unable to create `HMSPollCategory` instance from given `type` value: \(category)")
+            }
+        }
+
+        if let pollID = data["pollId"] as? String {
+            _ = pollBuilder.withPollID(pollID)
+        }
+
+        if let rolesStrThatCanViewResponses = data["rolesThatCanViewResponses"] as? [String] {
+            let roles = HMSHelper.getRolesFromRoleNames(rolesStrThatCanViewResponses, roles: sdkRoles)
+            _ = pollBuilder.withRolesThatCanViewResponses(roles)
+        }
+
+        if let rolesStrThatCanVote = data["rolesThatCanVote"] as? [String] {
+            let roles = HMSHelper.getRolesFromRoleNames(rolesStrThatCanVote, roles: sdkRoles)
+            _ = pollBuilder.withRolesThatCanVote(roles)
+        }
+
+        if let userTrackingMode = data["mode"] as? Int {
+            if let pollUserTrackingMode = HMSPollUserTrackingMode.init(rawValue: userTrackingMode) {
+                _ = pollBuilder.withUserTrackingMode(pollUserTrackingMode)
+            } else {
+                print("unable to create `HMSPollUserTrackingMode` instance from given `userTrackingMode` value: \(userTrackingMode)")
+            }
+        }
+
+        if let questions = data["questions"] as? [NSDictionary] {
+            addQuestionsToPollBuilder(questions: questions, pollBuilder: pollBuilder)
+        }
+
+        return pollBuilder
+    }
+
+    static func addQuestionsToPollBuilder(questions: [NSDictionary], pollBuilder: HMSPollBuilder) {
+        questions.forEach { question in
+            let pollQuestionBuilder = self.getPollQuestionBuilderFromDict(question)
+            _ = pollBuilder.addQuestion(with: pollQuestionBuilder)
+        }
+    }
+
+    static func getPollQuestionBuilderFromDict(_ data: NSDictionary) -> HMSPollQuestionBuilder {
+        let pollQuestionBuilder = HMSPollQuestionBuilder()
+
+        // // Commented because as of now, not passing any field from JS to use `withAnswerHidden` method of `HMSPollQuestionBuilder`
+        // if let answerHidden = data["answerHidden"] as? Bool {
+        //     _ = pollQuestionBuilder.withAnswerHidden(answerHidden: answerHidden)
+        // }
+
+        if let canBeSkipped = data["skippable"] as? Bool {
+            _ = pollQuestionBuilder.withCanBeSkipped(canBeSkipped)
+        }
+
+        if let once = data["once"] as? Bool {
+            _ = pollQuestionBuilder.withCanChangeResponse(canChangeResponse: !once)
+        }
+
+        if let duration = data["duration"] as? Int {
+            _ = pollQuestionBuilder.withDuration(duration)
+        }
+
+        if let index = data["index"] as? Int {
+            _ = pollQuestionBuilder.withIndex(index)
+        }
+
+        if let maxLength = data["answerMaxLen"] as? Int {
+            _ = pollQuestionBuilder.withMaxLength(maxLength: maxLength)
+        }
+
+        if let minLength = data["answerMinLen"] as? Int {
+            _ = pollQuestionBuilder.withMinLength(minLength: minLength)
+        }
+
+        if let title = data["text"] as? String {
+            _ = pollQuestionBuilder.withTitle(title)
+        }
+
+        if let type = data["type"] as? Int {
+            if let questionType = HMSPollQuestionType.init(rawValue: type) {
+                _ = pollQuestionBuilder.withType(questionType)
+            } else {
+                print("unable to create `HMSPollQuestionType` instance from given `type` value: \(type)")
+            }
+        }
+
+        if let weight = data["weight"] as? Int {
+            _ = pollQuestionBuilder.withWeight(weight: weight)
+        }
+
+        if let options = data["options"] as? [NSDictionary] {
+            addOptionsToPollQuestionBuilder(options: options, pollQuestionBuilder: pollQuestionBuilder)
+        }
+
+        return pollQuestionBuilder
+    }
+
+    static func addOptionsToPollQuestionBuilder(options: [NSDictionary], pollQuestionBuilder: HMSPollQuestionBuilder) {
+        options.forEach { option in
+            guard let optionTitle = option["text"] as? String else {
+                print("\(#function) option title field not available!")
+                return
+            }
+
+            if let isCorrect = option["isCorrectAnswer"] as? Bool {
+                _ = pollQuestionBuilder.addQuizOption(with: optionTitle, isCorrect: isCorrect)
+            } else {
+                _ = pollQuestionBuilder.addOption(with: optionTitle)
+            }
+        }
+    }
+
+    static func getPollResponseBuilder(_ response: NSDictionary, poll: HMSPoll, pollQuestion: HMSPollQuestion) -> HMSPollResponseBuilder {
+        let pollResponseBuilder = HMSPollResponseBuilder(poll: poll)
+
+        switch pollQuestion.type {
+        case .longAnswer, .shortAnswer:
+            if let responseText = response["text"] as? String {
+                if let duration = response["duration"] as? Int {
+                    pollResponseBuilder.addResponse(for: pollQuestion, text: responseText, duration: duration)
+                } else {
+                    pollResponseBuilder.addResponse(for: pollQuestion, text: responseText)
+                }
+            }
+        case .multipleChoice, .singleChoice:
+            if let options = response["options"] as? [Int],
+               let pollQuestionOptions = pollQuestion.options {
+                let questionOptions = options.compactMap({optionIndex in pollQuestionOptions.first { pollQuestionOption in pollQuestionOption.index == optionIndex }})
+
+                if let duration = response["duration"] as? Int {
+                    pollResponseBuilder.addResponse(for: pollQuestion, options: questionOptions, duration: duration)
+                } else {
+                    pollResponseBuilder.addResponse(for: pollQuestion, options: questionOptions)
+                }
+            }
+        @unknown default:
+            print("@unknown default case: Invalid pollQuestionType")
+        }
+        return pollResponseBuilder
+    }
+}