voice-react-native-sdk 1.6.2-fork.4

package/src/error/index.ts

@@ -0,0 +1,18 @@
+export { InvalidArgumentError } from './InvalidArgumentError';
+export { InvalidStateError } from './InvalidStateError';
+export { UnsupportedPlatformError } from './UnsupportedPlatformError';
+export { TwilioError } from './TwilioError';
+export {
+  AuthorizationErrors,
+  ClientErrors,
+  ForbiddenErrors,
+  GeneralErrors,
+  MalformedRequestErrors,
+  MediaErrors,
+  RegistrationErrors,
+  ServerErrors,
+  SignalingErrors,
+  SIPServerErrors,
+  TwiMLErrors,
+  UserMediaErrors,
+} from './generated';

package/src/error/utility.ts

@@ -0,0 +1,36 @@
+import { errorsByCode } from './generated';
+import { TwilioError } from './TwilioError';
+import { InvalidArgumentError } from './InvalidArgumentError';
+
+/**
+ * Uses the generated error-code map to create the appropriate error.
+ * If the code is "unexpected" such that there is no constructor for that
+ * specific code, this function will default to a generic {@link TwilioError}.
+ *
+ * @param message an error message
+ * @param code a Twilio error code, for example `31209`
+ *
+ * @returns a {@link TwilioError} or appropriate sub-class
+ */
+export function constructTwilioError(
+  message: string,
+  code: number
+): TwilioError {
+  if (typeof message !== 'string') {
+    throw new InvalidArgumentError(
+      'The "message" argument is not of type "string".'
+    );
+  }
+
+  if (typeof code !== 'number') {
+    throw new InvalidArgumentError(
+      'The "code" argument is not of type "number".'
+    );
+  }
+
+  const ErrorClass = errorsByCode.get(code);
+
+  return typeof ErrorClass !== 'undefined'
+    ? new ErrorClass(message)
+    : new TwilioError(message, code);
+}

package/src/index.tsx

@@ -0,0 +1,24 @@
+// Copyright © 2022 Twilio, Inc. All rights reserved. Licensed under the Twilio
+// license.
+
+// See LICENSE in the project root for license information.
+
+/**
+ * Provides access to Twilio Programmable Voice for React Native applications
+ * running on iOS and Android devices.
+ *
+ * @packageDocumentation
+ */
+export { Voice } from './Voice';
+export { AudioDevice } from './AudioDevice';
+export { Call } from './Call';
+export { CallInvite } from './CallInvite';
+export { CallMessage } from './CallMessage/CallMessage';
+export { IncomingCallMessage } from './CallMessage/IncomingCallMessage';
+export { OutgoingCallMessage } from './CallMessage/OutgoingCallMessage';
+export { CustomParameters } from './type/common';
+export { CallKit } from './type/CallKit';
+export { RTCStats } from './type/RTCStats';
+
+import * as TwilioErrors from './error';
+export { TwilioErrors };

package/src/type/AudioDevice.ts

@@ -0,0 +1,18 @@
+import type { AudioDevice } from '../AudioDevice';
+import type { Constants } from '../constants';
+import type { Uuid } from './common';
+
+export interface NativeAudioDeviceInfo {
+  uuid: Uuid;
+  type: AudioDevice.Type;
+  name: string;
+}
+
+export interface NativeAudioDevicesInfo {
+  audioDevices: NativeAudioDeviceInfo[];
+  selectedDevice?: NativeAudioDeviceInfo;
+}
+
+export interface NativeAudioDevicesUpdatedEvent extends NativeAudioDevicesInfo {
+  type: Constants.VoiceEventAudioDevicesUpdated;
+}

package/src/type/Call.ts

@@ -0,0 +1,102 @@
+import type { Constants } from '../constants';
+import type { CustomParameters, Uuid } from './common';
+import type { NativeErrorInfo } from './Error';
+import type { Call } from '../Call';
+import type { NativeCallMessageInfo } from './CallMessage';
+
+export interface NativeCallInfo {
+  uuid: Uuid;
+  customParameters?: CustomParameters;
+  from?: string;
+  [Constants.CallInfoInitialConnectedTimestamp]?: string;
+  isMuted?: boolean;
+  isOnHold?: boolean;
+  sid?: string;
+  state?: Call.State;
+  to?: string;
+}
+
+export interface NativeCallConnectedEvent {
+  type: Constants.CallEventConnected;
+  call: NativeCallInfo;
+}
+
+export interface NativeCallConnectFailureEvent {
+  type: Constants.CallEventConnectFailure;
+  call: NativeCallInfo;
+  error: NativeErrorInfo;
+}
+
+export interface NativeCallReconnectingEvent {
+  type: Constants.CallEventReconnecting;
+  call: NativeCallInfo;
+  error: NativeErrorInfo;
+}
+
+export interface NativeCallReconnectedEvent {
+  type: Constants.CallEventReconnected;
+  call: NativeCallInfo;
+}
+
+export interface NativeCallDisconnectedEvent {
+  type: Constants.CallEventDisconnected;
+  call: NativeCallInfo;
+  error?: NativeErrorInfo;
+}
+
+export interface NativeCallRingingEvent {
+  type: Constants.CallEventRinging;
+  call: NativeCallInfo;
+}
+
+export type NativeCallQualityWarnings = string[];
+
+export interface NativeCallQualityWarningsEvent {
+  type: Constants.CallEventQualityWarningsChanged;
+  call: NativeCallInfo;
+  [Constants.CallEventCurrentWarnings]: NativeCallQualityWarnings;
+  [Constants.CallEventPreviousWarnings]: NativeCallQualityWarnings;
+}
+
+export interface NativeCallMessageReceivedEvent {
+  type: Constants.CallEventMessageReceived;
+  call: NativeCallInfo;
+  [Constants.CallMessage]: NativeCallMessageInfo;
+}
+
+export type NativeCallEvent =
+  | NativeCallConnectedEvent
+  | NativeCallConnectFailureEvent
+  | NativeCallReconnectingEvent
+  | NativeCallReconnectedEvent
+  | NativeCallDisconnectedEvent
+  | NativeCallRingingEvent
+  | NativeCallQualityWarningsEvent
+  | NativeCallMessageReceivedEvent;
+
+export type NativeCallEventType =
+  | Constants.CallEventConnectFailure
+  | Constants.CallEventConnected
+  | Constants.CallEventDisconnected
+  | Constants.CallEventQualityWarningsChanged
+  | Constants.CallEventReconnected
+  | Constants.CallEventReconnecting
+  | Constants.CallEventRinging
+  | Constants.CallEventMessageReceived;
+
+export type NativeCallFeedbackIssue =
+  | Constants.CallFeedbackIssueAudioLatency
+  | Constants.CallFeedbackIssueChoppyAudio
+  | Constants.CallFeedbackIssueDroppedCall
+  | Constants.CallFeedbackIssueEcho
+  | Constants.CallFeedbackIssueNoisyCall
+  | Constants.CallFeedbackIssueNotReported
+  | Constants.CallFeedbackIssueOneWayAudio;
+
+export type NativeCallFeedbackScore =
+  | Constants.CallFeedbackScoreNotReported
+  | Constants.CallFeedbackScoreOne
+  | Constants.CallFeedbackScoreTwo
+  | Constants.CallFeedbackScoreThree
+  | Constants.CallFeedbackScoreFour
+  | Constants.CallFeedbackScoreFive;

package/src/type/CallInvite.ts

@@ -0,0 +1,59 @@
+import type { Constants } from '../constants';
+import type { CustomParameters, Uuid } from './common';
+import type { NativeErrorInfo } from './Error';
+import type { NativeCallMessageInfo } from './CallMessage';
+
+export interface BaseNativeCallInviteEvent {
+  callSid: string;
+}
+
+export interface NativeCallInviteInfo {
+  uuid: Uuid;
+  callSid: string;
+  customParameters?: CustomParameters;
+  from: string;
+  to: string;
+}
+
+export interface NativeCallInviteAcceptedEvent
+  extends BaseNativeCallInviteEvent {
+  type: Constants.CallInviteEventTypeValueAccepted;
+  callInvite: NativeCallInviteInfo;
+}
+
+export interface NativeCallInviteNotificationTappedEvent
+  extends BaseNativeCallInviteEvent {
+  type: Constants.CallInviteEventTypeValueNotificationTapped;
+}
+
+export interface NativeCallInviteRejectedEvent
+  extends BaseNativeCallInviteEvent {
+  type: Constants.CallInviteEventTypeValueRejected;
+  callInvite: NativeCallInviteInfo;
+}
+
+export interface NativeCallInviteCancelledEvent
+  extends BaseNativeCallInviteEvent {
+  type: Constants.CallInviteEventTypeValueCancelled;
+  cancelledCallInvite: NativeCancelledCallInviteInfo;
+  error?: NativeErrorInfo;
+}
+
+export interface NativeCancelledCallInviteInfo {
+  callSid: string;
+  from: string;
+  to: string;
+}
+
+export interface NativeCallInviteMessageReceivedEvent
+  extends BaseNativeCallInviteEvent {
+  type: Constants.CallEventMessageReceived;
+  [Constants.CallMessage]: NativeCallMessageInfo;
+}
+
+export type NativeCallInviteEvent =
+  | NativeCallInviteNotificationTappedEvent
+  | NativeCallInviteAcceptedEvent
+  | NativeCallInviteRejectedEvent
+  | NativeCallInviteCancelledEvent
+  | NativeCallInviteMessageReceivedEvent;

package/src/type/CallKit.ts

@@ -0,0 +1,61 @@
+/**
+ * @public
+ * CallKit related types.
+ */
+export namespace CallKit {
+  /**
+   * @public
+   * iOS CallKit configuration options.
+   */
+  export type ConfigurationOptions = {
+    /**
+     * Filename of a 80x80 PNG image that will show in the system call UI as the app icon.
+     */
+    callKitIconTemplateImageData: string;
+    /**
+     * Include call history in system recents (`true` by default).
+     *
+     * @remarks
+     * Only supported on iOS 11 and newer versions.
+     */
+    callKitIncludesCallsInRecents: boolean;
+    /**
+     * Maximum number of call groups (`2` by default).
+     */
+    callKitMaximumCallGroups: number;
+    /**
+     * Maximum number of calls per group (`5` by default).
+     */
+    callKitMaximumCallsPerCallGroup: number;
+    /**
+     * Filename of the incoming call ringing tone.
+     */
+    callKitRingtoneSound: string;
+    /**
+     * Supported handle types.
+     *
+     * @remarks
+     * See {@link CallKit.HandleType}.
+     */
+    callKitSupportedHandleTypes: HandleType[];
+  };
+
+  /**
+   * @public
+   * Enumeration of all supported handle types by iOS CallKit.
+   */
+  export enum HandleType {
+    /**
+     * Generic handle.
+     */
+    Generic = 0,
+    /**
+     * Phone number handle.
+     */
+    PhoneNumber = 1,
+    /**
+     * Email address handle.
+     */
+    EmailAddress = 2,
+  }
+}

package/src/type/CallMessage.ts

@@ -0,0 +1,31 @@
+import type { Constants } from '../constants';
+import type { NativeErrorInfo } from './Error';
+
+export interface NativeCallMessageInfo {
+  [Constants.CallMessageContent]: any;
+  [Constants.CallMessageContentType]: string;
+  [Constants.CallMessageMessageType]: string;
+  [Constants.VoiceEventSid]?: string;
+}
+
+export interface NativeCallMessageEventBase {
+  [Constants.VoiceEventSid]: string;
+}
+
+export interface NativeCallMessageFailureEvent
+  extends NativeCallMessageEventBase {
+  type: Constants.CallEventMessageFailure;
+  error: NativeErrorInfo;
+}
+
+export interface NativeCallMessageSentEvent extends NativeCallMessageEventBase {
+  type: Constants.CallEventMessageSent;
+}
+
+export type NativeCallMessageEvent =
+  | NativeCallMessageFailureEvent
+  | NativeCallMessageSentEvent;
+
+export type NativeCallMessageEventType =
+  | Constants.CallEventMessageFailure
+  | Constants.CallEventMessageSent;

package/src/type/Error.ts

@@ -0,0 +1,11 @@
+import type { Constants } from '../constants';
+
+export interface NativeErrorInfo {
+  code: number;
+  message: string;
+}
+
+export interface NativeErrorEvent {
+  type: Constants.VoiceEventError;
+  error: NativeErrorInfo;
+}

package/src/type/NativeModule.ts

@@ -0,0 +1,93 @@
+import type { NativeModulesStatic } from 'react-native';
+import type { CallInvite } from '../CallInvite';
+import type { NativeAudioDevicesInfo } from './AudioDevice';
+import type {
+  NativeCallInfo,
+  NativeCallFeedbackIssue,
+  NativeCallFeedbackScore,
+} from './Call';
+import type { NativeCallInviteInfo } from './CallInvite';
+import type { Uuid } from './common';
+import type { RTCStats } from './RTCStats';
+
+export interface TwilioVoiceReactNative extends NativeModulesStatic {
+  /**
+   * Native types.
+   *
+   * The following event related functions are required by the React Native
+   * bindings.
+   */
+  addListener: (eventType: string) => void;
+  removeListeners: (count: number) => void;
+
+  /**
+   * Call bindings.
+   */
+  call_disconnect(callUuid: Uuid): Promise<void>;
+  call_getStats(callUuid: Uuid): Promise<RTCStats.StatsReport>;
+  call_hold(callUuid: Uuid, hold: boolean): Promise<boolean>;
+  call_isOnHold(callUuid: Uuid): Promise<boolean>;
+  call_isMuted(callUuid: Uuid): Promise<boolean>;
+  call_mute(callUuid: Uuid, mute: boolean): Promise<boolean>;
+  call_postFeedback(
+    callUuid: Uuid,
+    score: NativeCallFeedbackScore,
+    issue: NativeCallFeedbackIssue
+  ): Promise<void>;
+  call_sendDigits(callUuid: Uuid, digits: string): Promise<void>;
+  call_sendMessage(
+    callUuid: Uuid,
+    content: string,
+    contentType: string,
+    messageType: string
+  ): Promise<string>;
+
+  /**
+   * Call Invite bindings.
+   */
+  callInvite_accept(
+    callInviteUuid: Uuid,
+    acceptOptions: CallInvite.AcceptOptions
+  ): Promise<NativeCallInfo>;
+  callInvite_isValid(callInviteUuid: Uuid): Promise<boolean>;
+  callInvite_reject(callInviteUuid: Uuid): Promise<void>;
+  callInvite_updateCallerHandle(
+    callInviteUuid: Uuid,
+    handle: string
+  ): Promise<void>;
+
+  /**
+   * Voice bindings.
+   */
+  voice_connect_android(
+    token: string,
+    twimlParams: Record<string, any>,
+    notificationDisplayName: string | undefined
+  ): Promise<NativeCallInfo>;
+  voice_connect_ios(
+    token: string,
+    twimlParams: Record<string, any>,
+    contactHandle: string
+  ): Promise<NativeCallInfo>;
+  voice_initializePushRegistry(): Promise<void>;
+  voice_setCallKitConfiguration(
+    configuration: Record<string, any>
+  ): Promise<void>;
+  voice_setIncomingCallContactHandleTemplate(template?: string): Promise<void>;
+  voice_getAudioDevices(): Promise<NativeAudioDevicesInfo>;
+  voice_getCalls(): Promise<NativeCallInfo[]>;
+  voice_getCallInvites(): Promise<NativeCallInviteInfo[]>;
+  voice_getDeviceToken(): Promise<string>;
+  voice_getVersion(): Promise<string>;
+  voice_handleEvent(remoteMessage: Record<string, string>): Promise<boolean>;
+  voice_register(accessToken: string): Promise<void>;
+  voice_selectAudioDevice(audioDeviceUuid: Uuid): Promise<void>;
+  voice_showNativeAvRoutePicker(): Promise<void>;
+  voice_unregister(accessToken: string): Promise<void>;
+
+  /**
+   * System/permissions related bindings.
+   */
+  system_isFullScreenNotificationEnabled(): Promise<boolean>;
+  system_requestFullScreenNotificationPermission(): Promise<void>;
+}

package/src/type/RTCStats.ts

@@ -0,0 +1,99 @@
+/**
+ * Types related to WebRTC stats.
+ *
+ * @public
+ */
+export namespace RTCStats {
+  export enum IceCandidatePairState {
+    STATE_FAILED = 'STATE_FAILED',
+    STATE_FROZEN = 'STATE_FROZEN',
+    STATE_IN_PROGRESS = 'STATE_IN_PROGRESS',
+    STATE_SUCCEEDED = 'STATE_SUCCEEDED',
+    STATE_WAITING = 'STATE_WAITING',
+  }
+
+  export interface IceCandidatePairStats {
+    activeCandidatePair: boolean;
+    availableIncomingBitrate: number;
+    availableOutgoingBitrate: number;
+    bytesReceived: number;
+    bytesSent: number;
+    consentRequestsReceived: number;
+    consentRequestsSent: number;
+    consentResponsesReceived: number;
+    consentResponsesSent: number;
+    currentRoundTripTime: number;
+    localCandidateId: string;
+    localCandidateIp: string;
+    nominated: boolean;
+    priority: number;
+    readable: boolean;
+    relayProtocol: string;
+    remoteCandidateId: string;
+    remoteCandidateIp: string;
+    requestsReceieved: number;
+    requestsSent: number;
+    responsesRecieved: number;
+    responsesSent: number;
+    retransmissionsReceived: number;
+    retransmissionsSent: number;
+    state: IceCandidatePairState;
+    totalRoundTripTime: number;
+    transportId: string;
+    writeable: boolean;
+  }
+
+  export interface IceCandidateStats {
+    candidateType: string;
+    deleted: boolean;
+    ip: string;
+    isRemote: boolean;
+    port: number;
+    priority: number;
+    protocol: string;
+    transportId: string;
+    url: string;
+  }
+
+  export interface BaseTrackStats {
+    codec: string;
+    packetsLost: number;
+    ssrc: string;
+    timestamp: number;
+    trackId: string;
+  }
+
+  export interface LocalTrackStats extends BaseTrackStats {
+    bytesSent: number;
+    packetsSent: number;
+    roundTripTime: number;
+  }
+
+  export interface LocalAudioTrackStats extends LocalTrackStats {
+    audioLevel: number;
+    jitter: number;
+  }
+
+  export interface RemoteTrackStats extends BaseTrackStats {
+    bytesRecieved: number;
+    packetsReceived: number;
+  }
+
+  export interface RemoteAudioTrackStats extends RemoteTrackStats {
+    audioLevel: number;
+    jitter: number;
+    mos: number;
+  }
+
+  /**
+   * WebRTC stats report. Contains diagnostics information about
+   * `RTCPeerConnection`s and summarizes data for an ongoing call.
+   */
+  export interface StatsReport {
+    iceCandidatePairStats: IceCandidatePairStats[];
+    iceCandidateStats: IceCandidateStats[];
+    localAudioTrackStats: LocalAudioTrackStats[];
+    peerConnectionId: string;
+    remoteAudioTrackStats: RemoteAudioTrackStats[];
+  }
+}

package/src/type/Voice.ts

@@ -0,0 +1,31 @@
+import type { Constants } from '../constants';
+import type { NativeAudioDevicesUpdatedEvent } from './AudioDevice';
+import type { NativeCallInviteInfo } from './CallInvite';
+import type { NativeErrorEvent } from './Error';
+
+export interface NativeRegisteredEvent {
+  type: Constants.VoiceEventRegistered;
+}
+
+export interface NativeUnregisteredEvent {
+  type: Constants.VoiceEventUnregistered;
+}
+
+export interface NativeCallInviteIncomingEvent {
+  [Constants.VoiceEventType]: Constants.VoiceEventTypeValueIncomingCallInvite;
+  callInvite: NativeCallInviteInfo;
+}
+
+export type NativeVoiceEvent =
+  | NativeAudioDevicesUpdatedEvent
+  | NativeCallInviteIncomingEvent
+  | NativeErrorEvent
+  | NativeRegisteredEvent
+  | NativeUnregisteredEvent;
+
+export type NativeVoiceEventType =
+  | Constants.VoiceEventAudioDevicesUpdated
+  | Constants.VoiceEventTypeValueIncomingCallInvite
+  | Constants.VoiceEventError
+  | Constants.VoiceEventRegistered
+  | Constants.VoiceEventUnregistered;

package/src/type/common.ts

@@ -0,0 +1,16 @@
+/**
+ * Call custom parameters. If custom parameters are present for a call, then
+ * it will have this typing.
+ *
+ * @remarks
+ *  - `Call`s will have a method to access custom parameters, see
+ *    {@link (Call:class).getCustomParameters}.
+ *  - `CallInvite`s will have a method to access custom parameters for the call
+ *    that is associated with the invite, see
+ *    {@link (CallInvite:class).getCustomParameters}.
+ *
+ * @public
+ */
+export type CustomParameters = Record<string, string>;
+
+export type Uuid = string;

package/twilio-voice-react-native.podspec

@@ -0,0 +1,22 @@
+require "json"
+
+package = JSON.parse(File.read(File.join(__dir__, "package.json")))
+
+Pod::Spec.new do |s|
+  s.name         = "twilio-voice-react-native"
+  s.version      = package["version"]
+  s.summary      = package["description"]
+  s.homepage     = package["homepage"]
+  s.license      = package["license"]
+  s.authors      = package["author"]
+
+  s.platforms    = { :ios => "11.0" }
+  s.source       = { :git => "https://github.com/mhuynh5757/twilio-voice-react-native.git", :tag => "#{s.version}" }
+
+  s.source_files = "ios/**/*.{h,m,mm}"
+
+  s.dependency "React-Core"
+  s.dependency "TwilioVoice", "6.12.1"
+  s.xcconfig  =  { 'VALID_ARCHS' => 'arm64 x86_64' }
+  s.pod_target_xcconfig   = { 'VALID_ARCHS[sdk=iphoneos*]' => 'arm64', 'VALID_ARCHS[sdk=iphonesimulator*]' => 'arm64 x86_64' }
+end