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

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

@@ -0,0 +1,41 @@
+package com.twiliovoicereactnative;
+
+import android.content.Context;
+import android.content.SharedPreferences;
+
+class ConfigurationProperties {
+  public static void setIncomingCallContactHandleTemplate(Context ctx, String template) {
+    SharedPreferences sharedPreferences = ctx.getSharedPreferences(Constants.PREFERENCES_FILE, Context.MODE_PRIVATE);
+    sharedPreferences
+      .edit()
+      .putString(Constants.INCOMING_CALL_CONTACT_HANDLE_TEMPLATE_PREFERENCES_KEY, template)
+      .apply();
+  }
+
+  public static String getIncomingCallContactHandleTemplate(Context ctx) {
+    SharedPreferences sharedPreferences = ctx.getSharedPreferences(Constants.PREFERENCES_FILE, Context.MODE_PRIVATE);
+    return sharedPreferences.getString(Constants.INCOMING_CALL_CONTACT_HANDLE_TEMPLATE_PREFERENCES_KEY, null);
+  }
+
+  /**
+   * Get configuration boolean, used to determine if the built-in Firebase service should be enabled
+   * or not.
+   * @param context the application context
+   * @return a boolean read from the application resources
+   */
+  public static boolean isFirebaseServiceEnabled(Context context) {
+    return context.getResources()
+      .getBoolean(R.bool.twiliovoicereactnative_firebasemessagingservice_enabled);
+  }
+
+  /**
+   * Get configuration boolean, used to determine if full screen notifications are enabled
+   * or not.
+   * @param context the application context
+   * @return a boolean read from the application resources
+   */
+  public static boolean isFullScreenNotificationEnabled(Context context) {
+    return context.getResources()
+      .getBoolean(R.bool.twiliovoicereactnative_fullscreennotification_enabled);
+  }
+}

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

@@ -0,0 +1,23 @@
+package com.twiliovoicereactnative;
+
+class Constants {
+  public static final String VOICE_CHANNEL_GROUP = "notification-group";
+  public static final String VOICE_CHANNEL_LOW_IMPORTANCE = "notification-channel-low-importance";
+  public static final String VOICE_CHANNEL_HIGH_IMPORTANCE = "notification-channel-high-importance";
+  public static final String VOICE_CHANNEL_DEFAULT_IMPORTANCE = "notification-channel-normal-importance";
+  public static final String ACTION_ACCEPT_CALL = "ACTION_ACCEPT_CALL";
+  public static final String ACTION_REJECT_CALL = "ACTION_REJECT_CALL";
+  public static final String ACTION_CANCEL_ACTIVE_CALL_NOTIFICATION = "ACTION_CANCEL_ACTIVE_CALL_NOTIFICATION";
+  public static final String ACTION_INCOMING_CALL = "ACTION_INCOMING_CALL";
+  public static final String ACTION_CANCEL_CALL = "ACTION_CANCEL_CALL";
+  public static final String ACTION_CALL_DISCONNECT = "ACTION_CALL_DISCONNECT";
+  public static final String ACTION_RAISE_OUTGOING_CALL_NOTIFICATION = "ACTION_RAISE_OUTGOING_CALL_NOTIFICATION";
+  public static final String ACTION_PUSH_APP_TO_FOREGROUND = "ACTION_PUSH_APP_TO_FOREGROUND";
+  public static final String ACTION_FOREGROUND_AND_DEPRIORITIZE_INCOMING_CALL_NOTIFICATION = "ACTION_FOREGROUND_AND_DEPRIORITIZE_INCOMING_CALL_NOTIFICATION";
+  public static final String MSG_KEY_UUID = "UUID";
+  public static final String JS_EVENT_KEY_CALL_INFO = "call";
+  public static final String JS_EVENT_KEY_CALL_INVITE_INFO = "callInvite";
+  public static final String JS_EVENT_KEY_CANCELLED_CALL_INVITE_INFO = "cancelledCallInvite";
+  public static final String PREFERENCES_FILE = "com.twilio.twiliovoicereactnative.preferences";
+  public static final String INCOMING_CALL_CONTACT_HANDLE_TEMPLATE_PREFERENCES_KEY = "incomingCallContactHandleTemplatePreferenceKey";
+}

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

@@ -0,0 +1,39 @@
+package com.twiliovoicereactnative;
+
+import android.app.Activity;
+import android.content.Intent;
+import android.os.Bundle;
+import expo.modules.core.interfaces.ReactActivityLifecycleListener;
+
+public class ExpoActivityLifecycleListener implements ReactActivityLifecycleListener {
+    VoiceActivityProxy voiceActivityProxy;
+
+    @Override
+    public void onCreate(Activity activity, Bundle savedInstanceState) {
+        // Create a PermissionsRationaleNotifier implementation
+        VoiceActivityProxy.PermissionsRationaleNotifier notifier = new VoiceActivityProxy.PermissionsRationaleNotifier() {
+            @Override
+            public void displayRationale(String permission) {
+                // Log the permission rationale for debugging
+                SDKLog logger = new SDKLog(ExpoActivityLifecycleListener.class);
+                logger.debug("Permission rationale needed for: " + permission);
+                // You can add additional logic here to show a dialog or notification
+                // to the user explaining why the permission is needed
+            }
+        };
+        
+        this.voiceActivityProxy = new VoiceActivityProxy(activity, notifier);
+        this.voiceActivityProxy.onCreate(savedInstanceState);
+    }
+
+    @Override
+    public boolean onNewIntent(Intent intent) {
+        this.voiceActivityProxy.onNewIntent(intent);
+        return false;
+    }
+
+    @Override
+    public void onDestroy(Activity activity) {
+        this.voiceActivityProxy.onDestroy();
+    }
+}

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

@@ -0,0 +1,14 @@
+package com.twiliovoicereactnative;
+
+import android.app.Application;
+import expo.modules.core.interfaces.ApplicationLifecycleListener;
+
+public class ExpoApplicationLifecycleListener implements ApplicationLifecycleListener {
+    VoiceApplicationProxy voiceApplicationProxy;
+
+    @Override
+    public void onCreate(Application application) {
+        this.voiceApplicationProxy = new VoiceApplicationProxy(application);
+        this.voiceApplicationProxy.onCreate();
+    }
+}

package/android/src/main/java/com/twiliovoicereactnative/ExpoModule.kt

@@ -0,0 +1,41 @@
+package com.twiliovoicereactnative
+
+import expo.modules.kotlin.modules.Module
+import expo.modules.kotlin.modules.ModuleDefinition
+import com.twilio.voice.ConnectOptions
+import java.util.UUID
+import com.twiliovoicereactnative.ReactNativeArgumentsSerializer.serializeCall
+
+class ExpoModule : Module() {
+    private val log = SDKLog(this.javaClass)
+
+    override fun definition() = ModuleDefinition {
+        Name("TwilioVoiceExpo")
+
+        Function("voice_connect") { accessToken: String ->
+            val context = appContext.reactContext ?: return@Function
+
+            val connectOptions = ConnectOptions.Builder(accessToken).build()
+            val uuid = UUID.randomUUID()
+            val callListenerProxy = CallListenerProxy(uuid, context)
+
+            val call = VoiceApplicationProxy.getVoiceServiceApi().connect(
+                connectOptions,
+                callListenerProxy
+            )
+
+            val callRecord = CallRecordDatabase.CallRecord(
+                uuid,
+                call,
+                "Callee", // provide a mechanism for determining the name of the callee
+                HashMap(), // provide a mechanism for passing custom TwiML parameters
+                CallRecordDatabase.CallRecord.Direction.OUTGOING,
+                "Display Name" // provide a mechanism for determining the notification display name of the callee
+            )
+
+            VoiceApplicationProxy.getCallRecordDatabase().add(callRecord)
+            
+            serializeCall(callRecord)
+        }
+    }
+}

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

@@ -0,0 +1,20 @@
+package com.twiliovoicereactnative;
+
+import android.content.Context;
+import expo.modules.core.interfaces.Package;
+import expo.modules.core.interfaces.ReactActivityLifecycleListener;
+import expo.modules.core.interfaces.ApplicationLifecycleListener;
+import java.util.Collections;
+import java.util.List;
+
+public class ExpoPackage implements Package {
+    @Override
+    public List<? extends ReactActivityLifecycleListener> createReactActivityLifecycleListeners(Context activityContext) {
+        return Collections.singletonList(new ExpoActivityLifecycleListener());
+    }
+
+    @Override
+    public List<? extends ApplicationLifecycleListener> createApplicationLifecycleListeners(Context applicationContext) {
+        return Collections.singletonList(new ExpoApplicationLifecycleListener());
+    }
+}

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

@@ -0,0 +1,98 @@
+package com.twiliovoicereactnative;
+
+import android.util.Pair;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.bridge.ReadableArray;
+import com.facebook.react.bridge.ReadableMap;
+import com.facebook.react.bridge.WritableArray;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.modules.core.DeviceEventManagerModule;
+
+import java.lang.ref.WeakReference;
+
+class JSEventEmitter {
+  private static final SDKLog logger = new SDKLog(JSEventEmitter.class);
+  private WeakReference<ReactApplicationContext> context = new WeakReference<>(null);
+
+  public void setContext(ReactApplicationContext context) {
+    this.context = new WeakReference<>(context);
+  }
+  public void sendEvent(String eventName, @Nullable WritableMap params) {
+    logger.debug("sendEvent " + eventName + " params " + params);
+    if ((null != context.get()) &&
+        context.get().hasActiveReactInstance()) {
+      context.get()
+        .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
+        .emit(eventName, params);
+    } else {
+      logger.warning(
+        String.format(
+          "attempt to sendEvent without context {%s} or Catalyst instance not active",
+          context.get()));
+    }
+  }
+
+  public static WritableArray constructJSArray(@NonNull Object...entries) {
+    WritableArray params = Arguments.createArray();
+    for (Object entry: entries) {
+      if ((entry instanceof String)) {
+        params.pushString((String)entry);
+      } else if (entry instanceof ReadableMap) {
+        params.pushMap((ReadableMap) entry);
+      } else if (entry instanceof ReadableArray) {
+        params.pushArray((ReadableArray) entry);
+      } else if (entry instanceof Boolean) {
+        params.pushBoolean((Boolean) entry);
+      } else if (entry instanceof Integer) {
+        params.pushInt((Integer) entry);
+      } else if (entry instanceof Float) {
+        params.pushDouble((Float) entry);
+      } else if (entry instanceof Double) {
+        params.pushDouble((Double) entry);
+      } else if (entry instanceof Long) {
+        params.pushDouble((Long) entry);
+      } else if (entry == null) {
+        logger.debug("constructJSArray: filtering null value");
+      } else {
+        logger.debug(String.format("constructJSArray: unexpected type %s", entry.getClass()));
+      }
+    }
+    return params;
+  }
+  @SafeVarargs
+  public static WritableMap constructJSMap(@NonNull Pair<String, Object>...entries) {
+    WritableMap params = Arguments.createMap();
+    for (Pair<String, Object> entry: entries) {
+      if ((entry.second instanceof String)) {
+        params.putString(entry.first, (String) entry.second);
+      } else if (entry.second instanceof ReadableMap) {
+        params.putMap(entry.first, (ReadableMap) entry.second);
+      } else if (entry.second instanceof ReadableArray) {
+        params.putArray(entry.first, (ReadableArray) entry.second);
+      } else if (entry.second instanceof Boolean) {
+        params.putBoolean(entry.first, (Boolean) entry.second);
+      } else if (entry.second instanceof Integer) {
+        params.putInt(entry.first, (Integer) entry.second);
+      } else if (entry.second instanceof Float) {
+        params.putDouble(entry.first, (Float) entry.second);
+      } else if (entry.second instanceof Double) {
+        params.putDouble(entry.first, (Double) entry.second);
+      } else if (entry.second instanceof Long) {
+        params.putDouble(entry.first, (Long) entry.second);
+      } else if (entry.second == null) {
+        logger.debug("constructJSMap: filtering null value");
+      } else {
+        logger.debug(String.format(
+          "constructJSMap: unexpected type %s",
+          entry.second.getClass()
+        ));
+      }
+    }
+    return params;
+  }
+}

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

@@ -0,0 +1,58 @@
+package com.twiliovoicereactnative;
+
+import android.content.Context;
+import android.media.AudioAttributes;
+import android.media.SoundPool;
+
+import java.util.HashMap;
+import java.util.Map;
+
+class MediaPlayerManager {
+  public enum SoundTable {
+    INCOMING,
+    OUTGOING,
+    DISCONNECT,
+    RINGTONE
+  }
+  private final SoundPool soundPool;
+  private final Map<SoundTable, Integer> soundMap;
+  private int activeStream;
+
+  MediaPlayerManager(Context context) {
+    soundPool = (new SoundPool.Builder())
+      .setMaxStreams(2)
+      .setAudioAttributes(
+        new AudioAttributes.Builder()
+          .setContentType(AudioAttributes.CONTENT_TYPE_SONIFICATION)
+          .setUsage(AudioAttributes.USAGE_VOICE_COMMUNICATION)
+          .build())
+      .build();
+    activeStream = 0;
+    soundMap = new HashMap<>();
+    soundMap.put(SoundTable.INCOMING, soundPool.load(context, R.raw.incoming, 1));
+    soundMap.put(SoundTable.OUTGOING, soundPool.load(context, R.raw.outgoing, 1));
+    soundMap.put(SoundTable.DISCONNECT, soundPool.load(context, R.raw.disconnect, 1));
+    soundMap.put(SoundTable.RINGTONE, soundPool.load(context, R.raw.ringtone, 1));
+  }
+
+  public void play(final SoundTable sound) {
+    activeStream = soundPool.play(
+      soundMap.get(sound),
+      1.f,
+      1.f,
+      1,
+      (SoundTable.DISCONNECT== sound) ? 0 : -1,
+      1.f);
+  }
+
+  public void stop() {
+    soundPool.stop(activeStream);
+    activeStream = 0;
+  }
+
+  @Override
+  protected void finalize() throws Throwable {
+    soundPool.release();
+    super.finalize();
+  }
+}