@zelloptt/react-native-zello-sdk 0.3.3 → 1.0.0

package/src/sdk/index.ts

@@ -1,21 +1,30 @@
+// noinspection JSUnusedGlobalSymbols
+
 import {
   EmitterSubscription,
   NativeEventEmitter,
   NativeModules,
 } from 'react-native';
-import { isAndroid } from '../utils';
+import {
+  bridgeCallToSdkCall,
+  bridgeChannelUserToSdkChannelUser,
+  bridgeConsoleSettingsToSdkConsoleSettings,
+  isAndroid,
+} from '../utils';
 import {
   ZelloAccountStatus,
   ZelloAlertMessage,
   ZelloChannel,
   ZelloChannelAlertLevel,
-  ZelloChannelUser,
   ZelloConfig,
   ZelloConnectionError,
   ZelloConnectionState,
+  ZelloConsoleSettings,
   ZelloContact,
   ZelloContactType,
   ZelloCredentials,
+  ZelloDispatchChannel,
+  ZelloGroupConversation,
   ZelloHistoryImageMessage,
   ZelloHistoryMessage,
   ZelloHistoryVoiceMessage,
@@ -74,6 +83,10 @@ export class Zello extends EventEmitter {
    * The list of {@link ZelloChannel} in the contact list. Sorted by name, ascending.
    */
   public channels: ZelloChannel[] = [];
+  /**
+   * The list of {@link ZelloGroupConversation} in the contact list. Sorted by name, ascending.
+   */
+  public groupConversations: ZelloGroupConversation[] = [];
 
   /**
    * The current account status. undefined when {@link state} is not {@link ZelloConnectionState.Connected}.
@@ -113,6 +126,12 @@ export class Zello extends EventEmitter {
    */
   public historyVoiceMessage: ZelloHistoryVoiceMessage | undefined;
 
+  /**
+   * The console settings for the network.
+   * This is only expected to be valid when {@link state} is {@link ZelloConnectionState.Connected}.
+   */
+  public consoleSettings: ZelloConsoleSettings | undefined;
+
   private eventListener: EmitterSubscription | undefined;
 
   private constructor() {
@@ -131,9 +150,6 @@ export class Zello extends EventEmitter {
 
   /**
    * Sets configuration variables for the SDK.
-   *
-   * At the moment, this is only functional on Android.
-   *
    * @param config The configuration to set.
    */
   public configure(config: ZelloConfig) {
@@ -143,7 +159,7 @@ export class Zello extends EventEmitter {
         config.android.enableForegroundService
       );
     } else {
-      ZelloIOSSdkModule.configure(config.ios.isDebugBuild);
+      ZelloIOSSdkModule.configure(config.ios.isDebugBuild, config.ios.appGroup);
     }
   }
 
@@ -208,6 +224,17 @@ export class Zello extends EventEmitter {
     return sortedArrayFind(this.channels, name, compareNameAscending);
   }
 
+  /**
+   * Returns the group conversation with the given name. Case-insensitive.
+   * @param name The name of the group conversation to search for.
+   * @return The group conversation with the given name, or null if no group conversation with that name exists.
+   */
+  public getGroupConversation(
+    name: string
+  ): ZelloGroupConversation | undefined {
+    return sortedArrayFind(this.groupConversations, name, compareNameAscending);
+  }
+
   /**
    * Sets the selected contact.
    * While optional, this is typically used for tracking the contact that the user is currently interacting with.
@@ -246,7 +273,11 @@ export class Zello extends EventEmitter {
     if (isAndroid) {
       ZelloAndroidSdkModule.connectChannel(channel.name);
     } else {
-      ZelloIOSSdkModule.connectChannel(channel.name);
+      if (channel.type === ZelloContactType.GroupConversation) {
+        ZelloIOSSdkModule.connectGroupConversation(channel.name);
+      } else {
+        ZelloIOSSdkModule.connectChannel(channel.name);
+      }
     }
   }
 
@@ -260,7 +291,11 @@ export class Zello extends EventEmitter {
     if (isAndroid) {
       ZelloAndroidSdkModule.disconnectChannel(channel.name);
     } else {
-      ZelloIOSSdkModule.disconnectChannel(channel.name);
+      if (channel.type === ZelloContactType.GroupConversation) {
+        ZelloIOSSdkModule.disconnectGroupConversation(channel.name);
+      } else {
+        ZelloIOSSdkModule.disconnectChannel(channel.name);
+      }
     }
   }
 
@@ -523,6 +558,110 @@ export class Zello extends EventEmitter {
     });
   }
 
+  /**
+   * Ends the dispatch call for the given dispatch channel.
+   * This will trigger the {@link ZelloEvent.DISPATCH_CALL_ENDED} event.
+   *
+   * If {@link consoleSettings | ZelloConsoleSettings.allowNonDispatchersToEndCalls} is false, this method will do nothing.
+   *
+   * @param channel The dispatch channel to end the call for.
+   */
+  public endDispatchCall(channel: ZelloDispatchChannel) {
+    if (isAndroid) {
+      ZelloAndroidSdkModule.endDispatchCall(channel.name);
+    } else {
+      ZelloIOSSdkModule.endDispatchCall(channel.name);
+    }
+  }
+
+  /**
+   * Creates a new group conversation with the given users.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_CREATED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param users The users to create the group conversation with.
+   * @param displayName Optional; The display name of the group conversation. The conversation can be renamed later by using {@link renameGroupConversation}.
+   */
+  public createGroupConversation(users: ZelloUser[], displayName?: string) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
+    }
+    if (isAndroid) {
+      ZelloAndroidSdkModule.createGroupConversation(
+        users.map((user) => user.name),
+        displayName
+      );
+    } else {
+      ZelloIOSSdkModule.createGroupConversation(
+        users.map((user) => user.name),
+        displayName
+      );
+    }
+  }
+
+  /**
+   * Adds users to the given group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_USERS_ADDED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to add users to.
+   * @param users The users to add to the group conversation.
+   */
+  public addUsersToGroupConversation(
+    groupConversation: ZelloGroupConversation,
+    users: ZelloUser[]
+  ) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
+    }
+    if (isAndroid) {
+      ZelloAndroidSdkModule.addUsersToGroupConversation(
+        groupConversation.name,
+        users.map((user) => user.name)
+      );
+    } else {
+      ZelloIOSSdkModule.addUsersToGroupConversation(
+        groupConversation.name,
+        users.map((user) => user.name)
+      );
+    }
+  }
+
+  /**
+   * Removes the user from the group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_LEFT} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to leave.
+   */
+  public leaveGroupConversation(groupConversation: ZelloGroupConversation) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
+    }
+    if (isAndroid) {
+      ZelloAndroidSdkModule.leaveGroupConversation(groupConversation.name);
+    } else {
+      ZelloIOSSdkModule.leaveGroupConversation(groupConversation.name);
+    }
+  }
+
+  /**
+   * Renames the group conversation.
+   * This will trigger the {@link ZelloEvent.GROUP_CONVERSATION_RENAMED} and {@link ZelloEvent.CONTACT_LIST_UPDATED} events.
+   * @param groupConversation The group conversation to rename.
+   * @param name The new name for the group conversation.
+   */
+  public renameGroupConversation(
+    groupConversation: ZelloGroupConversation,
+    name: string
+  ) {
+    if (!this.consoleSettings?.allowGroupConversations) {
+      return;
+    }
+    if (isAndroid) {
+      ZelloAndroidSdkModule.renameGroupConversation(
+        groupConversation.name,
+        name
+      );
+    } else {
+      ZelloIOSSdkModule.renameGroupConversation(groupConversation.name, name);
+    }
+  }
+
   private setupEventListener(eventEmitter: NativeEventEmitter) {
     this.eventListener = eventEmitter.addListener('zellosdk', (event) => {
       const eventName = event.eventName;
@@ -568,13 +707,24 @@ export class Zello extends EventEmitter {
           );
           this.channels.sort(compareNameAscending);
 
+          this.groupConversations = event.groupConversations.map(
+            (groupConversation: any) =>
+              bridgeContactToSdkContact(groupConversation)
+          );
+          this.groupConversations.sort(compareNameAscending);
+
           if (event.emergencyChannel) {
             this.emergencyChannel = bridgeContactToSdkContact(
               event.emergencyChannel
             ) as ZelloChannel;
           }
 
-          this.emit(ZelloEvent.CONTACT_LIST_UPDATED, this.users, this.channels);
+          this.emit(
+            ZelloEvent.CONTACT_LIST_UPDATED,
+            this.users,
+            this.channels,
+            this.groupConversations
+          );
           break;
         }
         case 'onSelectedContactChanged': {
@@ -602,7 +752,7 @@ export class Zello extends EventEmitter {
           }
           this.incomingVoiceMessage = new ZelloIncomingVoiceMessage(
             contact,
-            new ZelloChannelUser(event.channelUserName),
+            bridgeChannelUserToSdkChannelUser(event.channelUser),
             parseInt(event.timestamp, 10)
           );
           this.emit(
@@ -621,7 +771,7 @@ export class Zello extends EventEmitter {
             ZelloEvent.INCOMING_VOICE_MESSAGE_STOPPED,
             new ZelloIncomingVoiceMessage(
               contact,
-              new ZelloChannelUser(event.channelUserName),
+              bridgeChannelUserToSdkChannelUser(event.channelUser),
               parseInt(event.timestamp, 10)
             )
           );
@@ -694,7 +844,7 @@ export class Zello extends EventEmitter {
             ZelloEvent.INCOMING_IMAGE_MESSAGE_RECEIVED,
             new ZelloImageMessage(
               contact,
-              new ZelloChannelUser(event.channelUserName),
+              bridgeChannelUserToSdkChannelUser(event.channelUser),
               true,
               parseInt(event.timestamp, 10),
               event.thumbnail,
@@ -748,7 +898,7 @@ export class Zello extends EventEmitter {
             ZelloEvent.INCOMING_ALERT_MESSAGE_RECEIVED,
             new ZelloAlertMessage(
               contact,
-              new ZelloChannelUser(event.channelUserName),
+              bridgeChannelUserToSdkChannelUser(event.channelUser),
               true,
               parseInt(event.timestamp, 10),
               event.text
@@ -799,7 +949,7 @@ export class Zello extends EventEmitter {
             ZelloEvent.INCOMING_TEXT_MESSAGE_RECEIVED,
             new ZelloTextMessage(
               contact,
-              new ZelloChannelUser(event.channelUserName),
+              bridgeChannelUserToSdkChannelUser(event.channelUser),
               true,
               parseInt(event.timestamp, 10),
               event.text
@@ -850,7 +1000,7 @@ export class Zello extends EventEmitter {
             ZelloEvent.INCOMING_LOCATION_MESSAGE_RECEIVED,
             new ZelloLocationMessage(
               contact,
-              new ZelloChannelUser(event.channelUserName),
+              bridgeChannelUserToSdkChannelUser(event.channelUser),
               true,
               parseInt(event.timestamp, 10),
               event.latitude,
@@ -979,12 +1129,9 @@ export class Zello extends EventEmitter {
               if (!contact) {
                 return undefined;
               }
-              const channelUser = recent.channelUser
-                ? new ZelloChannelUser(recent.channelUser)
-                : undefined;
               return new ZelloRecentEntry(
                 contact,
-                channelUser,
+                bridgeChannelUserToSdkChannelUser(event.channelUser),
                 parseInt(recent.timestamp, 10),
                 recent.type.toLowerCase(),
                 recent.incoming
@@ -1018,15 +1165,135 @@ export class Zello extends EventEmitter {
           );
           break;
         }
+        case 'onConsoleSettingsChanged': {
+          this.consoleSettings =
+            bridgeConsoleSettingsToSdkConsoleSettings(event);
+          this.emit(ZelloEvent.CONSOLE_SETTINGS_CHANGED, this.consoleSettings);
+          break;
+        }
+        case 'onDispatchCallTransferred':
+        case 'onDispatchCallEnded':
+        case 'onDispatchCallActive':
+        case 'onDispatchCallPending': {
+          this.processDispatchCallEvent(event);
+          break;
+        }
+        case 'onGroupConversationLeft': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          this.emit(ZelloEvent.GROUP_CONVERSATION_LEFT, groupConversation);
+          break;
+        }
+        case 'onGroupConversationInvite': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          this.emit(ZelloEvent.GROUP_CONVERSATION_INVITE, groupConversation);
+          break;
+        }
+        case 'onGroupConversationCreated': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          this.emit(ZelloEvent.GROUP_CONVERSATION_CREATED, groupConversation);
+          break;
+        }
+        case 'onGroupConversationRenamed': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          this.emit(ZelloEvent.GROUP_CONVERSATION_RENAMED, groupConversation);
+          break;
+        }
+        case 'onGroupConversationUsersAdded': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          const users = event.users.map((user: any) =>
+            bridgeChannelUserToSdkChannelUser(user)
+          );
+          if (!users || users.length === 0) {
+            return;
+          }
+          this.emit(
+            ZelloEvent.GROUP_CONVERSATION_USERS_ADDED,
+            groupConversation,
+            users
+          );
+          break;
+        }
+        case 'onGroupConversationUsersLeft': {
+          const groupConversation = bridgeContactToSdkContact(
+            event.conversation
+          ) as ZelloGroupConversation;
+          if (!groupConversation) {
+            break;
+          }
+          const users = event.users.map((user: any) =>
+            bridgeChannelUserToSdkChannelUser(user)
+          );
+          if (!users || users.length === 0) {
+            return;
+          }
+          this.emit(
+            ZelloEvent.GROUP_CONVERSATION_USERS_LEFT,
+            groupConversation,
+            users
+          );
+          break;
+        }
         default:
           break;
       }
     });
   }
 
+  private processDispatchCallEvent(event: any) {
+    const channel = bridgeContactToSdkContact(
+      event.channel
+    ) as ZelloDispatchChannel;
+    const call = bridgeCallToSdkCall(event.call);
+    if (!channel || !call) {
+      return;
+    }
+    switch (event.name) {
+      case 'onDispatchCallTransferred':
+        this.emit(ZelloEvent.DISPATCH_CALL_TRANSFERRED, channel, call);
+        break;
+      case 'onDispatchCallEnded':
+        this.emit(ZelloEvent.DISPATCH_CALL_ENDED, channel, call);
+        break;
+      case 'onDispatchCallActive':
+        this.emit(ZelloEvent.DISPATCH_CALL_ACTIVE, channel, call);
+        break;
+      case 'onDispatchCallPending':
+        this.emit(ZelloEvent.DISPATCH_CALL_PENDING, channel, call);
+        break;
+      default:
+        break;
+    }
+  }
+
   private clearContactList() {
     this.users = [];
     this.channels = [];
+    this.groupConversations = [];
   }
 
   private static getSdk() {

package/src/types/index.ts

@@ -26,6 +26,8 @@ export type ZelloContact = {
 export enum ZelloContactType {
   User = 'user',
   Channel = 'channel',
+  DispatchChannel = 'dispatchChannel',
+  GroupConversation = 'groupConversation',
 }
 
 /**
@@ -73,6 +75,10 @@ export class ZelloUser implements ZelloContact {
    * This can be used for displaying a smaller version of the profile picture (such as in a list).
    */
   public profilePictureThumbnailUrl: string | undefined;
+  /**
+   * The supported features of the user.
+   */
+  public supportedFeatures: ZelloUserSupportedFeatures;
 
   constructor(
     name: string,
@@ -80,7 +86,8 @@ export class ZelloUser implements ZelloContact {
     isMuted: boolean,
     status: ZelloUserStatus,
     profilePictureUrl: string | undefined,
-    profilePictureThumbnailUrl: string | undefined
+    profilePictureThumbnailUrl: string | undefined,
+    supportedFeatures: ZelloUserSupportedFeatures
   ) {
     this.name = name;
     this.type = ZelloContactType.User;
@@ -89,6 +96,21 @@ export class ZelloUser implements ZelloContact {
     this.status = status;
     this.profilePictureUrl = profilePictureUrl;
     this.profilePictureThumbnailUrl = profilePictureThumbnailUrl;
+    this.supportedFeatures = supportedFeatures;
+  }
+}
+
+/**
+ * The supported features of a {@link ZelloUser}.
+ */
+export class ZelloUserSupportedFeatures {
+  /**
+   * Whether the user supports group conversations.
+   */
+  public readonly groupConversations: boolean;
+
+  constructor(groupConversations: boolean) {
+    this.groupConversations = groupConversations;
   }
 }
 
@@ -128,6 +150,95 @@ export class ZelloChannel implements ZelloContact {
   }
 }
 
+/**
+ * A Zello dispatch channel. A dispatch channel is a special type of channel that has calls between a user and a dispatcher.
+ */
+export class ZelloDispatchChannel extends ZelloChannel {
+  /**
+   * The current call on the dispatch channel, if any.
+   */
+  public readonly currentCall: ZelloDispatchCall | undefined;
+
+  constructor(
+    name: string,
+    isMuted: boolean,
+    connectionStatus: ZelloChannelConnectionStatus,
+    usersOnline: number,
+    options: ZelloChannelOptions,
+    currentCall: ZelloDispatchCall | undefined
+  ) {
+    super(name, isMuted, connectionStatus, usersOnline, options);
+    this.type = ZelloContactType.DispatchChannel;
+    this.currentCall = currentCall;
+  }
+}
+
+/**
+ * A Zello dispatch call. A dispatch call is a call between a user and a dispatcher.
+ */
+export class ZelloDispatchCall {
+  /**
+   * The status of the call.
+   */
+  public readonly status: ZelloDispatchCallStatus;
+  /**
+   * The name of the dispatcher who accepted the call. Null if the call is in the {@link ZelloDispatchCallStatus.Pending} state.
+   */
+  public readonly dispatcher: string | undefined;
+
+  constructor(status: ZelloDispatchCallStatus, dispatcher: string | undefined) {
+    this.status = status;
+    this.dispatcher = dispatcher;
+  }
+}
+
+/**
+ * The status of a {@link ZelloDispatchCall}.
+ */
+export enum ZelloDispatchCallStatus {
+  Pending = 'pending',
+  Active = 'active',
+  Ended = 'ended',
+  Disconnected = 'disconnected',
+}
+
+/**
+ * A ad-hoc group conversation in Zello. A {@link ZelloGroupConversation} is a type of {@link ZelloChannel}, but the provisioning is done by the end user instead of through the Zello Work Administrative Console.
+ *
+ * {@link ZelloGroupConversation}s are only possible when {@link ZelloConsoleSettings.allowGroupConversations} is true.
+ */
+export class ZelloGroupConversation extends ZelloChannel {
+  /**
+   * The display name of the group conversation. This should be used in the UI instead of {@link ZelloChannel#name}, as the {@link ZelloChannel#name} will be a uniquely hashed value starting with c##.
+   */
+  public readonly displayName: string;
+  /**
+   * The users in the group conversation.
+   */
+  public readonly users: ZelloChannelUser[];
+  /**
+   * The users in the group conversation that are currently online.
+   */
+  public readonly onlineUsers: ZelloChannelUser[];
+
+  constructor(
+    name: string,
+    isMuted: boolean,
+    connectionStatus: ZelloChannelConnectionStatus,
+    usersOnline: number,
+    options: ZelloChannelOptions,
+    displayName: string,
+    users: ZelloChannelUser[],
+    onlineUsers: ZelloChannelUser[]
+  ) {
+    super(name, isMuted, connectionStatus, usersOnline, options);
+    this.type = ZelloContactType.GroupConversation;
+    this.displayName = displayName;
+    this.users = users;
+    this.onlineUsers = onlineUsers;
+  }
+}
+
 /**
  * The connection status of a {@link ZelloChannel}.
  */
@@ -160,7 +271,7 @@ export type ZelloChannelOptions = {
    * Whether the user is allowed to send alert messages to the channel.
    * When this is true, you should not show any UI to allow the user to send alert messages to the channel.
    */
-  allowAlerts: boolean;
+  allowAlertMessages: boolean;
   /**
    * Whether the user is allowed to send text messages to the channel.
    * When this is true, you should not show any UI to allow the user to send text messages to the channel.
@@ -170,17 +281,19 @@ export type ZelloChannelOptions = {
    * Whether the user is allowed to send location messages to the channel.
    * When this is true, you should not show any UI to allow the user to send location messages to the channel.
    */
-  allowLocations: boolean;
+  allowLocationMessages: boolean;
 };
 
 /**
- * A user in a {@link ZelloChannel}. A {@link ZelloChannelUser} may or may not not be part of your contact list.
+ * A user in a {@link ZelloChannel}. A {@link ZelloChannelUser} may or may not be part of your contact list.
  */
 export class ZelloChannelUser {
   public name: string;
+  public displayName: string;
 
-  constructor(name: string) {
+  constructor(name: string, displayName: string) {
     this.name = name;
+    this.displayName = displayName;
   }
 }
 
@@ -814,5 +927,39 @@ export type ZelloConfig = {
      * Whether your application is being run in a debug or release build.
      */
     isDebugBuild: boolean;
+    /**
+     * The app group for shared data. This is required for the Notification Service Extension to work properly.
+     */
+    appGroup: string;
   };
 };
+
+/**
+ * Settings for the network. These are configured via the Zello Work Administrative Console.
+ */
+export type ZelloConsoleSettings = {
+  /**
+   * Allow non-dispatchers to end calls. When this is false, you should not show any UI to allow non-dispatchers to end calls.
+   */
+  allowNonDispatchersToEndCalls: boolean;
+  /**
+   * Allow image messages. When this is false, you should not show any UI to allow users to send image messages.
+   */
+  allowImageMessages: boolean;
+  /**
+   * Allow alert messages. When this is false, you should not show any UI to allow users to send alert messages.
+   */
+  allowAlertMessages: boolean;
+  /**
+   * Allow location messages. When this is false, you should not show any UI to allow users to send location messages.
+   */
+  allowLocationMessages: boolean;
+  /**
+   * Allow text messages. When this is false, you should not show any UI to allow users to send text messages.
+   */
+  allowTextMessages: boolean;
+  /**
+   * Allow group conversations. When this is false, you should not show any UI to allow users to create group conversations.
+   */
+  allowGroupConversations: boolean;
+};