@zelloptt/react-native-zello-sdk 2.0.1 → 4.0.0

package/README.md

@@ -2,7 +2,7 @@
 
 Zello SDK for React Native.
 
-Our React Native SDK offers itself as a thin wrapper around our native iOS and Android SDK’s. It is built with TypeScript, and communicates with the native SDK’s via [React Native’s native module support](https://reactnative.dev/docs/native-modules-intro).
+Our React Native SDK offers itself as a thin wrapper around our native iOS and Android SDK’s. It is built with TypeScript, and communicates with the native SDK’s via a [Turbo Native Module](https://reactnative.dev/docs/turbo-native-modules-introduction) on React Native’s New Architecture.
 
 This repository contains both the React Native Bridge, as well as an example app to demonstrate usage.
 
@@ -13,6 +13,9 @@ The following instructions are for the installation of the SDK into your applica
 ## Prerequisites
 A React Native application and environment.
 
+- **React Native 0.86+** with the **New Architecture enabled** (the default since 0.76). This SDK is a Turbo Native Module and does not support the legacy architecture.
+- **Node 20+** (Node 22+ recommended, matching the React Native 0.86 toolchain).
+
 A thorough understanding of Zello. The best place to get started is our [documentation](https://sdk.zello.com/).
 
 
@@ -25,9 +28,82 @@ npm install @zelloptt/react-native-zello-sdk
 
 ### iOS
 
-Before getting started, please reference the [iOS Installation Guide](https://sdk.zello.com/installation-guides/ios-installation-guide).
+Before getting started, please reference the [iOS Installation Guide](https://developers.zello.com/sdk/latest/ios/documentation/zellosdk/getting-started). There is no need to add the native `ZelloSDK` to your project directly — this library declares it for you.
+
+The native ZelloSDK is consumed through **Swift Package Manager only** (product `ZelloSDKUmbrella` from [`github.com/zelloptt/ios-mobile-sdk`](https://github.com/zelloptt/ios-mobile-sdk)); it is no longer available through CocoaPods. React Native itself still requires CocoaPods, so the React Native layer of this library stays a CocoaPod and a small Podfile helper wires the Swift package into your app.
+
+Requirements:
+
+- **React Native 0.86 or later**: the podspec uses React Native's `spm_dependency` and raises during `pod install` on older versions.
+- **iOS 17.0 or later**, in **both** places: `platform :ios, '17.0'` in your `Podfile`, and the `IPHONEOS_DEPLOYMENT_TARGET` of your app target and of any app extension (for example the Notification Service Extension).
+- Native ZelloSDK `3.3.2` or later, below `4.0.0`. The requirement is `upToNextMajorVersion` from `3.3.2`; a fresh resolve picks the newest `3.x`, while a committed `Package.resolved` keeps its pin until you use *File > Packages > Update to Latest Package Versions*.
+
+#### Setup
+
+```sh
+npm install @zelloptt/react-native-zello-sdk@4
+npx @zelloptt/react-native-zello-sdk setup-ios
+cd ios && bundle exec pod install
+```
+
+`setup-ios` edits only your `Podfile` (it never touches the `.xcodeproj`): it prints a diff and asks for confirmation. Options: `--dry-run` (print the diff only), `--yes` (non-interactive), `--project-root <dir>` / `--podfile <path>` (monorepos), `--app-target <name>` and `--extension-target <name>` (repeatable) when the targets cannot be detected. Only top-level `Podfile` targets whose name contains `Extension`, `NSE` or `Widget` are detected as extensions; list any other extension with `--extension-target`. It exits with code `2` and changes nothing when it needs a manual step.
+
+Or make the changes yourself:
+
+```ruby
+# Podfile — before `prepare_react_native_project!`
+require Pod::Executable.execute_command('node', ['-p',
+  "require.resolve('@zelloptt/react-native-zello-sdk/scripts/zello_pods.rb', {paths: [process.argv[1]]})",
+  __dir__]).strip
+
+platform :ios, '17.0'
+
+target 'MyApp' do
+  # ...
+  post_install do |installer|
+    zello_post_install(installer, app_target: 'MyApp', extension_targets: ['NotificationServiceExtension'])
+    react_native_post_install(installer, config[:reactNativePath])
+  end
+end
+```
+
+`zello_post_install` adds the package to your Xcode project, links `ZelloSDKUmbrella` into the app and embeds it, and links it (without embedding) into the listed extension targets. It is idempotent, and raises with an explanation if the deployment target is below 17.0 or a `ZelloSDK` pod is still present. Open the `.xcworkspace` afterwards; Xcode resolves the package on first build.
 
-The main amendment to the guide is that there is no need to add the `ZelloSDK` as a pod directly to your project.
+If your app project already references `github.com/zelloptt/ios-mobile-sdk`, `zello_post_install` keeps your version requirement unless it is an *Up to Next Major Version* rule with a lower minimum than `3.3.2`; then it raises the minimum to `3.3.2`. The bridge pod always requires `3.3.2` up to the next major, and Xcode resolves one version that satisfies both.
+
+Static and dynamic `use_frameworks!` as well as no `use_frameworks!` are all supported. With static or no `use_frameworks!`, `pod install` prints `[SPM] WARNING!!! Pod react-native-zello-sdk is using swift package(s) ZelloSDKUmbrella with static linking, this might cause linker errors`; this is expected, because `zello_post_install` links the dynamic `ZelloSDKUmbrella` into the app.
+
+#### Upgrading from 3.x
+
+1. Run the three commands above. `setup-ios` removes `pod 'ZelloSDK'`, the CocoaPods resilient-pods `post_install` workaround (`BUILD_LIBRARY_FOR_DISTRIBUTION` for `PhoneNumberKit`, `SnowplowTracker`, `CocoaLumberjack`, `PromisesSwift`) and raises `platform :ios` to `17.0`. If you did it by hand, remove those as well as any `ZELLO_USE_SPM` setting and any manually added `ZelloSDKUmbrella` package reference in your extension targets.
+2. Raise the app and extension deployment targets to 17.0 if they are lower.
+3. Do a **Clean Build Folder** in Xcode (or `rm -rf ios/build`) once: frameworks previously embedded by CocoaPods can linger in an incremental build and clash with the new ones.
+
+#### Troubleshooting (Swift Package Manager)
+
+- `[CP] Copy Pods Resources ... Operation not permitted` with static or no `use_frameworks!`: set `ENABLE_USER_SCRIPT_SANDBOXING = NO` on the app and extension targets.
+- `Multiple commands produce '*.ttf'` with static or no `use_frameworks!`: remove the duplicated font files from the app target's *Copy Bundle Resources* phase (keep them in `UIAppFonts`); CocoaPods already copies them.
+- **PhoneNumberKit:** ZelloSDK pulls PhoneNumberKit via Swift Package Manager — the `marmelroy/PhoneNumberKit` 3.x on native `3.3.2`, the 5.x from the PhoneNumberKit organization's repository on `3.3.3` and later. These are two different repositories sharing one package identity, so:
+  - an app that depends on `marmelroy/PhoneNumberKit` itself gets *package 'phonenumberkit' is required using two different URLs* once `3.3.3` resolves — switch your dependency to the PhoneNumberKit organization repository, or drop it;
+  - builds that disable automatic resolution (`-onlyUsePackageVersionsFromResolvedFile`) fail until their `Package.resolved` is updated;
+  - a PhoneNumberKit **pod** next to the Swift package duplicates classes — remove the pod.
+
+#### Expo
+
+Add the config plugin, plus `expo-build-properties` to raise the app's deployment target, to `app.json`:
+
+```json
+{
+  "expo": {
+    "plugins": [
+      ["expo-build-properties", { "ios": { "deploymentTarget": "17.0" } }],
+      ["@zelloptt/react-native-zello-sdk", { "extensionTargets": ["NotificationServiceExtension"] }]
+    ]
+  }
+}
+```
+
+The plugin applies the same Podfile changes as `setup-ios` on `expo prebuild`, and sets the deployment target of the listed `extensionTargets` to 17.0. Expo applies plugin mods in reverse order, so list it **before** any plugin that creates the extension target; prebuild fails if a listed extension target is not in the Xcode project. Expo apps use no `use_frameworks!` unless `ios.useFrameworks` is set.
 
 #### Troubleshooting
 
@@ -62,29 +138,38 @@ repositories {
 
 #### Linking
 
-Since the Zello Android SDK requires Hilt, and we must inject the `Zello` instance into the `ReactPackage`, the project does not work with autolinking.
+Since the Zello Android SDK requires Hilt, and we must inject the `Zello` instance into the package, the project does not work with autolinking.
 
-As such, you will need to create a `ReactPackage` wrapper like this:
+Because the module is now a Turbo Native Module (New Architecture), the package must be a `BaseReactPackage` that exposes the module through a `ReactModuleInfoProvider` with `isTurboModule = true`:
 
 ```kotlin
 /// ZelloAndroidSdkPackage.kt
 
-import com.facebook.react.ReactPackage
+import com.facebook.react.BaseReactPackage
 import com.facebook.react.bridge.NativeModule
 import com.facebook.react.bridge.ReactApplicationContext
-import com.facebook.react.uimanager.ViewManager
+import com.facebook.react.module.model.ReactModuleInfo
+import com.facebook.react.module.model.ReactModuleInfoProvider
 import com.zello.sdk.Zello
 import com.zellosdk.ZelloAndroidSdkModule
 import javax.inject.Inject
 
-class ZelloAndroidSdkPackage @Inject constructor(private val zello: Zello) : ReactPackage {
-
-  override fun createNativeModules(reactContext: ReactApplicationContext): List<NativeModule> {
-    return listOf(ZelloAndroidSdkModule(reactContext, zello))
-  }
-
-  override fun createViewManagers(reactContext: ReactApplicationContext): List<ViewManager<*, *>> {
-    return emptyList()
+class ZelloAndroidSdkPackage @Inject constructor(private val zello: Zello) : BaseReactPackage() {
+
+  override fun getModule(name: String, reactContext: ReactApplicationContext): NativeModule? =
+    if (name == "NativeZelloSdk") ZelloAndroidSdkModule(reactContext, zello) else null
+
+  override fun getReactModuleInfoProvider() = ReactModuleInfoProvider {
+    mapOf(
+      "NativeZelloSdk" to ReactModuleInfo(
+        "NativeZelloSdk", // name
+        "NativeZelloSdk", // className
+        false, // canOverrideExistingModule
+        false, // needsEagerInit
+        false, // isCxxModule
+        true   // isTurboModule
+      )
+    )
   }
 }
 ```

package/android/build.gradle

@@ -11,10 +11,9 @@ buildscript {
   }
 
   dependencies {
-    classpath "com.android.tools.build:gradle:8.5.1"
+    classpath "com.android.tools.build:gradle:8.13.0"
     // noinspection DifferentKotlinGradleVersion
     classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:$kotlin_version"
-    classpath("com.google.dagger:hilt-android-gradle-plugin:2.51")
   }
 }
 
@@ -29,12 +28,11 @@ def isNewArchitectureEnabled() {
 
 apply plugin: "com.android.library"
 apply plugin: "kotlin-android"
-apply plugin: 'com.google.dagger.hilt.android'
-apply plugin: 'kotlin-kapt'
 
-hilt {
-  enableAggregatingTask = true
-}
+// Note: this library does NOT apply Hilt/kapt. Its only @Inject was on a class
+// that the host app constructs manually (see ZelloAndroidSdkPackage), so Hilt
+// never processed it. Avoiding kapt also lets the generated TurboModule codegen
+// spec compile cleanly (kapt doesn't reliably see generated sources).
 
 if (isNewArchitectureEnabled()) {
   apply plugin: "com.facebook.react"
@@ -68,6 +66,21 @@ android {
     }
   }
 
+  if (isNewArchitectureEnabled()) {
+    // Make the generated TurboModule spec (NativeZelloSdkSpec) visible to the
+    // Kotlin/kapt compile. The RN Gradle plugin generates it under
+    // build/generated/source/codegen and adds it via finalizeDsl, but because
+    // this library uses kapt (Hilt) that late addition isn't reliably picked up,
+    // so register the dir explicitly here.
+    sourceSets {
+      main {
+        java.srcDirs += [
+          layout.buildDirectory.dir("generated/source/codegen/java").get().asFile
+        ]
+      }
+    }
+  }
+
   compileSdkVersion getExtOrIntegerDefault("compileSdkVersion")
 
   defaultConfig {
@@ -102,7 +115,7 @@ repositories {
 
 def kotlin_version = getExtOrDefault("kotlinVersion")
 
-def zelloSdkVersion = "1.0.+"
+def zelloSdkVersion = "3.+"
 
 dependencies {
   // For < 0.71, this will be from the local maven repo
@@ -119,6 +132,12 @@ dependencies {
   }
   implementation(platform("com.google.firebase:firebase-bom:33.1.2"))
   implementation("com.google.firebase:firebase-messaging")
-  implementation("com.google.dagger:hilt-android:2.51")
-  kapt("com.google.dagger:hilt-android-compiler:2.51")
+}
+
+if (isNewArchitectureEnabled()) {
+  react {
+    jsRootDir = file("../src/")
+    libraryName = "NativeZelloSdk"
+    codegenJavaPackageName = "com.zellosdk"
+  }
 }

package/android/gradle.properties

@@ -1,5 +1,5 @@
-ZelloSdk_kotlinVersion=1.8.0
+ZelloSdk_kotlinVersion=2.3.21
 ZelloSdk_minSdkVersion=24
-ZelloSdk_targetSdkVersion=34
-ZelloSdk_compileSdkVersion=34
-ZelloSdk_ndkversion=25.1.8937393
+ZelloSdk_targetSdkVersion=36
+ZelloSdk_compileSdkVersion=36
+ZelloSdk_ndkversion=27.1.12297006

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

@@ -2,13 +2,15 @@
 
 package com.zellosdk
 
+// NativeZelloSdkSpec is generated by RN codegen into this same package
+// (com.zellosdk), driven by codegenConfig.android.javaPackageName in
+// package.json — so it needs no import.
 import com.facebook.react.bridge.Arguments
-import com.facebook.react.bridge.Callback
+import com.facebook.react.bridge.Promise
 import com.facebook.react.bridge.ReactApplicationContext
 import com.facebook.react.bridge.ReactContext
-import com.facebook.react.bridge.ReactContextBaseJavaModule
-import com.facebook.react.bridge.ReactMethod
 import com.facebook.react.bridge.ReadableArray
+import com.facebook.react.bridge.ReadableMap
 import com.facebook.react.bridge.WritableMap
 import com.facebook.react.modules.core.DeviceEventManagerModule
 import com.zello.sdk.Zello
@@ -32,12 +34,11 @@ import com.zello.sdk.ZelloConsoleSettings
 import com.zello.sdk.ZelloGroupConversation
 import com.zello.sdk.ZelloState
 import com.zello.sdk.ZelloTextMessage
-import javax.inject.Inject
 
-class ZelloAndroidSdkModule @Inject constructor(
+class ZelloAndroidSdkModule(
   reactContext: ReactApplicationContext,
   private val zello: Zello
-) : ReactContextBaseJavaModule(reactContext), Zello.Listener {
+) : NativeZelloSdkSpec(reactContext), Zello.Listener {
   companion object {
     private const val BRIDGE_EVENT_NAME = "zellosdk"
     private const val EVENT_NAME = "eventName"
@@ -48,26 +49,33 @@ class ZelloAndroidSdkModule @Inject constructor(
     zello.framework = Zello.Framework.REACT_NATIVE
   }
 
-  override fun getName() = "ZelloAndroidSdkModule"
+  // getName() is provided by NativeZelloSdkSpec (returns "NativeZelloSdk").
 
-  @ReactMethod fun configure(enableOfflineMessagePushNotifications: Boolean, enableForegroundService: Boolean) {
+  override fun configure(config: ReadableMap) {
+    val android = config.getMap("android")
+    val enableOfflineMessagePushNotifications =
+      android?.takeIf { it.hasKey("enableOfflineMessagePushNotifications") }
+        ?.getBoolean("enableOfflineMessagePushNotifications") ?: false
+    val enableForegroundService =
+      android?.takeIf { it.hasKey("enableForegroundService") }
+        ?.getBoolean("enableForegroundService") ?: false
     zello.configure(enableOfflineMessagePushNotifications, enableForegroundService)
   }
 
-  @ReactMethod fun connect(network: String, username: String, password: String) {
+  override fun connect(network: String, username: String, password: String) {
     zello.connect(ZelloCredentials(network, username, password))
   }
 
-  @ReactMethod fun disconnect() {
+  override fun disconnect() {
     zello.disconnect()
   }
 
-  @ReactMethod fun setSelectedContact(name: String, type: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun selectContact(name: String, contactType: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.setSelectedContact(contact)
   }
 
-  @ReactMethod fun setAccountStatus(status: String) {
+  override fun setAccountStatus(status: String) {
     val accountStatus = when (status) {
       "available" -> ZelloAccountStatus.AVAILABLE
       "busy" -> ZelloAccountStatus.BUSY
@@ -76,28 +84,39 @@ class ZelloAndroidSdkModule @Inject constructor(
     zello.setAccountStatus(accountStatus)
   }
 
-  @ReactMethod fun connectChannel(name: String) {
+  override fun connectChannel(name: String) {
     val channel = zello.getChannel(name) ?: return
     zello.connectChannel(channel)
   }
 
-  @ReactMethod fun disconnectChannel(name: String) {
+  override fun disconnectChannel(name: String) {
     val channel = zello.getChannel(name) ?: return
     zello.disconnectChannel(channel)
   }
 
-  @ReactMethod fun startVoiceMessage(name: String, type: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun connectGroupConversation(name: String) {
+    // ZelloGroupConversation extends ZelloChannel, so connectChannel(ZelloChannel)
+    // accepts a group conversation directly.
+    val conversation = zello.getGroupConversation(name) ?: return
+    zello.connectChannel(conversation)
+  }
+
+  override fun disconnectGroupConversation(name: String) {
+    val conversation = zello.getGroupConversation(name) ?: return
+    zello.disconnectChannel(conversation)
+  }
+
+  override fun startVoiceMessage(name: String, contactType: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.startVoiceMessage(contact)
   }
 
-  @ReactMethod fun stopVoiceMessage() {
+  override fun stopVoiceMessage() {
     zello.stopVoiceMessage()
   }
 
-  @ReactMethod
-  fun sendImage(name: String, type: String, data: ReadableArray) {
-    val contact = contactFrom(name, type) ?: return
+  override fun sendImage(name: String, contactType: String, data: ReadableArray) {
+    val contact = contactFrom(name, contactType) ?: return
     val byteArray = ByteArray(data.size())
     for (i in 0 until data.size()) {
       byteArray[i] = data.getInt(i).toByte()
@@ -105,21 +124,18 @@ class ZelloAndroidSdkModule @Inject constructor(
     zello.sendImage(byteArray, contact)
   }
 
-  @ReactMethod
-  fun sendLocation(name: String, type: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun sendLocation(name: String, contactType: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.sendLocation(contact)
   }
 
-  @ReactMethod
-  fun sendText(name: String, type: String, text: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun sendText(name: String, contactType: String, text: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.sendText(text, contact)
   }
 
-  @ReactMethod
-  fun sendAlert(name: String, type: String, text: String, level: String?) {
-    val contact = contactFrom(name, type) ?: return
+  override fun sendAlert(name: String, contactType: String, text: String, level: String) {
+    val contact = contactFrom(name, contactType) ?: return
     val channelAlertLevel = when (level) {
       "all" -> ZelloAlertMessage.ChannelLevel.ALL
       "connected" -> ZelloAlertMessage.ChannelLevel.CONNECTED
@@ -128,89 +144,92 @@ class ZelloAndroidSdkModule @Inject constructor(
     zello.sendAlert(contact, text, channelAlertLevel)
   }
 
-  @ReactMethod
-  fun submitProblemReport() {
+  override fun submitProblemReport() {
     zello.submitProblemReport()
   }
 
-  @ReactMethod
-  fun muteContact(name: String, type: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun muteContact(name: String, contactType: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.muteContact(contact)
   }
 
-  @ReactMethod
-  fun unmuteContact(name: String, type: String) {
-    val contact = contactFrom(name, type) ?: return
+  override fun unmuteContact(name: String, contactType: String) {
+    val contact = contactFrom(name, contactType) ?: return
     zello.unmuteContact(contact)
   }
 
-  @ReactMethod
-  fun startEmergency() {
+  override fun startEmergency() {
     zello.startEmergency()
   }
 
-  @ReactMethod
-  fun stopEmergency() {
+  override fun stopEmergency() {
     zello.stopEmergency()
   }
 
-  @ReactMethod
-  fun getHistory(name: String, type: String, size: Int?, callback: Callback) {
-    val contact = contactFrom(name, type) ?: return
-    val messages = if (size != null) zello.getHistory(contact, size) else zello.getHistory(contact)
-    callback.invoke(ZelloAndroidSdkModuleHelper.historyMessagesToWritableArray(messages))
+  override fun stopIncomingEmergency(emergencyId: String) {
+    val incomingEmergency = zello.incomingEmergencies.firstOrNull { it.emergencyId == emergencyId } ?: return
+    zello.stopIncomingEmergency(incomingEmergency)
   }
 
-  @ReactMethod
-  fun playHistoryMessage(historyId: String, contactName: String, type: String) {
-    val contact = contactFrom(contactName, type) ?: return
+  override fun getHistory(name: String, contactType: String, maxMessages: Double, promise: Promise) {
+    val contact = contactFrom(name, contactType)
+    if (contact == null) {
+      promise.resolve(Arguments.createArray())
+      return
+    }
+    val messages = zello.getHistory(contact, maxMessages.toInt())
+    promise.resolve(ZelloAndroidSdkModuleHelper.historyMessagesToWritableArray(messages))
+  }
+
+  override fun playHistoryMessage(historyId: String, contactName: String, contactType: String) {
+    val contact = contactFrom(contactName, contactType) ?: return
     val message = zello.getHistoryMessage(historyId, contact) as? ZelloHistoryVoiceMessage ?: return
     zello.playHistoryMessage(message)
   }
 
-  @ReactMethod
-  fun stopHistoryMessagePlayback() {
+  override fun stopHistoryMessagePlayback() {
     zello.stopHistoryMessagePlayback()
   }
 
-  @ReactMethod
-  fun getImageDataForHistoryImageMessage(historyId: String, contactName: String, type: String, callback: Callback) {
-    val contact = contactFrom(contactName, type) ?: return
-    val message = zello.getHistoryMessage(historyId, contact) as? ZelloHistoryImageMessage ?: return
+  override fun getHistoryImageData(historyId: String, contactName: String, contactType: String, promise: Promise) {
+    val contact = contactFrom(contactName, contactType)
+    if (contact == null) {
+      promise.resolve(null)
+      return
+    }
+    val message = zello.getHistoryMessage(historyId, contact) as? ZelloHistoryImageMessage
+    if (message == null) {
+      promise.resolve(null)
+      return
+    }
     zello.loadBitmapForHistoryImageMessage(message) {
-      callback.invoke(ZelloAndroidSdkModuleHelper.bitmapToBase64String(it))
+      promise.resolve(ZelloAndroidSdkModuleHelper.bitmapToBase64String(it))
     }
   }
 
-  @ReactMethod
-  fun endDispatchCall(channelName: String) {
+  override fun endDispatchCall(channelName: String) {
     val dispatchChannel = zello.getChannel(channelName) as? ZelloDispatchChannel ?: return
     val call = dispatchChannel.currentCall ?: return
     zello.endDispatchCall(call, dispatchChannel)
   }
 
-  @ReactMethod
-  fun createGroupConversation(usernames: ReadableArray, displayName: String?) {
+  override fun createGroupConversation(usernames: ReadableArray, displayName: String) {
     val users = usernames.toArrayList().mapNotNull { zello.getUser(it as String) }
-    zello.createGroupConversation(users, displayName)
+    zello.createGroupConversation(users, displayName.ifEmpty { null })
   }
 
-  @ReactMethod
-  fun addUsersToGroupConversation(conversationName: String, usernames: ReadableArray) {
+  override fun addUsersToGroupConversation(conversationName: String, usernames: ReadableArray) {
     val conversation = zello.getGroupConversation(conversationName) ?: return
     val users = usernames.toArrayList().mapNotNull { zello.getUser(it as String) }
     zello.addUsersToGroupConversation(conversation, users)
   }
 
-  @ReactMethod
-  fun leaveGroupConversation(conversationName: String) {
+  override fun leaveGroupConversation(conversationName: String) {
     val conversation = zello.getGroupConversation(conversationName) ?: return
     zello.leaveGroupConversation(conversation)
   }
 
-  @ReactMethod
-  fun renameGroupConversation(conversationName: String, newName: String) {
+  override fun renameGroupConversation(conversationName: String, newName: String) {
     val conversation = zello.getGroupConversation(conversationName) ?: return
     zello.renameGroupConversation(conversation, newName)
   }
@@ -363,6 +382,7 @@ class ZelloAndroidSdkModule @Inject constructor(
       putMap("contact", ZelloAndroidSdkModuleHelper.sdkContactToWritableMap(contact = message.contact))
       putMap("channelUser", ZelloAndroidSdkModuleHelper.channelUserToWritableMap(message.channelUser))
       putString("timestamp", message.timestamp.toString())
+      putBoolean("isTranslation", message.isTranslation)
     })
   }
 
@@ -371,6 +391,7 @@ class ZelloAndroidSdkModule @Inject constructor(
       putMap("contact", ZelloAndroidSdkModuleHelper.sdkContactToWritableMap(contact = message.contact))
       putMap("channelUser", ZelloAndroidSdkModuleHelper.channelUserToWritableMap(message.channelUser))
       putString("timestamp", message.timestamp.toString())
+      putBoolean("isTranslation", message.isTranslation)
     })
   }
 
@@ -470,6 +491,10 @@ class ZelloAndroidSdkModule @Inject constructor(
     sendEvent(reactApplicationContext, "onHistoryUpdated", null)
   }
 
+  override fun onHistoryVoiceMessageTranscriptionAvailable(zello: Zello, message: ZelloHistoryVoiceMessage) {
+    sendEvent(reactApplicationContext, "onHistoryVoiceMessageTranscriptionAvailable", ZelloAndroidSdkModuleHelper.historyVoiceMessageToWritableMap(message))
+  }
+
   override fun onConsoleSettingsChanged(zello: Zello, settings: ZelloConsoleSettings) {
     sendEvent(reactApplicationContext, "onConsoleSettingsChanged", ZelloAndroidSdkModuleHelper.consoleSettingsToWritableMap(settings))
   }

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

@@ -19,6 +19,7 @@ import com.zello.sdk.ZelloHistoryTextMessage
 import com.zello.sdk.ZelloHistoryVoiceMessage
 import com.zello.sdk.ZelloIncomingEmergency
 import com.zello.sdk.ZelloRecentEntry
+import com.zello.sdk.ZelloTranscription
 import com.zello.sdk.ZelloUser
 import java.io.ByteArrayOutputStream
 
@@ -66,6 +67,8 @@ object ZelloAndroidSdkModuleHelper {
 				putBoolean("isConnected", contact.status == ZelloChannel.ConnectionStatus.CONNECTED)
 				putBoolean("isConnecting", contact.status == ZelloChannel.ConnectionStatus.CONNECTING)
 				putInt("usersOnline", contact.usersOnline)
+				putString("channelType", contact.type.toString())
+				putBoolean("translationsEnabled", contact.translationsEnabled)
 				putMap("options", WritableNativeMap().apply {
 					val options = contact.options
 					putBoolean("noDisconnect", options.noDisconnect)
@@ -74,6 +77,8 @@ object ZelloAndroidSdkModuleHelper {
 					putBoolean("allowAlerts", options.allowAlerts)
 					putBoolean("allowTextMessages", options.allowTextMessages)
 					putBoolean("allowLocations", options.allowLocations)
+					putBoolean("allowEmergencyEndOwn", options.allowEmergencyEndOwn)
+					putBoolean("allowEmergencyEndOthers", options.allowEmergencyEndOthers)
 				})
 				if (contact is ZelloDispatchChannel) {
 					putBoolean("isDispatchChannel", true)
@@ -173,6 +178,26 @@ object ZelloAndroidSdkModuleHelper {
 			putString("historyId", message.historyId)
 			putBoolean("incoming", message.incoming)
 			putInt("durationMs", message.durationMs.toInt())
+			message.transcription?.let {
+				putMap("transcription", transcriptionToWritableMap(it))
+			}
+		}
+	}
+
+	fun transcriptionToWritableMap(transcription: ZelloTranscription): WritableMap {
+		return Arguments.createMap().apply {
+			putString("text", transcription.text)
+			putString("language", transcription.language)
+			putBoolean("isTruncated", transcription.isTruncated)
+			putDouble("confidence", transcription.confidence)
+			putArray("translations", WritableNativeArray().apply {
+				transcription.translations.forEach { translation ->
+					pushMap(Arguments.createMap().apply {
+						putString("text", translation.text)
+						putString("language", translation.language)
+					})
+				}
+			})
 		}
 	}