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

package/android/src/main/java/com/twiliovoicereactnative/AudioSwitchManager.java

@@ -0,0 +1,141 @@
+package com.twiliovoicereactnative;
+
+import android.content.Context;
+
+import com.twilio.audioswitch.AudioDevice;
+import com.twilio.audioswitch.AudioSwitch;
+
+import java.util.HashMap;
+import java.util.Map;
+import java.util.UUID;
+
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyEarpiece;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeySpeaker;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyBluetooth;
+
+import kotlin.Unit;
+
+/**
+ * AudioSwitchManager maintains a persistent AudioSwitch object and listens for audio
+ * device changes. Generates UUIDs per audio device when the AudioSwitch library updates available
+ * audio devices.
+ */
+class AudioSwitchManager {
+  /**
+   * The functional interface of a listener to be bound to the AudioSwitchManager.
+   */
+  @FunctionalInterface
+  interface AudioManagerListener {
+    void apply(
+      Map<String, AudioDevice> audioDevices,
+      String selectedAudioDeviceUuid,
+      AudioDevice selectedDevice
+    );
+  }
+
+  /**
+   * Audio device type mapping. Normalizes the class name into a string the JS layer expects.
+   */
+  public static final Map<String, String> AUDIO_DEVICE_TYPE = Map.of(
+    "Speakerphone", AudioDeviceKeySpeaker,
+    "BluetoothHeadset", AudioDeviceKeyBluetooth,
+    "WiredHeadset", AudioDeviceKeyEarpiece,
+    "Earpiece", AudioDeviceKeyEarpiece);
+
+  /**
+   * Map of UUIDs to all available AudioDevices. Kept up-to-date by the AudioSwitch.
+   */
+  private final HashMap<String, AudioDevice> audioDevices;
+  /**
+   * The AudioSwitch.
+   */
+  private final AudioSwitch audioSwitch;
+  /**
+   * A listener function that is invoked when the AudioSwitch updates.
+   */
+  private AudioManagerListener listener = null;
+  /**
+   * The UUID of the selected audio device.
+   */
+  private String selectedAudioDeviceUuid = null;
+
+  /**
+   * Constructor for the AudioSwitchManager class. Intended to be a singleton.
+   * @param context The Android application context
+   */
+  public AudioSwitchManager(Context context) {
+    audioDevices = new HashMap<>();
+    audioSwitch = new AudioSwitch(context);
+  }
+
+  public void start() {
+    audioSwitch.start((devices, selectedDevice) -> {
+
+      audioDevices.clear();
+      for (AudioDevice device : devices) {
+        String uuid = UUID.randomUUID().toString();
+        audioDevices.put(uuid, device);
+        if (device.equals(selectedDevice)) {
+          selectedAudioDeviceUuid = uuid;
+        }
+      }
+
+      if (this.listener != null) {
+        this.listener.apply(audioDevices, selectedAudioDeviceUuid, selectedDevice);
+      }
+      return Unit.INSTANCE;
+    });
+  }
+
+  public void stop() {
+    audioSwitch.stop();
+  }
+
+  /**
+   * Set a listener for the AudioSwitchManager. The listener function is invoked every time the
+   * AudioSwitch updates. Also invoked at the point the listener is set.
+   * @param listener A listener function.
+   * @return The singleton AudioSwitchManager.
+   */
+  public AudioSwitchManager setListener(AudioManagerListener listener) {
+    this.listener = listener;
+
+    this.listener.apply(audioDevices, selectedAudioDeviceUuid, getSelectedAudioDevice());
+
+    return this;
+  }
+
+  /**
+   * Get the AudioSwitch. Note that the AudioSwitchManager is a singleton, and only instantiates an
+   * AudioSwitch once in the construction of the AudioSwitchManager. Therefore, there should only be one
+   * AudioSwitch object and it is effectively a singleton.
+   * @return The AudioSwitch singleton
+   */
+  public AudioSwitch getAudioSwitch() {
+    return audioSwitch;
+  }
+
+  /**
+   * Get the audio devices.
+   * @return A map of UUIDs to available audio devices
+   */
+  public HashMap<String, AudioDevice> getAudioDevices() {
+    return audioDevices;
+  }
+
+  /**
+   * Get the UUID of the selected audio device.
+   * @return The UUID of the selected audio device.
+   */
+  public String getSelectedAudioDeviceUuid() {
+    return selectedAudioDeviceUuid;
+  }
+
+  /**
+   * Get the selected audio device.
+   * @return The selected audio device.
+   */
+  public AudioDevice getSelectedAudioDevice() {
+    return audioDevices.get(selectedAudioDeviceUuid);
+  }
+}

package/android/src/main/java/com/twiliovoicereactnative/CallListenerProxy.java

@@ -0,0 +1,186 @@
+package com.twiliovoicereactnative;
+
+import android.content.Context;
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.WritableMap;
+import com.twilio.voice.Call;
+import com.twilio.voice.CallException;
+
+import static com.twiliovoicereactnative.CommonConstants.CallEventConnected;
+import static com.twiliovoicereactnative.CommonConstants.CallEventDisconnected;
+import static com.twiliovoicereactnative.CommonConstants.CallEventReconnected;
+import static com.twiliovoicereactnative.CommonConstants.CallEventReconnecting;
+import static com.twiliovoicereactnative.CommonConstants.CallEventRinging;
+import static com.twiliovoicereactnative.CommonConstants.ScopeCall;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventType;
+import static com.twiliovoicereactnative.CommonConstants.VoiceErrorKeyError;
+import static com.twiliovoicereactnative.CommonConstants.CallEventCurrentWarnings;
+import static com.twiliovoicereactnative.CommonConstants.CallEventPreviousWarnings;
+import static com.twiliovoicereactnative.CommonConstants.CallEventConnectFailure;
+import static com.twiliovoicereactnative.CommonConstants.CallEventQualityWarningsChanged;
+import static com.twiliovoicereactnative.Constants.JS_EVENT_KEY_CALL_INFO;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getCallRecordDatabase;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getJSEventEmitter;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getAudioSwitchManager;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getMediaPlayerManager;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getVoiceServiceApi;
+import static com.twiliovoicereactnative.JSEventEmitter.constructJSMap;
+import static com.twiliovoicereactnative.ReactNativeArgumentsSerializer.*;
+
+import com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+import java.util.Date;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+
+class CallListenerProxy implements Call.Listener {
+  private static final SDKLog logger = new SDKLog(CallListenerProxy.class);
+  private final UUID uuid;
+  private final Context context;
+
+  public CallListenerProxy(UUID uuid, Context context) {
+    this.uuid = uuid;
+    this.context = context;
+  }
+
+  @Override
+  public void onConnectFailure(@NonNull Call call, @NonNull CallException callException) {
+    debug("onConnectFailure");
+
+    // stop sound and routing
+    getMediaPlayerManager().stop();
+    getAudioSwitchManager().getAudioSwitch().deactivate();
+
+    // find call record & remove
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().remove(new CallRecord(uuid)));
+
+    // take down notification
+    getVoiceServiceApi().cancelActiveCallNotification(callRecord);
+
+    // serialize and notify JS
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventConnectFailure),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord)),
+        new Pair<>(VoiceErrorKeyError, serializeVoiceException(callException))));
+  }
+
+  @Override
+  public void onRinging(@NonNull Call call) {
+    debug("onRinging");
+
+    // find call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(uuid)));
+    callRecord.setCall(call);
+
+    // create notification & sound
+    callRecord.setNotificationId(NotificationUtility.createNotificationIdentifier());
+    getAudioSwitchManager().getAudioSwitch().activate();
+    getMediaPlayerManager().play(MediaPlayerManager.SoundTable.RINGTONE);
+    getVoiceServiceApi().raiseOutgoingCallNotification(callRecord);
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventRinging),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord))));
+  }
+
+  @Override
+  public void onConnected(@NonNull Call call) {
+    debug("onConnected");
+
+    // find call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(uuid)));
+    callRecord.setCall(call);
+    callRecord.setTimestamp(new Date());
+    getMediaPlayerManager().stop();
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventConnected),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord))));
+  }
+
+  @Override
+  public void onReconnecting(@NonNull Call call, @NonNull CallException callException) {
+    debug("onReconnecting");
+
+    // find & update call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(uuid)));
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventReconnecting),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord)),
+        new Pair<>(VoiceErrorKeyError, serializeVoiceException(callException))));
+  }
+
+  @Override
+  public void onReconnected(@NonNull Call call) {
+    debug("onReconnected");
+
+    // find & update call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(uuid)));
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventReconnected),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord))));
+  }
+
+  @Override
+  public void onDisconnected(@NonNull Call call, @Nullable CallException callException) {
+    debug("onDisconnected");
+
+    // find & remove call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().remove(new CallRecord(uuid)));
+
+    // stop audio & cancel notification
+    getMediaPlayerManager().stop();
+    getMediaPlayerManager().play(MediaPlayerManager.SoundTable.DISCONNECT);
+    getAudioSwitchManager().getAudioSwitch().deactivate();
+    getVoiceServiceApi().cancelActiveCallNotification(callRecord);
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventDisconnected),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord)),
+        new Pair<>(VoiceErrorKeyError, serializeVoiceException(callException))));
+  }
+
+  @Override
+  public void onCallQualityWarningsChanged(@NonNull Call call,
+                                           @NonNull Set<Call.CallQualityWarning> currentWarnings,
+                                           @NonNull Set<Call.CallQualityWarning> previousWarnings) {
+    debug("onCallQualityWarningsChanged");
+
+    // find call record
+    CallRecord callRecord = Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(uuid)));
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventQualityWarningsChanged),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializeCall(callRecord)),
+        new Pair<>(CallEventCurrentWarnings, serializeCallQualityWarnings(currentWarnings)),
+        new Pair<>(CallEventPreviousWarnings, serializeCallQualityWarnings(previousWarnings))));
+  }
+
+  private void sendJSEvent(@NonNull WritableMap event) {
+    getJSEventEmitter().sendEvent(ScopeCall, event);
+  }
+
+  private void debug(final String message) {
+    logger.debug(String.format("%s UUID:%s", message, uuid.toString()));
+  }
+}

package/android/src/main/java/com/twiliovoicereactnative/CallMessageListenerProxy.java

@@ -0,0 +1,103 @@
+package com.twiliovoicereactnative;
+
+import static com.twiliovoicereactnative.CommonConstants.CallEventMessageFailure;
+import static com.twiliovoicereactnative.CommonConstants.CallEventMessageReceived;
+import static com.twiliovoicereactnative.CommonConstants.CallEventMessageSent;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteEventKeyCallSid;
+import static com.twiliovoicereactnative.CommonConstants.ScopeCall;
+import static com.twiliovoicereactnative.CommonConstants.ScopeCallInvite;
+import static com.twiliovoicereactnative.CommonConstants.ScopeCallMessage;
+import static com.twiliovoicereactnative.CommonConstants.VoiceErrorKeyError;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventSid;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventType;
+import static com.twiliovoicereactnative.CommonConstants.JSEventKeyCallMessageInfo;
+import static com.twiliovoicereactnative.Constants.JS_EVENT_KEY_CALL_INFO;
+import static com.twiliovoicereactnative.JSEventEmitter.constructJSMap;
+import static com.twiliovoicereactnative.ReactNativeArgumentsSerializer.serializeCall;
+import static com.twiliovoicereactnative.ReactNativeArgumentsSerializer.serializeCallMessage;
+import static com.twiliovoicereactnative.ReactNativeArgumentsSerializer.serializeVoiceException;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getCallRecordDatabase;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getJSEventEmitter;
+
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableMap;
+import com.twilio.voice.Call;
+import com.twilio.voice.CallMessage;
+import com.twilio.voice.VoiceException;
+
+import com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+import java.util.Objects;
+
+
+public class CallMessageListenerProxy implements Call.CallMessageListener {
+  private static final SDKLog logger = new SDKLog(CallMessageListenerProxy.class);
+
+  @Override
+  public void onMessageFailure(String callSid, String voiceEventSID, VoiceException voiceException) {
+    logger.debug("onMessageFailure");
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventMessageFailure),
+        new Pair<>(VoiceEventSid, voiceEventSID),
+        new Pair<>(VoiceErrorKeyError, serializeVoiceException(voiceException))
+      )
+    );
+  }
+
+  @Override
+  public void onMessageSent(String callSid, String voiceEventSID) {
+    logger.debug("onMessageSent");
+
+    // notify JS layer
+    sendJSEvent(
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventMessageSent),
+        new Pair<>(VoiceEventSid, voiceEventSID)
+    ));
+  }
+
+  @Override
+  public void onMessageReceived(String callSid, CallMessage callMessage) {
+    logger.debug("onMessageReceived");
+
+    //final call record
+    final CallRecord callRecord =
+      Objects.requireNonNull(getCallRecordDatabase().get(new CallRecord(callSid)));
+
+    // notify JS layer ScopeCallInvite or ScopeCall
+    final String event =
+      CallRecord.CallInviteState.ACTIVE == callRecord.getCallInviteState()
+        ? ScopeCallInvite
+        : ScopeCall;
+    final WritableMap serializedCallMap =
+      CallRecord.CallInviteState.ACTIVE == callRecord.getCallInviteState()
+        ? null
+        : serializeCall(callRecord);
+    final @Nullable String optionalCallSid =
+      CallRecord.CallInviteState.ACTIVE == callRecord.getCallInviteState()
+        ? callSid
+        : null;
+
+    getJSEventEmitter().sendEvent(
+      event,
+      constructJSMap(
+        new Pair<>(VoiceEventType, CallEventMessageReceived),
+        new Pair<>(JS_EVENT_KEY_CALL_INFO, serializedCallMap),
+        new Pair<>(JSEventKeyCallMessageInfo, serializeCallMessage(callMessage)),
+        new Pair<>(CallInviteEventKeyCallSid, optionalCallSid)
+      )
+    );
+  }
+
+  private void sendJSEvent(@NonNull WritableMap event) {
+    getJSEventEmitter().sendEvent(ScopeCallMessage, event);
+  }
+}

package/android/src/main/java/com/twiliovoicereactnative/CallRecordDatabase.java

@@ -0,0 +1,183 @@
+package com.twiliovoicereactnative;
+
+import static com.twiliovoicereactnative.CallRecordDatabase.CallRecord.CallInviteState.ACTIVE;
+import static com.twiliovoicereactnative.CallRecordDatabase.CallRecord.CallInviteState.NONE;
+import static com.twiliovoicereactnative.CallRecordDatabase.CallRecord.CallInviteState.USED;
+
+import java.util.Collection;
+import java.util.Date;
+import java.util.List;
+import java.util.UUID;
+import java.util.Vector;
+import java.util.Map;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.bridge.Promise;
+import com.twilio.voice.Call;
+import com.twilio.voice.CallException;
+import com.twilio.voice.CallInvite;
+import com.twilio.voice.CancelledCallInvite;
+
+class CallRecordDatabase  {
+  public static class CallRecord {
+    public enum CallInviteState { NONE, ACTIVE, USED }
+    public enum Direction { INCOMING, OUTGOING }
+    private final UUID uuid;
+    private String callSid = null;
+    private Date timestamp = null;
+    private int notificationId = -1;
+    private Call voiceCall = null;
+    private String callRecipient = "";
+    private CallInvite callInvite = null;
+    private CallInviteState callInviteState = NONE;
+    private CancelledCallInvite cancelledCallInvite = null;
+    private Promise callAcceptedPromise = null;
+    private Promise callRejectedPromise = null;
+    private CallException callException = null;
+    private Map<String, String> customParameters = null;
+    private String notificationDisplayName = null;
+    private Direction direction = Direction.INCOMING;
+    public CallRecord(final UUID uuid) {
+      this.uuid = uuid;
+    }
+    public CallRecord(final String callSid) {
+      this.uuid = null;
+      this.callSid = callSid;
+    }
+    public CallRecord(final UUID uuid, final CallInvite callInvite) {
+      this.uuid = uuid;
+      this.callSid = callInvite.getCallSid();
+      this.callInvite = callInvite;
+      this.callInviteState = ACTIVE;
+    }
+    public CallRecord(
+      final UUID uuid,
+      final Call call,
+      final String recipient,
+      final Map<String, String> customParameters,
+      final Direction direction,
+      final String notificationDisplayName
+    ) {
+      this.uuid = uuid;
+      this.callSid = call.getSid();
+      this.voiceCall = call;
+      this.callRecipient = recipient;
+      this.customParameters = customParameters;
+      this.direction = direction;
+      this.notificationDisplayName = notificationDisplayName;
+    }
+    public final UUID getUuid() {
+      return uuid;
+    }
+    public String getCallSid() {
+      return callSid;
+    }
+    public int getNotificationId() {
+      return notificationId;
+    }
+    public Date getTimestamp() {
+      return timestamp;
+    }
+    public Call getVoiceCall() {
+      return this.voiceCall;
+    }
+    public final Map<String, String> getCustomParameters() {
+      if (this.direction == Direction.INCOMING) {
+        return this.callInvite.getCustomParameters();
+      }
+      return this.customParameters;
+    }
+    public final String getNotificationDisplayName() {
+      return this.notificationDisplayName;
+    }
+    public final Direction getDirection() {
+      return this.direction;
+    }
+    public CallInvite getCallInvite() {
+      return this.callInvite;
+    }
+    public CallInviteState getCallInviteState() {
+      return this.callInviteState;
+    }
+    public CancelledCallInvite getCancelledCallInvite() {
+      return this.cancelledCallInvite;
+    }
+    public Promise getCallAcceptedPromise() {
+      return this.callAcceptedPromise;
+    }
+    public Promise getCallRejectedPromise() {
+      return this.callRejectedPromise;
+    }
+    public CallException getCallException() {
+      return this.callException;
+    }
+    public String getCallRecipient() { return this.callRecipient; }
+    public void setNotificationId(int notificationId) {
+      this.notificationId = notificationId;
+    }
+    public void setTimestamp(Date timestamp) {
+      this.timestamp = timestamp;
+    }
+    public void setCall(@NonNull Call voiceCall) {
+      this.callSid = voiceCall.getSid();
+      this.voiceCall = voiceCall;
+    }
+    public void setCallInviteUsedState() {
+      this.callInviteState = (this.callInviteState == ACTIVE) ? USED : this.callInviteState;
+    }
+    public void setCancelledCallInvite(@NonNull CancelledCallInvite cancelledCallInvite) {
+      this.callSid = cancelledCallInvite.getCallSid();
+      this.cancelledCallInvite = cancelledCallInvite;
+      this.callInvite = null;
+      this.callInviteState = NONE;
+    }
+    public void setCallAcceptedPromise(@NonNull Promise callAcceptedPromise) {
+      this.callAcceptedPromise = callAcceptedPromise;
+    }
+    public void setCallRejectedPromise(@NonNull Promise callRejectedPromise) {
+      this.callRejectedPromise = callRejectedPromise;
+    }
+    public void setCallException(CallException callException) {
+      this.callException = callException;
+    }
+    @Override
+    public boolean equals(Object obj) {
+      return (obj instanceof CallRecord) && comparator(this, (CallRecord)obj);
+    }
+  }
+  private final List<CallRecord> callRecordList = new Vector<>();
+
+  public void add(final CallRecord callRecord) {
+    callRecordList.add(callRecord);
+  }
+  public void clear() {
+    callRecordList.clear();
+  }
+
+  public CallRecord get(final CallRecord record) {
+    try {
+      return callRecordList.get(callRecordList.indexOf(record));
+    } catch (IndexOutOfBoundsException e) {
+      return null;
+    }
+  }
+  public CallRecord remove(final CallRecord record) {
+    try {
+      return callRecordList.remove(callRecordList.indexOf(record));
+    } catch (IndexOutOfBoundsException e) {
+      return null;
+    }
+  }
+  public Collection<CallRecord> getCollection() {
+    return callRecordList;
+  }
+  private static boolean comparator(@NonNull final CallRecord lhs, @NonNull final CallRecord rhs) {
+    if (null != lhs.uuid && null != rhs.uuid) {
+      return lhs.uuid.equals(rhs.uuid);
+    } else if (null != lhs.callSid && null != rhs.callSid) {
+      return lhs.callSid.equals(rhs.callSid);
+    }
+    return false;
+  }
+}