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

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

@@ -0,0 +1,363 @@
+package com.twiliovoicereactnative;
+
+import java.security.SecureRandom;
+
+import java.util.Map;
+import java.util.Objects;
+
+import android.annotation.SuppressLint;
+import android.app.Notification;
+import android.app.PendingIntent;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.Color;
+import android.media.AudioAttributes;
+import android.net.Uri;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.NotificationChannelCompat;
+import androidx.core.app.NotificationChannelGroupCompat;
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.NotificationManagerCompat;
+import androidx.core.app.Person;
+
+import com.twilio.voice.CallInvite;
+
+import static com.twiliovoicereactnative.ConfigurationProperties.isFullScreenNotificationEnabled;
+import static com.twiliovoicereactnative.Constants.VOICE_CHANNEL_DEFAULT_IMPORTANCE;
+import static com.twiliovoicereactnative.Constants.VOICE_CHANNEL_HIGH_IMPORTANCE;
+import static com.twiliovoicereactnative.Constants.VOICE_CHANNEL_LOW_IMPORTANCE;
+import static com.twiliovoicereactnative.VoiceService.constructMessage;
+
+import com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+class NotificationUtility {
+  private static final SecureRandom secureRandom = new SecureRandom();
+
+  private static class NotificationResource {
+    enum Type { INCOMING, OUTGOING, ANSWERED }
+
+    private final Type type;
+    private final Context ctx;
+    private final CallRecord callRecord;
+
+    public NotificationResource(Context context, Type type, CallRecord callRecord) {
+      this.ctx = context;
+      this.type = type;
+      this.callRecord = callRecord;
+    }
+
+    private int getSmallIconId() {
+      switch (this.type) {
+        case INCOMING:
+          return this.getDrawableResourceId("incoming_call_small_icon");
+        case OUTGOING:
+          return this.getDrawableResourceId("outgoing_call_small_icon");
+        default:
+          return this.getDrawableResourceId("answered_call_small_icon");
+      }
+    }
+
+    private String getContentText() {
+      switch (this.type) {
+        case INCOMING:
+          return this.ctx.getString(this.getTextResourceId("incoming_call_caller_name_text"));
+        case OUTGOING:
+          return this.ctx.getString(this.getTextResourceId("outgoing_call_caller_name_text"));
+        default:
+          return this.ctx.getString(this.getTextResourceId("answered_call_caller_name_text"));
+      }
+    }
+
+    public String getName() {
+      if (this.callRecord.getDirection() == CallRecord.Direction.INCOMING) {
+        final String template = ConfigurationProperties.getIncomingCallContactHandleTemplate(ctx);
+        if (template != null) {
+          final String processedTemplate =
+            templateDisplayName(template, this.callRecord.getCustomParameters());
+          if (!processedTemplate.isEmpty()) {
+            return processedTemplate;
+          }
+        }
+
+        final CallInvite callInvite = this.callRecord.getCallInvite();
+        final String from = null != callInvite ? getDisplayName(callInvite) : "";
+        return this.getContentText().replaceAll("\\$\\{from\\}", from);
+      }
+
+      // this.callRecord.Direction == CallRecord.Direction.OUTGOING
+      final String notificationDisplayName = this.callRecord.getNotificationDisplayName();
+      if (notificationDisplayName != null && !notificationDisplayName.isEmpty()) {
+        return notificationDisplayName;
+      }
+
+      final String to = this.callRecord.getCallRecipient();
+      return this.getContentText().replaceAll("\\$\\{to\\}", to);
+    }
+
+    @SuppressLint("DiscouragedApi")
+    private int getDrawableResourceId(String id) {
+      return ctx.getResources().getIdentifier(id, "drawable", ctx.getPackageName());
+    }
+
+    @SuppressLint("DiscouragedApi")
+    private int getTextResourceId(String id) {
+      return ctx.getResources().getIdentifier(id, "string", ctx.getPackageName());
+    }
+
+    private static String getDisplayName(@NonNull CallInvite callInvite) {
+      final String title = callInvite.getFrom();
+      if (title.startsWith("client:")) {
+        return title.replaceFirst("client:", "");
+      }
+      return title;
+    }
+
+    private static String templateDisplayName(final String template, final Map<String, String> twimlParams) {
+      String processedTemplate = template;
+
+      for (Map.Entry<String, String> e : twimlParams.entrySet()) {
+        String paramKey = e.getKey();
+        String paramValue = e.getValue();
+        processedTemplate = processedTemplate.replaceAll(
+          String.format("\\$\\{%s\\}", paramKey),
+          paramValue);
+      }
+
+      return processedTemplate;
+    }
+  }
+
+  public static int createNotificationIdentifier() {
+    return (secureRandom.nextInt() & 0x7FFFFFFF) + 1; // prevent 0 as an id
+  }
+
+  public static Notification createIncomingCallNotification(@NonNull Context context,
+                                                            @NonNull final CallRecord callRecord,
+                                                            @NonNull final String channelImportance) {
+    final NotificationResource notificationResource = new NotificationResource(
+      context,
+      NotificationResource.Type.INCOMING,
+      callRecord);
+
+    final Person incomingCaller = new Person.Builder()
+      .setName(notificationResource.getName())
+      .build();
+
+    Intent foregroundIntent = constructMessage(
+      context,
+      Constants.ACTION_FOREGROUND_AND_DEPRIORITIZE_INCOMING_CALL_NOTIFICATION,
+      Objects.requireNonNull(VoiceApplicationProxy.getMainActivityClass()),
+      callRecord.getUuid());
+    PendingIntent piForegroundIntent = constructPendingIntentForActivity(context, foregroundIntent);
+
+    Intent rejectIntent = constructMessage(
+      context,
+      Constants.ACTION_REJECT_CALL,
+      VoiceService.class,
+      callRecord.getUuid());
+    PendingIntent piRejectIntent = constructPendingIntentForService(context, rejectIntent);
+
+    Intent acceptIntent = constructMessage(
+      context,
+      Constants.ACTION_ACCEPT_CALL,
+      Objects.requireNonNull(VoiceApplicationProxy.getMainActivityClass()),
+      callRecord.getUuid());
+    PendingIntent piAcceptIntent = constructPendingIntentForActivity(context, acceptIntent);
+
+    NotificationCompat.Builder builder = constructNotificationBuilder(context, channelImportance)
+      .setSmallIcon(notificationResource.getSmallIconId())
+      .setCategory(Notification.CATEGORY_CALL)
+      .setAutoCancel(true)
+      .setContentIntent(piForegroundIntent)
+      .addPerson(incomingCaller)
+      .setStyle(NotificationCompat.CallStyle.forIncomingCall(
+        incomingCaller, piRejectIntent, piAcceptIntent));
+    if (isFullscreenIntentEnabled(context)) {
+      builder.setFullScreenIntent(piForegroundIntent, true);
+    }
+    return builder.build();
+  }
+
+  public static Notification createCallAnsweredNotificationWithLowImportance(@NonNull Context context,
+                                                                             @NonNull final CallRecord callRecord) {
+    final NotificationResource notificationResource = new NotificationResource(
+      context,
+      NotificationResource.Type.ANSWERED,
+      callRecord);
+
+    final Person activeCaller = new Person.Builder()
+      .setName(notificationResource.getName())
+      .build();
+
+    Intent foregroundIntent = constructMessage(
+      context,
+      Constants.ACTION_PUSH_APP_TO_FOREGROUND,
+      Objects.requireNonNull(VoiceApplicationProxy.getMainActivityClass()),
+      callRecord.getUuid());
+    PendingIntent piForegroundIntent = constructPendingIntentForActivity(context, foregroundIntent);
+
+    Intent endCallIntent = constructMessage(
+      context,
+      Constants.ACTION_CALL_DISCONNECT,
+      VoiceService.class,
+      callRecord.getUuid());
+    PendingIntent piEndCallIntent = constructPendingIntentForService(context, endCallIntent);
+
+    NotificationCompat.Builder builder = constructNotificationBuilder(context, Constants.VOICE_CHANNEL_LOW_IMPORTANCE)
+      .setSmallIcon(notificationResource.getSmallIconId())
+      .setCategory(Notification.CATEGORY_CALL)
+      .setAutoCancel(false)
+      .setContentIntent(piForegroundIntent)
+      .setOngoing(true)
+      .addPerson(activeCaller)
+      .setStyle(NotificationCompat.CallStyle.forOngoingCall(activeCaller, piEndCallIntent));
+    if (isFullscreenIntentEnabled(context)) {
+      builder.setFullScreenIntent(piForegroundIntent, true);
+    }
+    return builder.build();
+  }
+
+  public static Notification createOutgoingCallNotificationWithLowImportance(@NonNull Context context,
+                                                                             @NonNull final CallRecord callRecord) {
+    final NotificationResource notificationResource = new NotificationResource(
+      context,
+      NotificationResource.Type.OUTGOING,
+      callRecord);
+
+    final Person activeCaller = new Person.Builder()
+      .setName(notificationResource.getName())
+      .build();
+
+    Intent foregroundIntent = constructMessage(
+      context,
+      Constants.ACTION_PUSH_APP_TO_FOREGROUND,
+      Objects.requireNonNull(VoiceApplicationProxy.getMainActivityClass()),
+      callRecord.getUuid());
+    PendingIntent piForegroundIntent = constructPendingIntentForActivity(context, foregroundIntent);
+
+    Intent endCallIntent = constructMessage(
+      context,
+      Constants.ACTION_CALL_DISCONNECT,
+      VoiceService.class,
+      callRecord.getUuid());
+    PendingIntent piEndCallIntent = constructPendingIntentForService(context, endCallIntent);
+
+    NotificationCompat.Builder builder = constructNotificationBuilder(context, Constants.VOICE_CHANNEL_LOW_IMPORTANCE)
+      .setSmallIcon(notificationResource.getSmallIconId())
+      .setCategory(Notification.CATEGORY_CALL)
+      .setAutoCancel(false)
+      .setContentIntent(piForegroundIntent)
+      .setOngoing(true)
+      .addPerson(activeCaller)
+      .setStyle(NotificationCompat.CallStyle.forOngoingCall(activeCaller, piEndCallIntent));
+    if (isFullscreenIntentEnabled(context)) {
+      builder.setFullScreenIntent(piForegroundIntent, true);
+    }
+    return builder.build();
+  }
+
+  public static void createNotificationChannels(@NonNull Context context) {
+    NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
+    notificationManager.createNotificationChannelGroup(
+      new NotificationChannelGroupCompat.Builder(Constants.VOICE_CHANNEL_GROUP)
+        .setName("Twilio Voice").build());
+
+    for (String channelId:
+      new String[]{
+        VOICE_CHANNEL_HIGH_IMPORTANCE,
+        VOICE_CHANNEL_DEFAULT_IMPORTANCE,
+        VOICE_CHANNEL_LOW_IMPORTANCE}) {
+      notificationManager.createNotificationChannel(
+        createNotificationChannel(context, channelId));
+    }
+  }
+
+  public static void destroyNotificationChannels(@NonNull Context context) {
+    NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
+    notificationManager.deleteNotificationChannelGroup(Constants.VOICE_CHANNEL_GROUP);
+  }
+
+  public static boolean isFullscreenIntentEnabled(Context context) {
+    return isFullScreenNotificationEnabled(context) &&
+      NotificationManagerCompat.from(context).canUseFullScreenIntent();
+  }
+
+  private static NotificationChannelCompat createNotificationChannel(@NonNull Context context,
+                                                                     @NonNull final String voiceChannelId) {
+    final int notificationImportance = getChannelImportance(voiceChannelId);
+    NotificationChannelCompat.Builder voiceChannelBuilder =
+      new NotificationChannelCompat.Builder(voiceChannelId, notificationImportance)
+        .setName("Primary Voice Channel")
+        .setLightColor(Color.GREEN)
+        .setGroup(Constants.VOICE_CHANNEL_GROUP);
+    // low-importance notifications don't have sound
+    if (!Constants.VOICE_CHANNEL_LOW_IMPORTANCE.equals(voiceChannelId)) {
+      // set audio attributes for channel
+      Uri soundUri = provideResourceSilent_wav(context);
+      AudioAttributes audioAttributes = new AudioAttributes.Builder()
+        .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+        .setUsage(AudioAttributes.USAGE_NOTIFICATION)
+        .build();
+      voiceChannelBuilder.setSound(soundUri, audioAttributes);
+    }
+    return voiceChannelBuilder.build();
+  }
+
+  private static int getChannelImportance(@NonNull final String voiceChannel) {
+    final Map<String, Integer> importanceMapping = Map.of(
+      Constants.VOICE_CHANNEL_HIGH_IMPORTANCE, NotificationManagerCompat.IMPORTANCE_HIGH,
+      Constants.VOICE_CHANNEL_DEFAULT_IMPORTANCE, NotificationManagerCompat.IMPORTANCE_DEFAULT,
+      Constants.VOICE_CHANNEL_LOW_IMPORTANCE, NotificationManagerCompat.IMPORTANCE_LOW);
+    return Objects.requireNonNull(importanceMapping.get(voiceChannel));
+  }
+
+  private static String getChannel(@NonNull Context context, @NonNull final String voiceChannelId) {
+    // construct channel if it has not been created
+    NotificationManagerCompat notificationManager = NotificationManagerCompat.from(context);
+
+    if (null == notificationManager.getNotificationChannel(voiceChannelId)) {
+      createNotificationChannels(context);
+    }
+    return voiceChannelId;
+  }
+
+  private static PendingIntent constructPendingIntentForActivity(@NonNull Context context,
+                                                                 @NonNull final Intent intent) {
+    return PendingIntent.getActivity(
+      context.getApplicationContext(),
+      0,
+      intent,
+      PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+  }
+
+  private static PendingIntent constructPendingIntentForService(@NonNull Context context,
+                                                                @NonNull final Intent intent) {
+    return PendingIntent.getService(
+      context.getApplicationContext(),
+      0,
+      intent,
+      PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE);
+  }
+
+  private static NotificationCompat.Builder constructNotificationBuilder(
+    @NonNull Context context,
+    @NonNull final String channelImportance) {
+    return new NotificationCompat.Builder(context,
+        getChannel(context.getApplicationContext(),
+          channelImportance));
+  }
+
+  static Uri provideResourceSilent_wav(@NonNull Context context) {
+    return provideResource(context, R.raw.silent);
+  }
+
+  private static Uri provideResource(@NonNull Context context, int id) {
+    return (new Uri.Builder()
+      .scheme(ContentResolver.SCHEME_ANDROID_RESOURCE)
+      .authority(context.getResources().getResourcePackageName(id))
+      .appendPath(String.valueOf(id))
+    ).build();
+  }
+}

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

@@ -0,0 +1,276 @@
+package com.twiliovoicereactnative;
+
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyAudioDevices;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyName;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeySelectedDevice;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyType;
+import static com.twiliovoicereactnative.CommonConstants.AudioDeviceKeyUuid;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoFrom;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoInitialConnectedTimestamp;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoSid;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoTo;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoUuid;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoState;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoIsMuted;
+import static com.twiliovoicereactnative.CommonConstants.CallInfoIsOnHold;
+import static com.twiliovoicereactnative.CommonConstants.CallMessageContent;
+import static com.twiliovoicereactnative.CommonConstants.CallMessageContentType;
+import static com.twiliovoicereactnative.CommonConstants.CallMessageMessageType;
+import static com.twiliovoicereactnative.CommonConstants.ScopeVoice;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventError;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventSid;
+import static com.twiliovoicereactnative.CommonConstants.CallStateConnected;
+import static com.twiliovoicereactnative.CommonConstants.CallStateConnecting;
+import static com.twiliovoicereactnative.CommonConstants.CallStateDisconnected;
+import static com.twiliovoicereactnative.CommonConstants.CallStateReconnecting;
+import static com.twiliovoicereactnative.CommonConstants.CallStateRinging;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteInfoCallSid;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteInfoCustomParameters;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteInfoFrom;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteInfoTo;
+import static com.twiliovoicereactnative.CommonConstants.CallInviteInfoUuid;
+import static com.twiliovoicereactnative.CommonConstants.CancelledCallInviteInfoCallSid;
+import static com.twiliovoicereactnative.CommonConstants.CancelledCallInviteInfoFrom;
+import static com.twiliovoicereactnative.CommonConstants.CancelledCallInviteInfoTo;
+import static com.twiliovoicereactnative.CommonConstants.VoiceErrorKeyCode;
+import static com.twiliovoicereactnative.CommonConstants.VoiceErrorKeyMessage;
+import static com.twiliovoicereactnative.CommonConstants.VoiceEventType;
+import static com.twiliovoicereactnative.JSEventEmitter.constructJSMap;
+
+import java.text.SimpleDateFormat;
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.twilio.voice.CallMessage;
+import com.twilio.voice.CancelledCallInvite;
+import com.twilio.voice.VoiceException;
+import com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.twilio.audioswitch.AudioDevice;
+import com.twilio.voice.Call;
+import com.twilio.voice.CallInvite;
+
+import java.util.Date;
+import java.util.Locale;
+import java.util.Map;
+import java.util.Map.Entry;
+import java.util.Objects;
+import java.util.Set;
+import java.util.UUID;
+
+/**
+ * This class provides static helper functions that serializes native objects into
+ * React Native (RN) bridge objects emit-able to the JS layer.
+ */
+class ReactNativeArgumentsSerializer {
+  private static final SDKLog logger = new SDKLog(ReactNativeArgumentsSerializer.class);
+  /**
+   * Serializes the custom parameters of a CallInvite.
+   * @param callInvite A CallInvite object
+   * @return Serialized CallInvite custom parameters
+   */
+  public static WritableMap serializeCallInviteCustomParameters(CallInvite callInvite) {
+    if (null != callInvite) {
+      WritableMap customParameters = Arguments.createMap();
+      for (Entry<String, String> entry : callInvite.getCustomParameters().entrySet()) {
+        String customParameterKey = entry.getKey();
+        String customParameterValue = entry.getValue();
+
+        customParameters.putString(customParameterKey, customParameterValue);
+      }
+      return customParameters;
+    }
+    return null;
+  }
+
+  /**
+   * Serializes a CallInvite.
+   * @param CallRecord the callRecord
+   * @return A serialized CallInvite
+   */
+  public static WritableMap serializeCallInvite(@NonNull final CallRecord callRecord) {
+    // validate input
+    final UUID uuid = Objects.requireNonNull(callRecord.getUuid());
+    final CallInvite callInvite = Objects.requireNonNull(callRecord.getCallInvite());
+
+    // serialize
+    return constructJSMap(
+      new Pair<>(CallInviteInfoUuid, uuid.toString()),
+      new Pair<>(CallInviteInfoCallSid, callInvite.getCallSid()),
+      new Pair<>(CallInviteInfoFrom, callInvite.getFrom()),
+      new Pair<>(CallInviteInfoTo, callInvite.getTo()),
+      new Pair<>(CallInviteInfoCustomParameters, serializeCallInviteCustomParameters(callInvite)));
+  }
+
+  /**
+   * Serializes a CancelledCallInvite.
+   * @param CallRecord The callRecord
+   * @return A serialized CancelledCallInvite
+   */
+  public static WritableMap serializeCancelledCallInvite(@NonNull final CallRecord callRecord) {
+    // validate input
+    final CancelledCallInvite callInvite = Objects.requireNonNull(callRecord.getCancelledCallInvite());
+
+    // serialize
+    return constructJSMap(
+      new Pair<>(CancelledCallInviteInfoCallSid, callInvite.getCallSid()),
+      new Pair<>(CancelledCallInviteInfoFrom, callInvite.getFrom()),
+      new Pair<>(CancelledCallInviteInfoTo, callInvite.getTo()));
+  }
+
+  /**
+   * Convert the call state enumeration to a string that the JS layer expects.
+   * @param state The call state
+   * @return A string representing the state
+   */
+  public static String callStateToString(Call.State state) {
+    switch (state) {
+      case CONNECTED:
+        return CallStateConnected;
+      case CONNECTING:
+        return CallStateConnecting;
+      case DISCONNECTED:
+        return CallStateDisconnected;
+      case RECONNECTING:
+        return CallStateReconnecting;
+      case RINGING:
+        return CallStateRinging;
+      default:
+        logger.warning("Unknown call state: " + state);
+        return CallStateConnecting;
+    }
+  }
+
+  /**
+   * Serializes a Call.
+   * @param CallRecord the call record
+   * @return A serialized Call
+   */
+  public static WritableMap serializeCall(@NonNull final CallRecord callRecord) {
+    // validate input
+    Objects.requireNonNull(callRecord.getUuid());
+    Objects.requireNonNull(callRecord.getVoiceCall());
+
+    // serialize
+    WritableMap callInfo = constructJSMap(
+      new Pair<>(CallInfoUuid, callRecord.getUuid().toString()),
+      new Pair<>(CallInfoSid, callRecord.getVoiceCall().getSid()),
+      new Pair<>(CallInfoFrom, callRecord.getVoiceCall().getFrom()),
+      new Pair<>(CallInfoTo, callRecord.getVoiceCall().getTo()),
+      new Pair<>(CallInfoState, callStateToString(callRecord.getVoiceCall().getState())),
+      new Pair<>(CallInfoIsMuted, callRecord.getVoiceCall().isMuted()),
+      new Pair<>(CallInfoIsOnHold, callRecord.getVoiceCall().isOnHold()),
+      new Pair<>(CallInviteInfoCustomParameters, serializeCallInviteCustomParameters(callRecord.getCallInvite())),
+      new Pair<>(CallInfoInitialConnectedTimestamp, simplifiedISO8601DateTimeFormat(callRecord.getTimestamp()))
+    );
+    return callInfo;
+  }
+
+  /**
+   * Serializes an AudioDevice.
+   * @param uuid The UUID of the AudioDevice
+   * @param audioDevice The AudioDevice
+   * @return A serialized AudioDevice
+   */
+  public static WritableMap serializeAudioDevice(String uuid, @Nullable AudioDevice audioDevice) {
+    if (null != audioDevice) {
+      String type = audioDevice.getClass().getSimpleName();
+      return constructJSMap(
+        new Pair<>(AudioDeviceKeyUuid, uuid),
+        new Pair<>(AudioDeviceKeyName, audioDevice.getName()),
+        new Pair<>(AudioDeviceKeyType, AudioSwitchManager.AUDIO_DEVICE_TYPE.get(type)));
+    }
+    return null;
+  }
+
+  /**
+   * Serializes a map of UUIDs to AudioDevices into a list of [key, value] tuples.
+   * @param audioDevices A map of UUIDs to AudioDevices
+   * @return A serialized list of UUID and AudioDevice tuples
+   */
+  public static WritableArray serializeAudioDeviceMapIntoArray(Map<String, AudioDevice> audioDevices) {
+    WritableArray audioDeviceInfoArray = Arguments.createArray();
+
+    for (Entry<String, AudioDevice> entry : audioDevices.entrySet()) {
+      String uuid = entry.getKey();
+      AudioDevice audioDevice = entry.getValue();
+
+      WritableMap audioDeviceInfoMap = serializeAudioDevice(uuid, audioDevice);
+      audioDeviceInfoArray.pushMap(audioDeviceInfoMap);
+    }
+
+    return audioDeviceInfoArray;
+  }
+
+  /**
+   * Serializes all audio device information.
+   * @param audioDevices A map of UUIDs to AudioDevices
+   * @param selectedAudioDeviceUuid The UUID of the selected audio device
+   * @param selectedAudioDevice The selected audio device
+   * @return Serialized audio device information
+   */
+  public static WritableMap serializeAudioDeviceInfo(
+    Map<String, AudioDevice> audioDevices,
+    String selectedAudioDeviceUuid,
+    AudioDevice selectedAudioDevice) {
+    return constructJSMap(
+      new Pair<>(AudioDeviceKeyAudioDevices, serializeAudioDeviceMapIntoArray(audioDevices)),
+      new Pair<>(AudioDeviceKeySelectedDevice, serializeAudioDevice(selectedAudioDeviceUuid, selectedAudioDevice)));
+  }
+  public static WritableMap serializeVoiceException(VoiceException exception) {
+    if (null != exception) {
+      return constructJSMap(
+        new Pair<>(VoiceErrorKeyCode, exception.getErrorCode()),
+        new Pair<>(VoiceErrorKeyMessage, exception.getMessage()));
+    }
+    return null;
+  }
+  public static WritableMap serializeCallException(@NonNull final CallRecord callRecord) {
+    return (null != callRecord.getCallException())
+      ? serializeVoiceException(callRecord.getCallException())
+      : null;
+  }
+
+  public static WritableMap serializeError(int code, String message) {
+    if (null != message) {
+      return constructJSMap(
+        new Pair<>(VoiceErrorKeyCode, code),
+        new Pair<>(VoiceErrorKeyMessage, message)
+      );
+    }
+    return null;
+  }
+
+  public static WritableArray serializeCallQualityWarnings(@NonNull Set<Call.CallQualityWarning> warnings) {
+    WritableArray previousWarningsArray = Arguments.createArray();
+    for (Call.CallQualityWarning warning : warnings) {
+      previousWarningsArray.pushString(warning.toString());
+    }
+    return previousWarningsArray;
+  }
+
+  /**
+   * Serializes a Call Message
+   * @param CallMessage the call message
+   * @return A serialized Call
+   */
+  public static WritableMap serializeCallMessage(@NonNull final CallMessage callMessage) {
+    return constructJSMap(
+      new Pair<>(VoiceEventSid, callMessage.getVoiceEventSID()),
+      new Pair<>(CallMessageContent, callMessage.getContent()),
+      new Pair<>(CallMessageContentType, callMessage.getMessageContentType()),
+      new Pair<>(CallMessageMessageType, callMessage.getMessageType())
+    );
+  }
+
+  private static String simplifiedISO8601DateTimeFormat(final Date date) {
+    SimpleDateFormat simpleDateFormat =
+      new SimpleDateFormat("yyyy-MM-dd'T'HH:mm:ss.SSSZ", Locale.US);
+    return (null != date) ? simpleDateFormat.format(date) : null;
+  }
+}