@zelloptt/react-native-zello-sdk 0.1.0

package/android/src/main/java/com/zellosdk/ZelloAndroidSdkModuleHelper.kt

@@ -0,0 +1,198 @@
+package com.zellosdk
+
+import android.graphics.Bitmap
+import android.util.Base64
+import com.facebook.react.bridge.Arguments
+import com.facebook.react.bridge.WritableMap
+import com.facebook.react.bridge.WritableNativeArray
+import com.facebook.react.bridge.WritableNativeMap
+import com.zello.sdk.ZelloChannel
+import com.zello.sdk.ZelloContact
+import com.zello.sdk.ZelloHistoryAlertMessage
+import com.zello.sdk.ZelloHistoryImageMessage
+import com.zello.sdk.ZelloHistoryLocationMessage
+import com.zello.sdk.ZelloHistoryMessage
+import com.zello.sdk.ZelloHistoryTextMessage
+import com.zello.sdk.ZelloHistoryVoiceMessage
+import com.zello.sdk.ZelloIncomingEmergency
+import com.zello.sdk.ZelloRecentEntry
+import com.zello.sdk.ZelloUser
+import java.io.ByteArrayOutputStream
+
+object ZelloAndroidSdkModuleHelper {
+	fun contactListToWritableMap(users: List<ZelloUser>, channels: List<ZelloChannel>): WritableMap {
+		return Arguments.createMap().apply {
+			putArray("users", WritableNativeArray().apply {
+				users.forEach { user ->
+					pushMap(sdkContactToWritableMap(user))
+				}
+			})
+			putArray("channels", WritableNativeArray().apply {
+				channels.forEach { channel ->
+					pushMap(sdkContactToWritableMap(channel))
+				}
+			})
+		}
+	}
+
+	fun sdkContactToWritableMap(contact: ZelloContact): WritableMap {
+		return when (contact) {
+			is ZelloUser -> WritableNativeMap().apply {
+				putString("name", contact.name)
+				putBoolean("isChannel", false)
+				putBoolean("isMuted", contact.isMuted)
+				putString("displayName", contact.displayName)
+				putString("status", contact.status.toString())
+				putString("customStatusText", contact.customStatusText)
+				putString("profilePictureUrl", contact.profilePictureUrl)
+				putString("profilePictureThumbnailUrl", contact.profilePictureThumbnailUrl)
+			}
+
+			is ZelloChannel -> WritableNativeMap().apply {
+				putString("name", contact.name)
+				putBoolean("isChannel", true)
+				putBoolean("isMuted", contact.isMuted)
+				putBoolean("isConnected", contact.status == ZelloChannel.ConnectionStatus.CONNECTED)
+				putBoolean("isConnecting", contact.status == ZelloChannel.ConnectionStatus.CONNECTING)
+				putInt("usersOnline", contact.usersOnline)
+				putMap("options", WritableNativeMap().apply {
+					val options = contact.options
+					putBoolean("noDisconnect", options.noDisconnect)
+					putBoolean("hidePowerButton", options.hidePowerButton)
+					putBoolean("listenOnly", options.listenOnly)
+					putBoolean("allowAlerts", options.allowAlerts)
+					putBoolean("allowTextMessages", options.allowTextMessages)
+					putBoolean("allowLocations", options.allowLocations)
+				})
+			}
+
+			else -> WritableNativeMap()
+		}
+	}
+
+	fun incomingEmergenciesToWritableArray(incomingEmergencies: List<ZelloIncomingEmergency>): WritableNativeArray {
+		return WritableNativeArray().apply {
+			incomingEmergencies.forEach {
+				pushMap(incomingEmergencyToWritableMap(it))
+			}
+		}
+	}
+
+	fun incomingEmergencyToWritableMap(incomingEmergency: ZelloIncomingEmergency): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("channel", sdkContactToWritableMap(contact = incomingEmergency.channel))
+			putString("channelUserName", incomingEmergency.channelUser.name)
+			putString("emergencyId", incomingEmergency.emergencyId)
+			putString("startTimestamp", incomingEmergency.startTimestamp.toString())
+			incomingEmergency.endTimestamp?.let {
+				putString("endTimestamp", it.toString())
+			}
+		}
+	}
+
+	fun bitmapToBase64String(bitmap: Bitmap?): String? {
+		if (bitmap == null) {
+			return null
+		}
+		val byteArrayOutputStream = ByteArrayOutputStream()
+		bitmap.compress(Bitmap.CompressFormat.PNG, 100, byteArrayOutputStream)
+		val byteArray = byteArrayOutputStream.toByteArray()
+		val base64String: String = Base64.encodeToString(byteArray, Base64.DEFAULT)
+		return "data:image/jpeg;base64,$base64String"
+	}
+
+	fun recentsToWritableArray(recents: List<ZelloRecentEntry>): WritableNativeArray {
+		return WritableNativeArray().apply {
+			recents.forEach {
+				pushMap(WritableNativeMap().apply {
+					putMap("contact", sdkContactToWritableMap(it.contact))
+					putString("channelUserName", it.channelUser?.name)
+					putString("type", it.type.toString())
+					putString("timestamp", it.timestamp.toString())
+					putBoolean("incoming", it.incoming)
+				})
+			}
+		}
+	}
+
+	fun historyMessagesToWritableArray(messages: List<ZelloHistoryMessage>): WritableNativeArray {
+		return WritableNativeArray().apply {
+			messages.forEach {
+				pushMap(historyMessageToWritableMap(it))
+			}
+		}
+	}
+
+	fun historyMessageToWritableMap(message: ZelloHistoryMessage): WritableMap {
+		return when (message) {
+			is ZelloHistoryVoiceMessage -> historyVoiceMessageToWritableMap(message)
+			is ZelloHistoryImageMessage -> historyImageMessageToWritableMap(message)
+			is ZelloHistoryTextMessage -> historyTextMessageToWritableMap(message)
+			is ZelloHistoryAlertMessage -> historyAlertMessageToWritableMap(message)
+			is ZelloHistoryLocationMessage -> historyLocationMessageToWritableMap(message)
+			else -> WritableNativeMap()
+		}
+	}
+
+	fun historyVoiceMessageToWritableMap(message: ZelloHistoryVoiceMessage): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("contact", sdkContactToWritableMap(contact = message.contact))
+			putString("type", "voice")
+			putString("channelUserName", message.channelUser?.name)
+			putString("timestamp", message.timestamp.toString())
+			putString("historyId", message.historyId)
+			putBoolean("incoming", message.incoming)
+			putInt("durationMs", message.durationMs.toInt())
+		}
+	}
+
+	fun historyImageMessageToWritableMap(message: ZelloHistoryImageMessage): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("contact", sdkContactToWritableMap(contact = message.contact))
+			putString("type", "image")
+			putString("channelUserName", message.channelUser?.name)
+			putString("timestamp", message.timestamp.toString())
+			putString("historyId", message.historyId)
+			putBoolean("incoming", message.incoming)
+		}
+	}
+
+	fun historyTextMessageToWritableMap(message: ZelloHistoryTextMessage): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("contact", sdkContactToWritableMap(contact = message.contact))
+			putString("type", "text")
+			putString("channelUserName", message.channelUser?.name)
+			putString("timestamp", message.timestamp.toString())
+			putString("historyId", message.historyId)
+			putBoolean("incoming", message.incoming)
+			putString("text", message.text)
+		}
+	}
+
+	fun historyAlertMessageToWritableMap(message: ZelloHistoryAlertMessage): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("contact", sdkContactToWritableMap(contact = message.contact))
+			putString("type", "alert")
+			putString("channelUserName", message.channelUser?.name)
+			putString("timestamp", message.timestamp.toString())
+			putString("historyId", message.historyId)
+			putBoolean("incoming", message.incoming)
+			putString("text", message.text)
+		}
+	}
+
+	fun historyLocationMessageToWritableMap(message: ZelloHistoryLocationMessage): WritableMap {
+		return Arguments.createMap().apply {
+			putMap("contact", sdkContactToWritableMap(contact = message.contact))
+			putString("type", "location")
+			putString("channelUserName", message.channelUser?.name)
+			putString("timestamp", message.timestamp.toString())
+			putString("historyId", message.historyId)
+			putBoolean("incoming", message.incoming)
+			putDouble("latitude", message.latitude)
+			putDouble("longitude", message.longitude)
+			putDouble("accuracy", message.accuracy)
+			putString("address", message.address)
+		}
+	}
+}

package/ios/Extensions/Date+Extension.swift

@@ -0,0 +1,5 @@
+extension Date {
+  var bridgeTimestamp: String {
+    String(timeIntervalSince1970 * 1000)
+  }
+}

package/ios/Extensions/UIImage+Extension.swift

@@ -0,0 +1,9 @@
+extension UIImage {
+  var base64String: String? {
+    guard let string = self.jpegData(compressionQuality: 1.0)?
+      .base64EncodedString(options: .lineLength64Characters) else {
+      return nil
+    }
+    return "data:image/jpeg;base64," + string
+  }
+}

package/ios/Extensions/ZelloContact+Extension.swift

@@ -0,0 +1,52 @@
+import ZelloSDK
+
+extension ZelloContact {
+  var jsonDictionary: [AnyHashable: Any] {
+    if let user = self.asZelloUser() {
+      return user.jsonDictionary
+    } else if let channel = self.asZelloChannel() {
+      return channel.jsonDictionary
+    }
+    return [:]
+  }
+}
+
+extension ZelloChannel {
+  var jsonDictionary: [AnyHashable: Any] {
+    return [
+      "name": name,
+      "isChannel": true,
+      "isMuted": isMuted,
+      "isConnected": status == .connected,
+      "isConnecting": status == .connecting,
+      "usersOnline": usersOnline,
+      "options": [
+        "noDisconnect": channelOptions.noDisconnect,
+        "hidePowerButton": channelOptions.hidePowerButton,
+        "listenOnly": channelOptions.listenOnly,
+        "allowAlerts": channelOptions.allowAlerts,
+        "allowTextMessages": channelOptions.allowTextMessages,
+        "allowLocations": channelOptions.allowLocations
+      ]
+    ]
+  }
+}
+
+extension ZelloUser {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "name": name,
+      "isChannel": false,
+      "isMuted": isMuted,
+      "displayName": displayName,
+      "status": status.rawValue.lowercased()
+    ]
+    if let url = profilePictureURL?.absoluteString {
+      body["profilePictureUrl"] = url
+    }
+    if let url = profilePictureThumbnailURL?.absoluteString {
+      body["profilePictureThumbnailUrl"] = url
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloHistoryAlertMessage+Extension.swift

@@ -0,0 +1,18 @@
+import ZelloSDK
+
+extension ZelloHistoryAlertMessage {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "contact": contact.jsonDictionary,
+      "type": "alert",
+      "historyId": historyId,
+      "timestamp": timestamp.bridgeTimestamp,
+      "incoming": incoming,
+      "text": text
+    ]
+    if let channelUserName = channelUser?.name {
+      body["channelUserName"] = channelUserName
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloHistoryImageMessage+Extension.swift

@@ -0,0 +1,17 @@
+import ZelloSDK
+
+extension ZelloHistoryImageMessage {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "contact": contact.jsonDictionary,
+      "type": "image",
+      "historyId": historyId,
+      "timestamp": timestamp.bridgeTimestamp,
+      "incoming": incoming
+    ]
+    if let channelUserName = channelUser?.name {
+      body["channelUserName"] = channelUserName
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloHistoryLocationMessage+Extension.swift

@@ -0,0 +1,23 @@
+import ZelloSDK
+
+extension ZelloHistoryLocationMessage {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "contact": contact.jsonDictionary,
+      "type": "location",
+      "historyId": historyId,
+      "timestamp": timestamp.bridgeTimestamp,
+      "incoming": incoming,
+      "latitude": location.coordinate.latitude,
+      "longitude": location.coordinate.longitude,
+      "accuracy": location.horizontalAccuracy
+    ]
+    if let address = address {
+      body["address"] = address
+    }
+    if let channelUserName = channelUser?.name {
+      body["channelUserName"] = channelUserName
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloHistoryTextMessage+Extension.swift

@@ -0,0 +1,18 @@
+import ZelloSDK
+
+extension ZelloHistoryTextMessage {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "contact": contact.jsonDictionary,
+      "type": "text",
+      "historyId": historyId,
+      "timestamp": timestamp.bridgeTimestamp,
+      "incoming": incoming,
+      "text": text
+    ]
+    if let channelUserName = channelUser?.name {
+      body["channelUserName"] = channelUserName
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloHistoryVoiceMessage+Extension.swift

@@ -0,0 +1,18 @@
+import ZelloSDK
+
+extension ZelloHistoryVoiceMessage {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "contact": contact.jsonDictionary,
+      "type": "voice",
+      "historyId": historyId,
+      "timestamp": timestamp.bridgeTimestamp,
+      "incoming": incoming,
+      "durationMs": duration * 1000
+    ]
+    if let channelUserName = channelUser?.name {
+      body["channelUserName"] = channelUserName
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloIOSSdkModule+Extension.swift

@@ -0,0 +1,285 @@
+import ZelloSDK
+
+extension ZelloIOSSdkModule: Zello.Delegate {
+  func zelloDidStartConnecting(_ zello: Zello) {
+    sendSdkEvent(withName: "onConnectStarted", body: nil)
+  }
+
+  func zelloDidFinishConnecting(_ zello: Zello) {
+    sendSdkEvent(withName: "onConnectSucceeded", body: nil)
+  }
+
+  func zelloDidDisconnect(_ zello: Zello) {
+    sendSdkEvent(withName: "onDisconnected", body: nil)
+  }
+
+  func zelloWillReconnect(_ zello: Zello) {
+    sendSdkEvent(withName: "onWillReconnect", body: nil)
+  }
+
+  func zelloDidUpdateContactList(_ zello: Zello) {
+    let users = zello.users.map { ZelloContact.user($0).jsonDictionary }
+    let channels = zello.channels.map { ZelloContact.channel($0).jsonDictionary }
+    var body: [AnyHashable: Any] = [
+      "users": users,
+      "channels": channels
+    ]
+    if let emergencyChannel = zello.emergencyChannel {
+      body["emergencyChannel"] = emergencyChannel.jsonDictionary
+    }
+    sendSdkEvent(withName: "onContactListUpdated", body: body)
+  }
+
+  func zello(_ zello: Zello, accountStatusChangedTo newStatus: ZelloAccountStatus?) {
+    if let newStatus = newStatus?.rawValue.lowercased() {
+      sendSdkEvent(withName: "onAccountStatusChanged", body: ["status": newStatus])
+    }
+  }
+
+  func zello(_ zello: Zello, didFailToConnect error: Zello.ConnectionError) {
+    sendSdkEvent(withName: "onConnectFailed", body: ["error": error.rawValue])
+  }
+
+  func zello(_ zello: Zello, didUpdateSelectedContact contact: ZelloContact) {
+    sendSdkEvent(withName: "onSelectedContactChanged", body: ["contact": contact.jsonDictionary])
+  }
+
+  func zello(_ zello: Zello, didStartConnecting outgoingVoiceMessage: ZelloOutgoingVoiceMessage) {
+    sendSdkEvent(withName: "onOutgoingVoiceMessageConnecting",
+                 body: [
+                  "contact": outgoingVoiceMessage.contact.jsonDictionary,
+                  "state": outgoingVoiceMessage.state,
+                  "timestamp": outgoingVoiceMessage.timestamp.bridgeTimestamp
+                 ])
+  }
+
+  func zello(_ zello: Zello, didStartSending outgoingVoiceMessage: ZelloOutgoingVoiceMessage) {
+    sendSdkEvent(withName: "onOutgoingVoiceMessageStarted",
+                 body: [
+                  "contact": outgoingVoiceMessage.contact.jsonDictionary,
+                  "state": outgoingVoiceMessage.state,
+                  "timestamp": outgoingVoiceMessage.timestamp.bridgeTimestamp
+                 ])
+  }
+
+  func zello(_ zello: Zello, didFinishSending outgoingVoiceMessage: ZelloOutgoingVoiceMessage, error: ZelloOutgoingVoiceMessage.Error?) {
+    var body: [AnyHashable: Any] = [
+      "contact": outgoingVoiceMessage.contact.jsonDictionary,
+      "state": outgoingVoiceMessage.state,
+      "timestamp": outgoingVoiceMessage.timestamp.bridgeTimestamp
+     ]
+    if let error {
+      body["error"] = error.rawValue
+    }
+    sendSdkEvent(withName: "onOutgoingVoiceMessageStopped", body: body)
+  }
+
+  func zello(_ zello: Zello, didStartReceiving incomingVoiceMessage: ZelloIncomingVoiceMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": incomingVoiceMessage.contact.jsonDictionary,
+      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp
+    ]
+    if let channelUser = incomingVoiceMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+    sendSdkEvent(withName: "onIncomingVoiceMessageStarted", body: body)
+  }
+
+  func zello(_ zello: Zello, didFinishReceiving incomingVoiceMessage: ZelloIncomingVoiceMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": incomingVoiceMessage.contact.jsonDictionary,
+      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp
+    ]
+    if let channelUser = incomingVoiceMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+    sendSdkEvent(withName: "onIncomingVoiceMessageStopped", body: body)
+  }
+
+  func zello(_ zello: Zello, didReceive textMessage: ZelloTextMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": textMessage.contact.jsonDictionary,
+      "text": textMessage.text,
+      "timestamp": textMessage.timestamp.bridgeTimestamp
+    ]
+    if let channelUser = textMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+    sendSdkEvent(withName: "onIncomingTextMessage", body: body)
+  }
+
+  func zello(_ zello: Zello, didSend textMessage: ZelloTextMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": textMessage.contact.jsonDictionary,
+      "text": textMessage.text,
+      "timestamp": textMessage.timestamp.bridgeTimestamp
+    ]
+    sendSdkEvent(withName: "onOutgoingTextMessageSent", body: body)
+  }
+
+  func zello(_ zello: Zello, didFailToSend textMessage: ZelloTextMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": textMessage.contact.jsonDictionary,
+      "text": textMessage.text,
+      "timestamp": textMessage.timestamp.bridgeTimestamp
+    ]
+    sendSdkEvent(withName: "onOutgoingTextMessageSendFailed", body: body)
+  }
+
+  func zello(_ zello: Zello, didReceive imageMessage: ZelloImageMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": imageMessage.contact.jsonDictionary,
+      "timestamp": imageMessage.timestamp.bridgeTimestamp
+    ]
+
+    if let channelUser = imageMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+
+    body["image"] = imageMessage.image.base64String
+    body["thumbnail"] = imageMessage.thumbnail.base64String
+
+    sendSdkEvent(withName: "onIncomingImageMessage", body: body)
+  }
+
+  func zello(_ zello: Zello, didSend imageMessage: ZelloImageMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": imageMessage.contact.jsonDictionary,
+      "timestamp": imageMessage.timestamp.bridgeTimestamp
+    ]
+
+    body["image"] = imageMessage.image.base64String
+    body["thumbnail"] = imageMessage.thumbnail.base64String
+
+    sendSdkEvent(withName: "onOutgoingImageMessageSent", body: body)
+  }
+
+  func zello(_ zello: Zello, didFailToSend imageMessage: ZelloImageMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": imageMessage.contact.jsonDictionary,
+      "timestamp": imageMessage.timestamp.bridgeTimestamp
+    ]
+    sendSdkEvent(withName: "onOutgoingImageMessageSendFailed", body: body)
+  }
+
+  func zello(_ zello: Zello, didReceive locationMessage: ZelloLocationMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": locationMessage.contact.jsonDictionary,
+      "timestamp": locationMessage.timestamp.bridgeTimestamp,
+      "latitude": locationMessage.location.coordinate.latitude,
+      "longitude": locationMessage.location.coordinate.longitude,
+      "accuracy": locationMessage.location.horizontalAccuracy,
+    ]
+    if let channelUser = locationMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+    if let address = locationMessage.address {
+      body["address"] = address
+    }
+    sendSdkEvent(withName: "onIncomingLocationMessage", body: body)
+  }
+
+  func zello(_ zello: Zello, didReceive alertMessage: ZelloAlertMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": alertMessage.contact.jsonDictionary,
+      "text": alertMessage.text,
+      "timestamp": alertMessage.timestamp.bridgeTimestamp
+    ]
+    if let channelUser = alertMessage.channelUser {
+      body["channelUserName"] = channelUser.name
+    }
+    sendSdkEvent(withName: "onIncomingAlertMessage", body: body)
+  }
+
+  func zello(_ zello: Zello, didSend locationMessage: ZelloLocationMessage) {
+    var body: [AnyHashable: Any] = [
+      "contact": locationMessage.contact.jsonDictionary,
+      "timestamp": locationMessage.timestamp.bridgeTimestamp,
+      "latitude": locationMessage.location.coordinate.latitude,
+      "longitude": locationMessage.location.coordinate.longitude,
+      "accuracy": locationMessage.location.horizontalAccuracy,
+    ]
+    if let address = locationMessage.address {
+      body["address"] = address
+    }
+    sendSdkEvent(withName: "onOutgoingLocationMessageSent", body: body)
+  }
+
+  func zello(_ zello: Zello, didFailToSend locationMessage: ZelloLocationMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": locationMessage.contact.jsonDictionary,
+      "timestamp": locationMessage.timestamp.bridgeTimestamp,
+      "latitude": locationMessage.location.coordinate.latitude,
+      "longitude": locationMessage.location.coordinate.longitude,
+      "accuracy": locationMessage.location.horizontalAccuracy,
+    ]
+    sendSdkEvent(withName: "onOutgoingLocationMessageSendFailed", body: body)
+  }
+
+  func zello(_ zello: Zello, didSend alertMessage: ZelloAlertMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": alertMessage.contact.jsonDictionary,
+      "text": alertMessage.text,
+      "timestamp": alertMessage.timestamp.bridgeTimestamp
+    ]
+    sendSdkEvent(withName: "onOutgoingAlertMessageSent", body: body)
+  }
+
+  func zello(_ zello: Zello, didFailToSend alertMessage: ZelloAlertMessage) {
+    let body: [AnyHashable: Any] = [
+      "contact": alertMessage.contact.jsonDictionary,
+      "text": alertMessage.text,
+      "timestamp": alertMessage.timestamp.bridgeTimestamp
+    ]
+    sendSdkEvent(withName: "onOutgoingAlertMessageSendFailed", body: body)
+  }
+
+  func zello(_ zello: Zello, didStart outgoingEmergency: ZelloOutgoingEmergency) {
+    sendSdkEvent(withName: "onOutgoingEmergencyStarted", body: outgoingEmergency.jsonDictionary)
+  }
+
+  func zello(_ zello: Zello, didStop outgoingEmergency: ZelloOutgoingEmergency) {
+    sendSdkEvent(withName: "onOutgoingEmergencyStopped", body: outgoingEmergency.jsonDictionary)
+  }
+
+  func zello(_ zello: Zello, didStart incomingEmergency: ZelloIncomingEmergency) {
+    let body: [AnyHashable: Any] = [
+      "emergency": incomingEmergency.jsonDictionary,
+      "emergencies": zello.incomingEmergencies.map { emergency in
+        emergency.jsonDictionary
+      }
+    ]
+    sendSdkEvent(withName: "onIncomingEmergencyStarted", body: body)
+  }
+
+  func zello(_ zello: Zello, didStop incomingEmergency: ZelloIncomingEmergency) {
+    let body: [AnyHashable: Any] = [
+      "emergency": incomingEmergency.jsonDictionary,
+      "emergencies": zello.incomingEmergencies.map { emergency in
+        emergency.jsonDictionary
+      }
+    ]
+    sendSdkEvent(withName: "onIncomingEmergencyStopped", body: body)
+  }
+
+  func zello(_ zello: Zello, didUpdate recentEntries: [ZelloRecentEntry]) {
+    let body: [AnyHashable: Any] = [
+      "recents": recentEntries.map { recent in
+        recent.jsonDictionary
+      }
+    ]
+    sendSdkEvent(withName: "onRecentsUpdated", body: body)
+  }
+
+  func zelloDidUpdateHistory(_ zello: Zello) {
+    sendSdkEvent(withName: "onHistoryUpdated", body: nil)
+  }
+
+  func zello(_ zello: Zello, didStartHistoryPlayback message: ZelloHistoryVoiceMessage) {
+    sendSdkEvent(withName: "onHistoryPlaybackStarted", body: message.jsonDictionary)
+  }
+
+  func zello(_ zello: Zello, didStopHistoryPlayback message: ZelloHistoryVoiceMessage) {
+    sendSdkEvent(withName: "onHistoryPlaybackStopped", body: message.jsonDictionary)
+  }
+}

package/ios/Extensions/ZelloIncomingEmergency+Extension.swift

@@ -0,0 +1,16 @@
+import ZelloSDK
+
+extension ZelloIncomingEmergency {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "channel": channel.jsonDictionary,
+      "channelUserName": channelUser.name,
+      "emergencyId": id,
+      "startTimestamp": startTimestamp.bridgeTimestamp
+    ]
+    if let endTimestamp {
+      body["endTimestamp"] = endTimestamp.bridgeTimestamp
+    }
+    return body
+  }
+}

package/ios/Extensions/ZelloOutgoingEmergency+Extension.swift

@@ -0,0 +1,14 @@
+import ZelloSDK
+
+extension ZelloOutgoingEmergency {
+  var jsonDictionary: [AnyHashable: Any] {
+    var body: [AnyHashable: Any] = [
+      "channel": channel.jsonDictionary,
+      "startTimestamp": startTimestamp.bridgeTimestamp
+    ]
+    if let endTimestamp {
+      body["endTimestamp"] = endTimestamp.bridgeTimestamp
+    }
+    return body
+  }
+}