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

package/app.plugin.js

@@ -0,0 +1,97 @@
+'use strict';
+
+/**
+ * Expo config plugin: migrates the generated Podfile to the SwiftPM-based native ZelloSDK and
+ * makes sure extension targets meet the iOS 17.0 deployment target.
+ *
+ *   "plugins": [["@zelloptt/react-native-zello-sdk", { "extensionTargets": ["NotificationServiceExtension"] }]]
+ *
+ * The app's deployment target itself comes from `expo-build-properties`
+ * (`ios.deploymentTarget: "17.0"`). Expo runs mods in reverse plugin order, so list this plugin
+ * before any plugin that creates the extension target.
+ */
+
+const {
+  createRunOncePlugin,
+  withPodfile,
+  withXcodeProject,
+} = require('expo/config-plugins');
+const {
+  MIN_IOS,
+  compareVersions,
+  transformPodfile,
+} = require('./scripts/podfile-transform');
+const pkg = require('./package.json');
+
+const unquote = (s) => String(s).replace(/^"(.*)"$/, '$1');
+
+/** Raises IPHONEOS_DEPLOYMENT_TARGET to MIN_IOS on the named native targets (xcode project object). */
+function setExtensionDeploymentTarget(project, extensionTargets) {
+  const lists = project.pbxXCConfigurationList();
+  const configs = project.pbxXCBuildConfigurationSection();
+  const sections = project.pbxNativeTargetSection();
+  const targets = Object.keys(sections)
+    .map((key) => sections[key])
+    .filter((target) => typeof target === 'object');
+  const missing = extensionTargets.filter(
+    (name) => !targets.some((target) => unquote(target.name) === name)
+  );
+  if (missing.length) {
+    throw new Error(
+      `[react-native-zello-sdk] Extension target(s) ${missing.join(', ')} not found in the Xcode project. ` +
+        'List @zelloptt/react-native-zello-sdk before the plugin that creates them (Expo runs mods in reverse order).'
+    );
+  }
+  targets.forEach((target) => {
+    if (!extensionTargets.includes(unquote(target.name))) {
+      return;
+    }
+    const list = lists[target.buildConfigurationList];
+    (list ? list.buildConfigurations : []).forEach(({ value }) => {
+      const settings = configs[value].buildSettings;
+      const current = settings.IPHONEOS_DEPLOYMENT_TARGET;
+      if (!current || compareVersions(unquote(current), MIN_IOS) < 0) {
+        settings.IPHONEOS_DEPLOYMENT_TARGET = MIN_IOS;
+      }
+    });
+  });
+  return project;
+}
+
+function withZelloSdk(config, props = {}) {
+  const extensionTargets = (props && props.extensionTargets) || [];
+  if (
+    !Array.isArray(extensionTargets) ||
+    !extensionTargets.every((name) => typeof name === 'string' && name)
+  ) {
+    throw new Error(
+      '[react-native-zello-sdk] `extensionTargets` must be an array of target names (strings).'
+    );
+  }
+
+  config = withPodfile(config, (cfg) => {
+    const result = transformPodfile(cfg.modResults.contents, {
+      appTarget: cfg.modRequest.projectName,
+      extensionTargets,
+    });
+    if (result.manual.length) {
+      throw new Error(
+        `[react-native-zello-sdk] Could not migrate the Podfile:\n - ${result.manual.join('\n - ')}` +
+          (result.snippet ? `\n\n${result.snippet}` : '')
+      );
+    }
+    cfg.modResults.contents = result.content;
+    return cfg;
+  });
+
+  if (extensionTargets.length) {
+    config = withXcodeProject(config, (cfg) => {
+      setExtensionDeploymentTarget(cfg.modResults, extensionTargets);
+      return cfg;
+    });
+  }
+  return config;
+}
+
+module.exports = createRunOncePlugin(withZelloSdk, pkg.name, pkg.version);
+module.exports.setExtensionDeploymentTarget = setExtensionDeploymentTarget;

package/ios/Extensions/ZelloContact+Extension.swift

@@ -22,15 +22,19 @@ extension ZelloChannel {
       "isConnected": status == .connected,
       "isConnecting": status == .connecting,
       "usersOnline": usersOnline,
+      "channelType": type.bridgeString,
+      "translationsEnabled": translationsEnabled,
       "options": [
         "noDisconnect": channelOptions.noDisconnect,
         "hidePowerButton": channelOptions.hidePowerButton,
         "listenOnly": channelOptions.listenOnly,
         "allowAlerts": channelOptions.allowAlerts,
         "allowTextMessages": channelOptions.allowTextMessages,
-        "allowLocations": channelOptions.allowLocations
+        "allowLocations": channelOptions.allowLocations,
+        "allowEmergencyEndOwn": channelOptions.allowEmergencyEndOwn,
+        "allowEmergencyEndOthers": channelOptions.allowEmergencyEndOthers
       ],
-      "isDispatchChannel": dispatchInfo != nil
+      "isDispatchChannel": type == .dispatch || dispatchInfo != nil
     ]
     if let currentCall = dispatchInfo?.currentCall {
       body["currentCall"] = currentCall.jsonDictionary
@@ -39,6 +43,21 @@ extension ZelloChannel {
   }
 }
 
+extension ZelloChannel.ChannelType {
+  var bridgeString: String {
+    switch self {
+    case .dispatch:
+      return "DISPATCH"
+    case .team:
+      return "TEAM"
+    case .dynamic:
+      return "DYNAMIC"
+    @unknown default:
+      return "DYNAMIC"
+    }
+  }
+}
+
 extension ZelloUser {
   var jsonDictionary: [AnyHashable: Any] {
     var body: [AnyHashable: Any] = [
@@ -70,13 +89,17 @@ extension ZelloGroupConversation {
       "isConnected": status == .connected,
       "isConnecting": status == .connecting,
       "usersOnline": onlineUsers.count,
+      "channelType": "GROUP_CONVERSATION",
+      "translationsEnabled": false,
       "options": [
         "noDisconnect": false,
         "hidePowerButton": false,
         "listenOnly": false,
         "allowAlerts": true,
         "allowTextMessages": true,
-        "allowLocations": true
+        "allowLocations": true,
+        "allowEmergencyEndOwn": false,
+        "allowEmergencyEndOthers": false
       ],
       "isGroupConversation": true,
       "displayName": displayName,

package/ios/Extensions/ZelloHistoryVoiceMessage+Extension.swift

@@ -13,6 +13,9 @@ extension ZelloHistoryVoiceMessage {
     if let channelUserName = channelUser?.name {
       body["channelUserName"] = channelUserName
     }
+    if let transcription {
+      body["transcription"] = transcription.jsonDictionary
+    }
     return body
   }
 }

package/ios/Extensions/ZelloIOSSdkModule+Extension.swift

@@ -85,7 +85,8 @@ extension ZelloIOSSdkModule: Zello.Delegate {
   func zello(_ zello: Zello, didStartReceiving incomingVoiceMessage: ZelloIncomingVoiceMessage) {
     var body: [AnyHashable: Any] = [
       "contact": incomingVoiceMessage.contact.jsonDictionary,
-      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp
+      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp,
+      "isTranslation": incomingVoiceMessage.isTranslation
     ]
     if let channelUser = incomingVoiceMessage.channelUser {
       body["channelUser"] = channelUser.jsonDictionary
@@ -96,7 +97,8 @@ extension ZelloIOSSdkModule: Zello.Delegate {
   func zello(_ zello: Zello, didFinishReceiving incomingVoiceMessage: ZelloIncomingVoiceMessage) {
     var body: [AnyHashable: Any] = [
       "contact": incomingVoiceMessage.contact.jsonDictionary,
-      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp
+      "timestamp": incomingVoiceMessage.timestamp.bridgeTimestamp,
+      "isTranslation": incomingVoiceMessage.isTranslation
     ]
     if let channelUser = incomingVoiceMessage.channelUser {
       body["channelUser"] = channelUser.jsonDictionary
@@ -291,6 +293,10 @@ extension ZelloIOSSdkModule: Zello.Delegate {
     sendSdkEvent(withName: "onHistoryPlaybackStopped", body: message.jsonDictionary)
   }
 
+  func zello(_ zello: Zello, didReceiveTranscriptionFor message: ZelloHistoryVoiceMessage) {
+    sendSdkEvent(withName: "onHistoryVoiceMessageTranscriptionAvailable", body: message.jsonDictionary)
+  }
+
   func zello(_ zello: Zello, callDidBecomePending call: ZelloDispatchCall, on channel: ZelloChannel) {
     let body: [AnyHashable: Any] = [
       "call": call.jsonDictionary,

package/ios/Extensions/ZelloIncomingEmergency+Extension.swift

@@ -4,6 +4,7 @@ extension ZelloIncomingEmergency {
   var jsonDictionary: [AnyHashable: Any] {
     var body: [AnyHashable: Any] = [
       "channel": channel.jsonDictionary,
+      "channelUser": channelUser.jsonDictionary,
       "channelUserName": channelUser.name,
       "emergencyId": id,
       "startTimestamp": startTimestamp.bridgeTimestamp

package/ios/Extensions/ZelloTranscription+Extension.swift

@@ -0,0 +1,18 @@
+import ZelloSDK
+
+extension ZelloTranscription {
+  var jsonDictionary: [AnyHashable: Any] {
+    return [
+      "text": text,
+      "language": language,
+      "isTruncated": isTruncated,
+      "confidence": confidence,
+      "translations": translations.map { translation in
+        [
+          "text": translation.text,
+          "language": translation.language
+        ]
+      }
+    ]
+  }
+}

package/ios/ZelloIOSSdkModule.swift

@@ -1,10 +1,15 @@
 import ZelloSDK
 
-@objc(ZelloIOSSdkModule) class ZelloIOSSdkModule: RCTEventEmitter {
+@objc(ZelloIOSSdkModule) class ZelloIOSSdkModule: NSObject {
 
   private let bridgeEventName = "zellosdk"
   private let eventName = "eventName"
 
+  // Injected by React Native. The bridgeless-safe way to call a JS module
+  // (here RCTDeviceEventEmitter) from native; RCTEventEmitter's sendEvent path
+  // is not callable under the bridgeless New Architecture.
+  @objc var callableJSModules: RCTCallableJSModules?
+
   let zello = Zello.shared
 
   override init() {
@@ -160,6 +165,18 @@ import ZelloSDK
     }
   }
 
+  @objc func stopIncomingEmergency(_ emergencyId: String) {
+    DispatchQueue.main.async { [weak self] in
+      guard
+        let self,
+        let incomingEmergency = self.zello.incomingEmergencies.first(where: { $0.id == emergencyId })
+      else {
+        return
+      }
+      self.zello.stopIncomingEmergency(incomingEmergency)
+    }
+  }
+
   @objc func getHistory(_ name: String, contactType: String, maxMessages: Int, callback: RCTResponseSenderBlock) {
     guard let contact = contactFromType(contactType, name: name) else {
       callback(nil)
@@ -271,14 +288,14 @@ extension ZelloIOSSdkModule {
   func sendSdkEvent(withName name: String, body: [AnyHashable: Any]?) {
     var eventBody = body ?? [:]
     eventBody[eventName] = name
-    sendEvent(withName: bridgeEventName, body: eventBody)
-  }
-
-  override func supportedEvents() -> [String]! {
-    return [bridgeEventName]
+    callableJSModules?.invokeModule(
+      "RCTDeviceEventEmitter",
+      method: "emit",
+      withArgs: [bridgeEventName, eventBody]
+    )
   }
 
-  override class func requiresMainQueueSetup() -> Bool {
+  @objc static func requiresMainQueueSetup() -> Bool {
     return true
   }
 }

package/ios/ZelloIOSSdkModuleBridge.m

@@ -35,6 +35,7 @@ RCT_EXTERN_METHOD(unmuteContact:(NSString *)name contactType:(NSString *)contact
 
 RCT_EXTERN_METHOD(startEmergency)
 RCT_EXTERN_METHOD(stopEmergency)
+RCT_EXTERN_METHOD(stopIncomingEmergency:(NSString *)emergencyId)
 
 RCT_EXTERN_METHOD(getHistory:(NSString *)name contactType:(NSString *)contactType maxMessages:(NSInteger)maxMessages callback:(RCTResponseSenderBlock)callback)
 

package/ios/ZelloSdkModule.h

@@ -0,0 +1,8 @@
+#import <React/RCTBridgeModule.h>
+
+// Keep this header free of the generated spec import: the spec header
+// (RNZelloSdkSpec.h) is Objective-C++ only, and this header is pulled into the
+// pod's Swift umbrella. The `<NativeZelloSdkSpec>` conformance and the C++
+// TurboModule glue live in ZelloSdkModule.mm instead.
+@interface ZelloSdkModule : NSObject <RCTBridgeModule>
+@end

package/ios/ZelloSdkModule.mm

@@ -0,0 +1,189 @@
+#import "ZelloSdkModule.h"
+
+// Generated Swift interface header for this pod (module name derived from the
+// podspec name `react-native-zello-sdk`). Use the framework-style import when
+// built with use_frameworks!, falling back to the flat header otherwise.
+#if __has_include(<react_native_zello_sdk/react_native_zello_sdk-Swift.h>)
+#import <react_native_zello_sdk/react_native_zello_sdk-Swift.h>
+#else
+#import "react_native_zello_sdk-Swift.h"
+#endif
+
+#ifdef RCT_NEW_ARCH_ENABLED
+// The generated spec header is Objective-C++ only, so it is imported here in
+// the .mm rather than in the public .h. Conformance is declared via a class
+// extension so the public interface stays Swift-umbrella safe.
+#import "RNZelloSdkSpec.h"
+
+@interface ZelloSdkModule () <NativeZelloSdkSpec>
+@end
+#endif
+
+@implementation ZelloSdkModule {
+  ZelloSdkModuleImpl *_impl;
+}
+
+RCT_EXPORT_MODULE(NativeZelloSdk)
+
+- (instancetype)init {
+  if (self = [super init]) {
+    _impl = [ZelloSdkModuleImpl new];
+  }
+  return self;
+}
+
++ (BOOL)requiresMainQueueSetup {
+  return YES;
+}
+
+#ifdef RCT_NEW_ARCH_ENABLED
+
+- (void)configure:(NSDictionary *)config {
+  [_impl configure:config];
+}
+
+- (void)connect:(NSString *)network username:(NSString *)username password:(NSString *)password {
+  [_impl connect:network username:username password:password];
+}
+
+- (void)disconnect {
+  [_impl disconnect];
+}
+
+- (void)setAccountStatus:(NSString *)status {
+  [_impl setAccountStatus:status];
+}
+
+- (void)selectContact:(NSString *)name contactType:(NSString *)contactType {
+  [_impl selectContact:name contactType:contactType];
+}
+
+- (void)startVoiceMessage:(NSString *)name contactType:(NSString *)contactType {
+  [_impl startVoiceMessage:name contactType:contactType];
+}
+
+- (void)stopVoiceMessage {
+  [_impl stopVoiceMessage];
+}
+
+- (void)sendImage:(NSString *)name contactType:(NSString *)contactType data:(NSArray *)data {
+  [_impl sendImage:name contactType:contactType data:data];
+}
+
+- (void)sendLocation:(NSString *)name contactType:(NSString *)contactType {
+  [_impl sendLocation:name contactType:contactType];
+}
+
+- (void)sendText:(NSString *)name contactType:(NSString *)contactType text:(NSString *)text {
+  [_impl sendText:name contactType:contactType text:text];
+}
+
+- (void)sendAlert:(NSString *)name
+      contactType:(NSString *)contactType
+             text:(NSString *)text
+            level:(NSString *)level {
+  [_impl sendAlert:name contactType:contactType text:text level:level];
+}
+
+- (void)connectChannel:(NSString *)name {
+  [_impl connectChannel:name];
+}
+
+- (void)disconnectChannel:(NSString *)name {
+  [_impl disconnectChannel:name];
+}
+
+- (void)connectGroupConversation:(NSString *)name {
+  [_impl connectGroupConversation:name];
+}
+
+- (void)disconnectGroupConversation:(NSString *)name {
+  [_impl disconnectGroupConversation:name];
+}
+
+- (void)submitProblemReport {
+  [_impl submitProblemReport];
+}
+
+- (void)muteContact:(NSString *)name contactType:(NSString *)contactType {
+  [_impl muteContact:name contactType:contactType];
+}
+
+- (void)unmuteContact:(NSString *)name contactType:(NSString *)contactType {
+  [_impl unmuteContact:name contactType:contactType];
+}
+
+- (void)startEmergency {
+  [_impl startEmergency];
+}
+
+- (void)stopEmergency {
+  [_impl stopEmergency];
+}
+
+- (void)stopIncomingEmergency:(NSString *)emergencyId {
+  [_impl stopIncomingEmergency:emergencyId];
+}
+
+- (void)getHistory:(NSString *)name
+       contactType:(NSString *)contactType
+       maxMessages:(double)maxMessages
+           resolve:(RCTPromiseResolveBlock)resolve
+            reject:(RCTPromiseRejectBlock)reject {
+  [_impl getHistory:name
+        contactType:contactType
+        maxMessages:(NSInteger)maxMessages
+            resolve:resolve
+             reject:reject];
+}
+
+- (void)playHistoryMessage:(NSString *)historyId
+               contactName:(NSString *)contactName
+               contactType:(NSString *)contactType {
+  [_impl playHistoryMessage:historyId contactName:contactName contactType:contactType];
+}
+
+- (void)stopHistoryMessagePlayback {
+  [_impl stopHistoryMessagePlayback];
+}
+
+- (void)getHistoryImageData:(NSString *)historyId
+                contactName:(NSString *)contactName
+                contactType:(NSString *)contactType
+                    resolve:(RCTPromiseResolveBlock)resolve
+                     reject:(RCTPromiseRejectBlock)reject {
+  [_impl getHistoryImageData:historyId
+                 contactName:contactName
+                 contactType:contactType
+                     resolve:resolve
+                      reject:reject];
+}
+
+- (void)endDispatchCall:(NSString *)channelName {
+  [_impl endDispatchCall:channelName];
+}
+
+- (void)createGroupConversation:(NSArray *)usernames displayName:(NSString *)displayName {
+  [_impl createGroupConversation:usernames displayName:displayName];
+}
+
+- (void)addUsersToGroupConversation:(NSString *)conversationName usernames:(NSArray *)usernames {
+  [_impl addUsersToGroupConversation:conversationName usernames:usernames];
+}
+
+- (void)leaveGroupConversation:(NSString *)conversationName {
+  [_impl leaveGroupConversation:conversationName];
+}
+
+- (void)renameGroupConversation:(NSString *)conversationName newName:(NSString *)newName {
+  [_impl renameGroupConversation:conversationName newName:newName];
+}
+
+- (std::shared_ptr<facebook::react::TurboModule>)getTurboModule:
+    (const facebook::react::ObjCTurboModule::InitParams &)params {
+  return std::make_shared<facebook::react::NativeZelloSdkSpecJSI>(params);
+}
+
+#endif
+
+@end