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

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

@@ -0,0 +1,28 @@
+package com.twiliovoicereactnative;
+
+import androidx.annotation.NonNull;
+
+import com.facebook.react.ReactPackage;
+import com.facebook.react.bridge.NativeModule;
+import com.facebook.react.bridge.ReactApplicationContext;
+import com.facebook.react.uimanager.ViewManager;
+
+import java.util.ArrayList;
+import java.util.Collections;
+import java.util.List;
+
+public class TwilioVoiceReactNativePackage implements ReactPackage {
+    @NonNull
+    @Override
+    public List<NativeModule> createNativeModules(@NonNull ReactApplicationContext reactContext) {
+        List<NativeModule> modules = new ArrayList<>();
+        modules.add(new TwilioVoiceReactNativeModule(reactContext));
+        return modules;
+    }
+
+    @NonNull
+    @Override
+    public List<ViewManager> createViewManagers(@NonNull ReactApplicationContext reactContext) {
+        return Collections.emptyList();
+    }
+}

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

@@ -0,0 +1,101 @@
+package com.twiliovoicereactnative;
+
+import java.util.List;
+import java.util.Vector;
+
+import android.Manifest;
+import android.app.Activity;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.os.Build;
+import android.os.Bundle;
+import android.view.Window;
+import android.view.WindowManager;
+
+import androidx.annotation.NonNull;
+import androidx.core.app.ActivityCompat;
+import androidx.core.content.ContextCompat;
+
+public class VoiceActivityProxy {
+  private static final SDKLog logger = new SDKLog(VoiceActivityProxy.class);
+  private static final int PERMISSION_REQUEST_CODE = 101;
+  private static final String[] permissionList;
+  private final Activity context;
+  private final PermissionsRationaleNotifier notifier;
+
+  public interface PermissionsRationaleNotifier {
+    void displayRationale(final String permission);
+  }
+
+  public VoiceActivityProxy(@NonNull Activity activity,
+                            @NonNull PermissionsRationaleNotifier notifier) {
+    this.context = activity;
+    this.notifier = notifier;
+  }
+  public void onCreate(Bundle ignoredSavedInstanceState) {
+    logger.debug("onCreate(): invoked");
+    // Ensure the microphone permission is enabled
+    if (!checkPermissions()) {
+      requestPermissions();
+    }
+    // These flags ensure that the activity can be launched when the screen is locked.
+    Window window = context.getWindow();
+    window.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED
+      | WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON
+      | WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
+    // handle any incoming intents
+    handleIntent(context.getIntent());
+  }
+  public void onDestroy() {
+    logger.debug("onDestroy(): invoked");
+  }
+  public void onNewIntent(Intent intent) {
+    logger.debug("onNewIntent(...): invoked");
+    handleIntent(intent);
+  }
+  private void requestPermissions() {
+    List<String> permissionsRequestList = new Vector<>();
+    for (final String permission: VoiceActivityProxy.permissionList) {
+      permissionsRequestList.add(permission);
+      if (ActivityCompat.shouldShowRequestPermissionRationale(context, permission)) {
+        notifier.displayRationale(permission);
+      }
+    }
+    ActivityCompat.requestPermissions(
+      context,
+      permissionsRequestList.toArray(new String[0]),
+      PERMISSION_REQUEST_CODE);
+  }
+  private boolean checkPermissions() {
+    for (String permission: VoiceActivityProxy.permissionList) {
+      if (PackageManager.PERMISSION_GRANTED !=
+        ContextCompat.checkSelfPermission(context, permission)) {
+        return false;
+      }
+    }
+    return true;
+  }
+  private void handleIntent(Intent intent) {
+    String action = intent.getAction();
+    if ((null != action) && (!action.equals(Constants.ACTION_PUSH_APP_TO_FOREGROUND))) {
+      Intent copiedIntent = new Intent(intent);
+      copiedIntent.setClass(context.getApplicationContext(), VoiceService.class);
+      copiedIntent.setFlags(0);
+      context.getApplicationContext().startService(copiedIntent);
+    }
+  }
+
+  static {
+    if (Build.VERSION.SDK_INT > Build.VERSION_CODES.S_V2) {
+      permissionList = new String[] {
+        Manifest.permission.RECORD_AUDIO,
+        Manifest.permission.BLUETOOTH_CONNECT,
+        Manifest.permission.POST_NOTIFICATIONS };
+    } else if (Build.VERSION.SDK_INT > Build.VERSION_CODES.R) {
+      permissionList = new String[] {
+        Manifest.permission.RECORD_AUDIO, Manifest.permission.BLUETOOTH_CONNECT };
+    } else {
+      permissionList = new String[] { Manifest.permission.RECORD_AUDIO };
+    }
+  }
+}

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

@@ -0,0 +1,133 @@
+package com.twiliovoicereactnative;
+
+import static com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+import java.util.List;
+import java.util.Objects;
+
+import android.app.Application;
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.Intent;
+import android.content.ServiceConnection;
+import android.os.IBinder;
+
+import com.facebook.react.ReactNativeHost;
+import com.facebook.react.ReactPackage;
+
+public class VoiceApplicationProxy {
+  private static final SDKLog logger = new SDKLog(VoiceApplicationProxy.class);
+  private static VoiceApplicationProxy instance = null;
+  private Application context = null;
+  private final CallRecordDatabase callRecordDatabase = new CallRecordDatabase();
+  private AudioSwitchManager audioSwitchManager;
+  private MediaPlayerManager mediaPlayerManager;
+  private JSEventEmitter jsEventEmitter;
+  private VoiceService.VoiceServiceAPI voiceServiceApi = null;
+  private final ServiceConnection voiceServiceObserver = new ServiceConnection() {
+    @Override
+    public void onServiceConnected(ComponentName name, IBinder service) {
+      if (name.getClassName().equals(VoiceService.class.getName()))
+        voiceServiceApi = (VoiceService.VoiceServiceAPI)service;
+    }
+    @Override
+    public void onServiceDisconnected(ComponentName name) {
+      voiceServiceApi = null;
+    }
+  };
+  public abstract static class VoiceReactNativeHost extends ReactNativeHost {
+    public VoiceReactNativeHost(Application application) {
+      super(application);
+    }
+    @Override
+    protected List<ReactPackage> getPackages() {
+      return List.of(new TwilioVoiceReactNativePackage());
+    }
+    public Application getAssociatedApplication() {
+      return super.getApplication();
+    }
+  }
+
+  public VoiceApplicationProxy(Application application) {
+    if (null != instance) {
+      logger.error("Voice application proxy already created!");
+    }
+    instance = this;
+    context = application;
+  }
+  public VoiceApplicationProxy(VoiceReactNativeHost reactNativeHost) {
+    if (null != instance) {
+      logger.error("Voice application proxy already created!");
+    }
+    instance = this;
+    context = reactNativeHost.getAssociatedApplication();
+  }
+  public void onCreate() {
+    logger.debug("onCreate(..) invoked");
+    // construct JS event engine
+    jsEventEmitter = new JSEventEmitter();
+    // construct notification channels
+    NotificationUtility.createNotificationChannels(context);
+    // launch and bind to voice call service
+    context.bindService(
+      new Intent(context, VoiceService.class),
+      voiceServiceObserver,
+      Context.BIND_AUTO_CREATE);
+    // Activate audio engine
+    audioSwitchManager = new AudioSwitchManager(context);
+    mediaPlayerManager = new MediaPlayerManager(context);
+    audioSwitchManager.start();
+  }
+  public void onTerminate() {
+    logger.debug("onTerminate(..) invoked");
+    // shutdown notificaiton channels
+    NotificationUtility.destroyNotificationChannels(context);
+    // shutdown audioswitch & media manager
+    audioSwitchManager.stop();
+    // verify that no call records are leaked
+    for (CallRecord callRecord: callRecordDatabase.getCollection()) {
+      logger.warning(
+        String.format(
+          "Call Record leaked: { uuid: %s callSid: %s }",
+          (null != callRecord.getUuid()) ? callRecord.getUuid() : "null",
+          (null != callRecord.getCallSid()) ? callRecord.getCallSid() : "null"));
+    }
+    callRecordDatabase.clear();
+  }
+  static CallRecordDatabase getCallRecordDatabase() {
+    return VoiceApplicationProxy.instance.callRecordDatabase;
+  }
+  static AudioSwitchManager getAudioSwitchManager() {
+    return VoiceApplicationProxy.instance.audioSwitchManager;
+  }
+  static MediaPlayerManager getMediaPlayerManager() {
+    return VoiceApplicationProxy.instance.mediaPlayerManager;
+  }
+  static JSEventEmitter getJSEventEmitter() {
+    return VoiceApplicationProxy.instance.jsEventEmitter;
+  }
+
+  static Context getApplicationContext() {
+    return VoiceApplicationProxy.instance.context;
+  }
+
+  static Class<?> getMainActivityClass() {
+    Context context = VoiceApplicationProxy.instance.context;
+    String packageName = context.getPackageName();
+    Intent launchIntent = context.getPackageManager().getLaunchIntentForPackage(packageName);
+    ComponentName componentName = Objects.requireNonNull(launchIntent).getComponent();
+    try {
+      return Class.forName(Objects.requireNonNull(componentName).getClassName());
+    } catch (ClassNotFoundException e) {
+      e.printStackTrace();
+      return null;
+    }
+  }
+
+  static VoiceService.VoiceServiceAPI getVoiceServiceApi() {
+    if (null == VoiceApplicationProxy.instance.voiceServiceApi) {
+      logger.error("Voice Service not bound!");
+    }
+    return VoiceApplicationProxy.instance.voiceServiceApi;
+  }
+}

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

@@ -0,0 +1,88 @@
+package com.twiliovoicereactnative;
+
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getCallRecordDatabase;
+import static com.twiliovoicereactnative.VoiceApplicationProxy.getVoiceServiceApi;
+
+import com.twiliovoicereactnative.CallRecordDatabase.CallRecord;
+
+import android.os.PowerManager;
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+
+import com.google.firebase.messaging.FirebaseMessagingService;
+import com.google.firebase.messaging.RemoteMessage;
+import com.twilio.voice.CallException;
+import com.twilio.voice.CallInvite;
+import com.twilio.voice.CancelledCallInvite;
+import com.twilio.voice.MessageListener;
+import com.twilio.voice.Voice;
+
+import java.util.Objects;
+import java.util.UUID;
+
+public class VoiceFirebaseMessagingService extends FirebaseMessagingService {
+  private static final SDKLog logger = new SDKLog(VoiceFirebaseMessagingService.class);
+
+  public static class MessageHandler implements MessageListener  {
+    @Override
+    public void onCallInvite(@NonNull CallInvite callInvite) {
+      logger.log(String.format("onCallInvite %s", callInvite.getCallSid()));
+
+      final CallRecord callRecord = new CallRecord(UUID.randomUUID(), callInvite);
+
+      getCallRecordDatabase().add(callRecord);
+      getVoiceServiceApi().incomingCall(callRecord);
+    }
+
+    @Override
+    public void onCancelledCallInvite(@NonNull CancelledCallInvite cancelledCallInvite,
+                                      @Nullable CallException callException) {
+      logger.log(String.format("onCancelledCallInvite %s", cancelledCallInvite.getCallSid()));
+
+      CallRecord callRecord = Objects.requireNonNull(
+        getCallRecordDatabase().remove(new CallRecord(cancelledCallInvite.getCallSid())));
+
+      callRecord.setCancelledCallInvite(cancelledCallInvite);
+      callRecord.setCallException(callException);
+      getVoiceServiceApi().cancelCall(callRecord);
+    }
+  }
+
+  @Override
+  public void onNewToken(@NonNull String token) {
+    logger.log("Refreshed FCM token: " + token);
+  }
+
+  /**
+   * Called when message is received.
+   *
+   * @param remoteMessage Object representing the message received from Firebase Cloud Messaging.
+   */
+  @Override
+  public void onMessageReceived(RemoteMessage remoteMessage) {
+    logger.debug("onMessageReceived remoteMessage: " + remoteMessage.toString());
+    logger.debug("Bundle data: " + remoteMessage.getData());
+    logger.debug("From: " + remoteMessage.getFrom());
+
+    PowerManager pm = (PowerManager)getSystemService(POWER_SERVICE);
+    boolean isScreenOn = pm.isInteractive(); // check if screen is on
+    if (!isScreenOn) {
+      PowerManager.WakeLock wl = pm.newWakeLock(
+        PowerManager.SCREEN_DIM_WAKE_LOCK | PowerManager.ACQUIRE_CAUSES_WAKEUP,
+        "VoiceFirebaseMessagingService:notificationLock");
+      wl.acquire(30000); //set your time in milliseconds
+    }
+
+    // Check if message contains a data payload.
+    if (!remoteMessage.getData().isEmpty()) {
+      if (!Voice.handleMessage(
+        this,
+        remoteMessage.getData(),
+        new MessageHandler(),
+        new CallMessageListenerProxy())) {
+        logger.error("The message was not a valid Twilio Voice SDK payload: " +
+          remoteMessage.getData());
+      }
+    }
+  }
+}