@100mslive/react-native-hms 0.8.0 → 0.8.1

package/android/src/main/java/com/reactnativehmssdk/HmsSDK.kt

@@ -4,6 +4,7 @@ import com.facebook.react.bridge.*
 import java.util.*
 import kotlinx.coroutines.launch
 import live.hms.video.error.HMSException
+import live.hms.video.media.settings.HMSTrackSettings
 import live.hms.video.media.tracks.*
 import live.hms.video.sdk.*
 import live.hms.video.sdk.models.*
@@ -11,11 +12,11 @@ import live.hms.video.sdk.models.HMSConfig
 import live.hms.video.sdk.models.enums.HMSPeerUpdate
 import live.hms.video.sdk.models.enums.HMSRoomUpdate
 import live.hms.video.sdk.models.enums.HMSTrackUpdate
-import live.hms.video.sdk.models.role.HMSRole
 import live.hms.video.sdk.models.trackchangerequest.HMSChangeTrackStateRequest
 import live.hms.video.utils.HMSCoroutineScope
 
 class HmsSDK(
+    data: ReadableMap?,
     HmsDelegate: HmsModule,
     sdkId: String,
     reactApplicationContext: ReactApplicationContext
@@ -25,9 +26,40 @@ class HmsSDK(
   private var changeTrackStateRequest: HMSChangeTrackStateRequest? = null
   val delegate: HmsModule = HmsDelegate
   val id: String = sdkId
+  val self = this
 
   init {
-    this.hmsSDK = HMSSDK.Builder(reactApplicationContext).build()
+    val videoSettings = HmsHelper.getVideoTrackSettings(data?.getMap("video"))
+    val audioSettings = HmsHelper.getAudioTrackSettings(data?.getMap("audio"))
+
+    val trackSettingsBuilder = HMSTrackSettings.Builder()
+    val trackSettings = trackSettingsBuilder.audio(audioSettings).video(videoSettings).build()
+
+    this.hmsSDK = HMSSDK.Builder(reactApplicationContext).setTrackSettings(trackSettings).build()
+  }
+
+  fun emitRequiredKeysError() {
+    val data: WritableMap = Arguments.createMap()
+    val hmsError =
+        HMSException(
+            102,
+            "NOT_FOUND",
+            "SEND_ALL_REQUIRED_KEYS",
+            "REQUIRED_KEYS_NOT_FOUND",
+            "REQUIRED_KEYS_NOT_FOUND"
+        )
+    data.putString("event", "ON_ERROR")
+    data.putString("id", id)
+    data.putMap("error", HmsDecoder.getError(hmsError))
+    delegate.emitEvent("ON_ERROR", data)
+  }
+
+  fun emitHMSError(error: HMSException) {
+    val data: WritableMap = Arguments.createMap()
+    data.putString("event", "ON_ERROR")
+    data.putString("id", id)
+    data.putMap("error", HmsDecoder.getError(error))
+    delegate.emitEvent("ON_ERROR", data)
   }
 
   fun preview(credentials: ReadableMap) {
@@ -40,15 +72,42 @@ class HmsSDK(
       var config =
           HMSConfig(
               credentials.getString("username") as String,
-              credentials.getString("authToken") as String
+              credentials.getString("authToken") as String,
           )
 
-      if (HmsHelper.areAllRequiredKeysAvailable(credentials, arrayOf(Pair("endpoint", "String")))) {
+      if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("endpoint", "String"), Pair("metadata", "String"))
+          )
+      ) {
+        config =
+            HMSConfig(
+                credentials.getString("username") as String,
+                credentials.getString("authToken") as String,
+                initEndpoint = credentials.getString("endpoint") as String,
+                metadata = credentials.getString("metadata") as String,
+            )
+      } else if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("endpoint", "String"))
+          )
+      ) {
+        config =
+            HMSConfig(
+                credentials.getString("username") as String,
+                credentials.getString("authToken") as String,
+                initEndpoint = credentials.getString("endpoint") as String,
+            )
+      } else if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("metadata", "String"))
+          )
+      ) {
         config =
             HMSConfig(
                 credentials.getString("username") as String,
                 credentials.getString("authToken") as String,
-                initEndpoint = credentials.getString("endpoint") as String
+                metadata = credentials.getString("metadata") as String,
             )
       }
 
@@ -56,7 +115,7 @@ class HmsSDK(
           config,
           object : HMSPreviewListener {
             override fun onError(error: HMSException) {
-              delegate.emitEvent("ON_ERROR", HmsDecoder.getError(error))
+              self.emitHMSError(error)
             }
 
             override fun onPreview(room: HMSRoom, localTracks: Array<HMSTrack>) {
@@ -74,18 +133,7 @@ class HmsSDK(
           }
       )
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
@@ -102,12 +150,39 @@ class HmsSDK(
               credentials.getString("authToken") as String
           )
 
-      if (HmsHelper.areAllRequiredKeysAvailable(credentials, arrayOf(Pair("endpoint", "String")))) {
+      if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("endpoint", "String"), Pair("metadata", "String"))
+          )
+      ) {
+        config =
+            HMSConfig(
+                credentials.getString("username") as String,
+                credentials.getString("authToken") as String,
+                initEndpoint = credentials.getString("endpoint") as String,
+                metadata = credentials.getString("metadata") as String,
+            )
+      } else if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("endpoint", "String"))
+          )
+      ) {
+        config =
+            HMSConfig(
+                credentials.getString("username") as String,
+                credentials.getString("authToken") as String,
+                initEndpoint = credentials.getString("endpoint") as String,
+            )
+      } else if (HmsHelper.areAllRequiredKeysAvailable(
+              credentials,
+              arrayOf(Pair("metadata", "String"))
+          )
+      ) {
         config =
             HMSConfig(
                 credentials.getString("username") as String,
                 credentials.getString("authToken") as String,
-                initEndpoint = credentials.getString("endpoint") as String
+                metadata = credentials.getString("metadata") as String,
             )
       }
 
@@ -130,7 +205,8 @@ class HmsSDK(
                   super.onRemovedFromRoom(notification)
 
                   val data: WritableMap = Arguments.createMap()
-                  val requestedBy = HmsDecoder.getHmsRemotePeer(notification.peerWhoRemoved as HMSRemotePeer?)
+                  val requestedBy =
+                      HmsDecoder.getHmsRemotePeer(notification.peerWhoRemoved as HMSRemotePeer?)
                   val roomEnded = notification.roomWasEnded
                   val reason = notification.reason
 
@@ -143,7 +219,7 @@ class HmsSDK(
                 }
 
                 override fun onError(error: HMSException) {
-                  delegate.emitEvent("ON_ERROR", HmsDecoder.getError(error))
+                  self.emitHMSError(error)
                 }
 
                 override fun onJoin(room: HMSRoom) {
@@ -163,7 +239,6 @@ class HmsSDK(
                 }
 
                 override fun onPeerUpdate(type: HMSPeerUpdate, hmsPeer: HMSPeer) {
-
                   val type = type.name
                   val roomData = HmsDecoder.getHmsRoom(hmsSDK?.getRoom())
                   val localPeerData = HmsDecoder.getHmsLocalPeer(hmsSDK?.getLocalPeer())
@@ -246,11 +321,7 @@ class HmsSDK(
               }
           )
         } catch (e: HMSException) {
-          val error: WritableMap = Arguments.createMap()
-          error.putString("message", e.localizedMessage)
-          error.putInt("code", e.code)
-          error.putString("id", id)
-          delegate.emitEvent("ON_ERROR", error)
+          self.emitHMSError(e)
         }
 
         hmsSDK?.addAudioObserver(
@@ -276,24 +347,26 @@ class HmsSDK(
         )
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
   fun setLocalMute(data: ReadableMap) {
     val isMute = data.getBoolean("isMute")
     hmsSDK?.getLocalPeer()?.audioTrack?.setMute(isMute)
+    val type = if (isMute) "TRACK_MUTED" else "TRACK_UNMUTED"
+    val localPeerData = HmsDecoder.getHmsLocalPeer(hmsSDK?.getLocalPeer())
+    val remotePeerData = HmsDecoder.getHmsRemotePeers(hmsSDK?.getRemotePeers())
+    val roomData = HmsDecoder.getHmsRoom(hmsSDK?.getRoom())
+
+    val data: WritableMap = Arguments.createMap()
+
+    data.putMap("room", roomData)
+    data.putString("type", type)
+    data.putMap("localPeer", localPeerData)
+    data.putArray("remotePeers", remotePeerData)
+    data.putString("id", id)
+    delegate.emitEvent("ON_TRACK_UPDATE", data)
   }
 
   fun setLocalVideoMute(data: ReadableMap) {
@@ -308,15 +381,18 @@ class HmsSDK(
   }
 
   fun leave(callback: Promise?) {
-    hmsSDK?.leave(object : HMSActionResultListener {
-      override fun onSuccess() {
-        callback?.resolve("")
-      }
+    hmsSDK?.leave(
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            callback?.resolve("")
+          }
 
-      override fun onError(error: HMSException) {
-        callback?.reject("101", "NOT_FOUND")
-      }
-    })
+          override fun onError(error: HMSException) {
+            callback?.reject("101", "NOT_FOUND")
+            self.emitHMSError(error)
+          }
+        }
+    )
   }
 
   fun sendBroadcastMessage(data: ReadableMap) {
@@ -331,23 +407,14 @@ class HmsSDK(
           data.getString("message") as String,
           type as String,
           object : HMSMessageResultListener {
-            override fun onError(error: HMSException) {}
+            override fun onError(error: HMSException) {
+              self.emitHMSError(error)
+            }
             override fun onSuccess(hmsMessage: HMSMessage) {}
           }
       )
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
@@ -373,24 +440,15 @@ class HmsSDK(
             type as String,
             encodedTargetedRoles,
             object : HMSMessageResultListener {
-              override fun onError(error: HMSException) {}
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+              }
               override fun onSuccess(hmsMessage: HMSMessage) {}
             }
         )
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
@@ -415,24 +473,15 @@ class HmsSDK(
             type as String,
             peer,
             object : HMSMessageResultListener {
-              override fun onError(error: HMSException) {}
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+              }
               override fun onSuccess(hmsMessage: HMSMessage) {}
             }
         )
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
@@ -458,24 +507,15 @@ class HmsSDK(
               force,
               object : HMSActionResultListener {
                 override fun onSuccess() {}
-                override fun onError(error: HMSException) {}
+                override fun onError(error: HMSException) {
+                  self.emitHMSError(error)
+                }
               }
           )
         }
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
@@ -496,56 +536,51 @@ class HmsSDK(
             mute,
             object : HMSActionResultListener {
               override fun onSuccess() {}
-              override fun onError(error: HMSException) {}
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+              }
             }
         )
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      self.emitRequiredKeysError()
     }
   }
 
   fun changeTrackStateRoles(data: ReadableMap) {
     val requiredKeys =
-      HmsHelper.areAllRequiredKeysAvailable(
-        data,
-        arrayOf(Pair("source", "String"), Pair("mute", "Boolean"), Pair("type", "String"), Pair("roles", "Array"))
-      )
+        HmsHelper.areAllRequiredKeysAvailable(
+            data,
+            arrayOf(
+                Pair("source", "String"),
+                Pair("mute", "Boolean"),
+                Pair("type", "String"),
+                Pair("roles", "Array")
+            )
+        )
     if (requiredKeys) {
       val mute: Boolean = data.getBoolean("mute")
-      val type = if(data.getString("type") == HMSTrackType.AUDIO.toString()) HMSTrackType.AUDIO else HMSTrackType.VIDEO
+      val type =
+          if (data.getString("type") == HMSTrackType.AUDIO.toString()) HMSTrackType.AUDIO
+          else HMSTrackType.VIDEO
       val source = data.getString("source")
       val targetedRoles = data.getArray("roles")?.toArrayList() as? ArrayList<String>
       val roles = hmsSDK?.getRoles()
       val encodedTargetedRoles = HmsHelper.getRolesFromRoleNames(targetedRoles, roles)
-        hmsSDK?.changeTrackState(mute, type, source, encodedTargetedRoles, object : HMSActionResultListener {
-          override fun onSuccess() {}
-          override fun onError(error: HMSException) {}
-        })
-    }else {
-      delegate.emitEvent(
-        "ON_ERROR",
-        HmsDecoder.getError(
-          HMSException(
-            102,
-            "NOT_FOUND",
-            "SEND_ALL_REQUIRED_KEYS",
-            "REQUIRED_KEYS_NOT_FOUND",
-            "REQUIRED_KEYS_NOT_FOUND"
-          )
-        )
+      hmsSDK?.changeTrackState(
+          mute,
+          type,
+          source,
+          encodedTargetedRoles,
+          object : HMSActionResultListener {
+            override fun onSuccess() {}
+            override fun onError(error: HMSException) {
+              self.emitHMSError(error)
+            }
+          }
       )
+    } else {
+      self.emitRequiredKeysError()
     }
   }
 
@@ -575,27 +610,34 @@ class HmsSDK(
   }
 
   fun removePeer(data: ReadableMap) {
-    val peerId = data.getString("peerId")
-    var reason = data.getString("reason")
-
-    if (reason == null) {
-      reason = ""
-    }
+    val requiredKeys =
+        HmsHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("peerId", "String")))
+    if (requiredKeys) {
+      val peerId = data.getString("peerId")
+      var reason = data.getString("reason")
 
-    val peers = hmsSDK?.getRemotePeers()
+      if (reason == null) {
+        reason = ""
+      }
 
-    val peer = HmsHelper.getRemotePeerFromPeerId(peerId, peers)
+      val peers = hmsSDK?.getRemotePeers()
 
-    if (peer != null) {
-      hmsSDK?.removePeerRequest(
-          peer,
-          reason,
-          object : HMSActionResultListener {
-            override fun onSuccess() {}
+      val peer = HmsHelper.getRemotePeerFromPeerId(peerId, peers)
 
-            override fun onError(error: HMSException) {}
-          }
-      )
+      if (peer != null) {
+        hmsSDK?.removePeerRequest(
+            peer,
+            reason,
+            object : HMSActionResultListener {
+              override fun onSuccess() {}
+              override fun onError(error: HMSException) {
+                self.emitHMSError(error)
+              }
+            }
+        )
+      }
+    } else {
+      self.emitRequiredKeysError()
     }
   }
 
@@ -611,8 +653,9 @@ class HmsSDK(
         lock,
         object : HMSActionResultListener {
           override fun onSuccess() {}
-
-          override fun onError(error: HMSException) {}
+          override fun onError(error: HMSException) {
+            self.emitHMSError(error)
+          }
         }
     )
   }
@@ -628,6 +671,7 @@ class HmsSDK(
 
             override fun onError(error: HMSException) {
               recentRoleChangeRequest = null
+              self.emitHMSError(error)
             }
           }
       )
@@ -635,11 +679,7 @@ class HmsSDK(
   }
 
   fun muteAllPeersAudio(data: ReadableMap) {
-    val requiredKeys =
-      HmsHelper.areAllRequiredKeysAvailable(
-        data,
-        arrayOf(Pair("mute", "Boolean"))
-      )
+    val requiredKeys = HmsHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("mute", "Boolean")))
     if (requiredKeys) {
       val mute = data.getBoolean("mute")
       val peers = hmsSDK?.getRemotePeers()
@@ -661,19 +701,8 @@ class HmsSDK(
         data.putString("id", id)
         delegate.emitEvent("ON_PEER_UPDATE", data)
       }
-    }else {
-      delegate.emitEvent(
-        "ON_ERROR",
-        HmsDecoder.getError(
-          HMSException(
-            102,
-            "NOT_FOUND",
-            "SEND_ALL_REQUIRED_KEYS",
-            "REQUIRED_KEYS_NOT_FOUND",
-            "REQUIRED_KEYS_NOT_FOUND"
-          )
-        )
-      )
+    } else {
+      this.emitRequiredKeysError()
     }
   }
 
@@ -695,18 +724,7 @@ class HmsSDK(
         remoteVideoTrack.isPlaybackAllowed = playbackAllowed
       }
     } else {
-      delegate.emitEvent(
-          "ON_ERROR",
-          HmsDecoder.getError(
-              HMSException(
-                  102,
-                  "NOT_FOUND",
-                  "SEND_ALL_REQUIRED_KEYS",
-                  "REQUIRED_KEYS_NOT_FOUND",
-                  "REQUIRED_KEYS_NOT_FOUND"
-              )
-          )
-      )
+      this.emitRequiredKeysError()
     }
   }
 
@@ -737,4 +755,145 @@ class HmsSDK(
 
     callback?.resolve(roomData)
   }
+
+  fun setVolume(data: ReadableMap) {
+    val requiredKeys =
+        HmsHelper.areAllRequiredKeysAvailable(
+            data,
+            arrayOf(Pair("trackId", "String"), Pair("volume", "Float"))
+        )
+
+    if (requiredKeys) {
+      val trackId = data.getString("trackId")
+      val volume = data.getDouble("volume")
+
+      val remotePeers = hmsSDK?.getRemotePeers()
+
+      if (remotePeers != null) {
+        for (peer in remotePeers) {
+          val audioTrackId = peer.audioTrack?.trackId
+
+          if (audioTrackId == trackId) {
+            peer.audioTrack?.setVolume(volume)
+            return
+          }
+
+          for (auxTrack in peer.auxiliaryTracks) {
+            if (auxTrack.trackId == trackId && auxTrack.type == HMSTrackType.AUDIO) {
+              val trackExtracted = auxTrack as? HMSRemoteAudioTrack
+
+              if (trackExtracted != null) {
+                trackExtracted.setVolume(volume)
+                return
+              }
+            }
+          }
+        }
+      }
+    } else {
+      this.emitRequiredKeysError()
+    }
+  }
+
+  fun getVolume(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+        HmsHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("trackId", "String")))
+
+    if (requiredKeys) {
+      val trackId = data.getString("trackId")
+
+      val localPeer = hmsSDK?.getLocalPeer()
+
+      if (localPeer?.audioTrack?.trackId == trackId) {
+        val volume = localPeer?.audioTrack?.volume
+        callback?.resolve(volume)
+        return
+      }
+      callback?.reject("101", "TRACK_IDS_DO_NOT_MATCH")
+    } else {
+      callback?.reject("101", "TRACK_NOT_FOUND")
+    }
+  }
+
+  fun changeMetadata(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+        HmsHelper.areAllRequiredKeysAvailable(data, arrayOf(Pair("metadata", "String")))
+
+    if (requiredKeys) {
+      val metadata = data.getString("metadata")
+
+      if (metadata != null) {
+        hmsSDK?.changeMetadata(
+            metadata,
+            object : HMSActionResultListener {
+              override fun onSuccess() {
+                val result: WritableMap = Arguments.createMap()
+
+                result.putBoolean("success", true)
+
+                callback?.resolve(result)
+              }
+              override fun onError(error: HMSException) {
+                callback?.reject(error.message, error.description)
+                self.emitHMSError(error)
+              }
+            }
+        )
+      }
+    } else {
+      self.emitRequiredKeysError()
+    }
+  }
+
+  fun startRTMPOrRecording(data: ReadableMap, callback: Promise?) {
+    val requiredKeys =
+        HmsHelper.areAllRequiredKeysAvailable(
+            data,
+            arrayOf(Pair("record", "Boolean"), Pair("meetingURL", "String"))
+        )
+    if (requiredKeys) {
+      val record = data.getBoolean("record")
+      var meetingURL = data.getString("meetingURL") as String
+      var rtmpURLs = data.getArray("rtmpURLs")
+      if (rtmpURLs == null) {
+        rtmpURLs = Arguments.createArray()
+      }
+      val rtmpURLsList = HmsHelper.getRtmpUrls(rtmpURLs)
+      val config = HMSRecordingConfig(meetingURL, rtmpURLsList, record)
+
+      hmsSDK?.startRtmpOrRecording(
+          config,
+          object : HMSActionResultListener {
+            override fun onSuccess() {
+              val result: WritableMap = Arguments.createMap()
+              result.putBoolean("success", true)
+              callback?.resolve(result)
+            }
+            override fun onError(error: HMSException) {
+              callback?.reject(error.message, error.description)
+              self.emitHMSError(error)
+            }
+          }
+      )
+    } else {
+      callback?.reject("101", "REQUIRED_KEYS_NOT_FOUND")
+      self.emitRequiredKeysError()
+    }
+  }
+
+  fun stopRtmpAndRecording(callback: Promise?) {
+    hmsSDK?.stopRtmpAndRecording(
+        object : HMSActionResultListener {
+          override fun onSuccess() {
+            val result: WritableMap = Arguments.createMap()
+            result.putBoolean("success", true)
+            callback?.resolve(result)
+          }
+          override fun onError(error: HMSException) {
+            callback?.reject(error.message, error.description)
+            self.emitHMSError(error)
+          }
+        }
+    )
+  }
 }