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

package/expo-config-plugin/android.js

@@ -0,0 +1,191 @@
+/* eslint-disable no-shadow */
+const {
+  withAppBuildGradle,
+  withProjectBuildGradle,
+  withAndroidManifest,
+  withStringsXml,
+} = require('@expo/config-plugins');
+const fs = require('fs');
+const path = require('path');
+
+const googleServicesClassPath = 'com.google.gms:google-services';
+const googleServicesVersion = '4.4.1';
+
+function withTwilioVoiceAndroid(config, options = {}) {
+  const {
+    firebaseMessagingServiceEnabled = true,
+    googleServicesJsonPath = null,
+  } = options;
+
+  config = withAndroidManifest(config, (config) => {
+    const androidManifest = config.modResults;
+
+    const permissions = [
+      'android.permission.RECORD_AUDIO',
+      'android.permission.MODIFY_AUDIO_SETTINGS',
+      'android.permission.USE_SIP',
+      'android.permission.WAKE_LOCK',
+      'android.permission.VIBRATE',
+    ];
+
+    permissions.forEach((permission) => {
+      if (
+        !androidManifest.manifest['uses-permission']?.find(
+          (p) => p.$['android:name'] === permission
+        )
+      ) {
+        if (!androidManifest.manifest['uses-permission']) {
+          androidManifest.manifest['uses-permission'] = [];
+        }
+        androidManifest.manifest['uses-permission'].push({
+          $: { 'android:name': permission },
+        });
+      }
+    });
+
+    return config;
+  });
+
+  config = withStringsXml(config, (config) => {
+    const strings = config.modResults;
+
+    const fcmServiceConfig = {
+      $: { name: 'twiliovoicereactnative_firebasemessagingservice_enabled' },
+      _: firebaseMessagingServiceEnabled.toString(),
+    };
+
+    strings.resources.bool = strings.resources.bool || [];
+    strings.resources.bool = strings.resources.bool.filter(
+      (item) =>
+        item.$.name !==
+        'twiliovoicereactnative_firebasemessagingservice_enabled'
+    );
+
+    strings.resources.bool.push(fcmServiceConfig);
+
+    return config;
+  });
+
+  config = withAppBuildGradle(config, (config) => {
+    let buildGradle = config.modResults.contents;
+
+    if (!buildGradle.includes('com.google.gms.google-services')) {
+      const pluginRegex = /(apply plugin: ['"]com\.android\.application['"])/;
+      if (pluginRegex.test(buildGradle)) {
+        buildGradle = buildGradle.replace(
+          pluginRegex,
+          '$1\napply plugin: "com.google.gms.google-services"'
+        );
+      }
+    }
+
+    const firebaseDeps = [
+      "implementation 'com.google.firebase:firebase-messaging:23.0.0'",
+      "implementation 'com.google.firebase:firebase-core:21.0.0'",
+    ];
+
+    const dependenciesRegex = /dependencies\s*\{/;
+    if (dependenciesRegex.test(buildGradle)) {
+      firebaseDeps.forEach((dep) => {
+        if (!buildGradle.includes(dep)) {
+          buildGradle = buildGradle.replace(
+            dependenciesRegex,
+            `dependencies {\n    ${dep}`
+          );
+        }
+      });
+    }
+
+    config.modResults.contents = buildGradle;
+    return config;
+  });
+
+  config = withAppBuildGradle(config, (config) => {
+    let buildGradle = config.modResults.contents;
+
+    const kotlinVersion = '2.0.21';
+
+    if (!buildGradle.includes('kotlin-gradle-plugin')) {
+      const buildscriptRegex = /buildscript\s*\{[\s\S]*?dependencies\s*\{/;
+      if (buildscriptRegex.test(buildGradle)) {
+        buildGradle = buildGradle.replace(
+          /dependencies\s*\{/,
+          `dependencies {\n        classpath "org.jetbrains.kotlin:kotlin-gradle-plugin:${kotlinVersion}"`
+        );
+      }
+    }
+
+    if (!buildGradle.includes('kotlin-android')) {
+      const pluginRegex = /(apply plugin: ['"]com\.android\.application['"])/;
+      if (pluginRegex.test(buildGradle)) {
+        buildGradle = buildGradle.replace(
+          pluginRegex,
+          '$1\napply plugin: "kotlin-android"'
+        );
+      }
+    }
+
+    config.modResults.contents = buildGradle;
+    return config;
+  });
+
+  config = withProjectBuildGradle(config, (config) => {
+    config.modResults.contents = setClassPath(
+      config,
+      config.modResults.contents
+    );
+    return config;
+  });
+
+  if (googleServicesJsonPath && fs.existsSync(googleServicesJsonPath)) {
+    config = withAppBuildGradle(config, (config) => {
+      console.log(
+        '📁 google-services.json will be copied from:',
+        googleServicesJsonPath
+      );
+      return config;
+    });
+  }
+
+  config = withGoogleServicesJson(config, googleServicesJsonPath);
+
+  return config;
+}
+
+function withGoogleServicesJson(config, googleServicesJsonPath) {
+  return withAppBuildGradle(config, async (config) => {
+    if (googleServicesJsonPath && fs.existsSync(googleServicesJsonPath)) {
+      const projectRoot = config.modRequest.projectRoot;
+      const targetPath = path.join(
+        projectRoot,
+        'android',
+        'app',
+        'google-services.json'
+      );
+
+      try {
+        fs.copyFileSync(googleServicesJsonPath, targetPath);
+        console.log('✅ google-services.json copied successfully');
+      } catch (error) {
+        console.warn('⚠️ Failed to copy google-services.json:', error.message);
+      }
+    }
+    return config;
+  });
+}
+
+function setClassPath(config, buildGradle) {
+  if (buildGradle.includes(googleServicesClassPath)) {
+    return buildGradle;
+  }
+
+  //
+  return buildGradle.replace(
+    /dependencies\s?{/,
+    `dependencies {
+        classpath('${googleServicesClassPath}:${googleServicesVersion}')`
+  );
+}
+
+module.exports = withTwilioVoiceAndroid;
+module.exports.withGoogleServicesJson = withGoogleServicesJson;

package/expo-config-plugin/ios.js

@@ -0,0 +1,22 @@
+const {
+  withInfoPlist,
+  withEntitlementsPlist,
+} = require('@expo/config-plugins');
+
+function withTwilioVoiceIOS(config) {
+  config = withInfoPlist(config, (configuration) => {
+    configuration.modResults.NSMicrophoneUsageDescription =
+      'This app needs access to the microphone for voice calls and recording voice messages';
+    configuration.modResults.UIBackgroundModes = ['audio', 'voip'];
+    return configuration;
+  });
+
+  config = withEntitlementsPlist(config, (configuration) => {
+    configuration.modResults['aps-environment'] = ['development'];
+    return configuration;
+  });
+
+  return config;
+}
+
+module.exports = withTwilioVoiceIOS;

package/expo-module.config.json

@@ -0,0 +1,6 @@
+{
+  "platforms": ["android", "ios"],
+  "android": {
+    "modules": ["com.twiliovoicereactnative.ExpoModule"]
+  }
+}

package/ios/TwilioVoicePushRegistry.h

@@ -0,0 +1,19 @@
+//
+//  TwilioVoicePushRegistry.h
+//  TwilioVoiceReactNative
+//
+//  Copyright © 2022 Twilio, Inc. All rights reserved.
+//
+
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryNotification;
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryEventType;
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryNotificationDeviceTokenUpdated;
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryNotificationDeviceToken;
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryNotificationIncomingPushReceived;
+FOUNDATION_EXPORT NSString * const kTwilioVoicePushRegistryNotificationIncomingPushPayload;
+
+@interface TwilioVoicePushRegistry : NSObject
+
+- (void)updatePushRegistry;
+
+@end

package/ios/TwilioVoicePushRegistry.m

@@ -0,0 +1,72 @@
+//
+//  TwilioVoicePushRegistry.m
+//  TwilioVoiceReactNative
+//
+//  Copyright © 2022 Twilio, Inc. All rights reserved.
+//
+
+@import PushKit;
+@import Foundation;
+@import TwilioVoice;
+
+#import "TwilioVoicePushRegistry.h"
+#import "TwilioVoiceReactNative.h"
+#import "TwilioVoiceReactNativeConstants.h"
+
+NSString * const kTwilioVoicePushRegistryNotification = @"TwilioVoicePushRegistryNotification";
+NSString * const kTwilioVoicePushRegistryEventType = @"type";
+NSString * const kTwilioVoicePushRegistryNotificationDeviceTokenUpdated = @"deviceTokenUpdated";
+NSString * const kTwilioVoicePushRegistryNotificationDeviceToken = @"deviceToken";
+NSString * const kTwilioVoicePushRegistryNotificationIncomingPushReceived = @"incomingPushReceived";
+NSString * const kTwilioVoicePushRegistryNotificationIncomingPushPayload = @"incomingPushPayload";
+
+@interface TwilioVoicePushRegistry () <PKPushRegistryDelegate>
+
+@property (nonatomic, strong) PKPushRegistry *voipRegistry;
+@property (nonatomic, copy) NSString *callInviteUuid;
+
+@end
+
+@implementation TwilioVoicePushRegistry
+
+#pragma mark - TwilioVoicePushRegistry methods
+
+- (void)updatePushRegistry {
+    self.voipRegistry = [[PKPushRegistry alloc] initWithQueue:dispatch_get_main_queue()];
+    self.voipRegistry.delegate = self;
+    self.voipRegistry.desiredPushTypes = [NSSet setWithObject:PKPushTypeVoIP];
+}
+
+#pragma mark - PKPushRegistryDelegate
+
+- (void)pushRegistry:(PKPushRegistry *)registry
+didUpdatePushCredentials:(PKPushCredentials *)credentials
+             forType:(NSString *)type {
+    if ([type isEqualToString:PKPushTypeVoIP]) {
+        [[NSNotificationCenter defaultCenter] postNotificationName:kTwilioVoicePushRegistryNotification
+                                                            object:nil
+                                                          userInfo:@{kTwilioVoicePushRegistryEventType: kTwilioVoicePushRegistryNotificationDeviceTokenUpdated,
+                                                                     kTwilioVoicePushRegistryNotificationDeviceToken: credentials.token}];
+    }
+}
+
+- (void)pushRegistry:(PKPushRegistry *)registry
+didReceiveIncomingPushWithPayload:(PKPushPayload *)payload
+             forType:(PKPushType)type
+withCompletionHandler:(void (^)(void))completion {
+    if ([type isEqualToString:PKPushTypeVoIP]) {
+        [[NSNotificationCenter defaultCenter] postNotificationName:kTwilioVoicePushRegistryNotification
+                                                            object:nil
+                                                          userInfo:@{kTwilioVoicePushRegistryEventType: kTwilioVoicePushRegistryNotificationIncomingPushReceived,
+                                                                     kTwilioVoicePushRegistryNotificationIncomingPushPayload: payload.dictionaryPayload}];
+    }
+
+    completion();
+}
+
+- (void)pushRegistry:(PKPushRegistry *)registry
+        didInvalidatePushTokenForType:(NSString *)type {
+    // TODO: notify view-controller to emit event that the push-registry has been invalidated
+}
+
+@end

package/ios/TwilioVoiceReactNative+CallInvite.m

@@ -0,0 +1,56 @@
+//
+//  TwilioVoiceReactNative+CallInvite.m
+//  TwilioVoiceReactNative
+//
+//  Copyright © 2023 Twilio, Inc. All rights reserved.
+//
+
+@import TwilioVoice;
+
+#import "TwilioVoiceReactNative.h"
+#import "TwilioVoiceReactNativeConstants.h"
+
+@interface TwilioVoiceReactNative (CallInvite) <TVONotificationDelegate>
+
+@end
+
+@implementation TwilioVoiceReactNative (CallInvite)
+
+- (void)callInviteReceived:(TVOCallInvite *)callInvite {
+    self.callInviteMap[callInvite.uuid.UUIDString] = callInvite;
+    
+    [self reportNewIncomingCall:callInvite];
+
+    [self sendEventWithName:kTwilioVoiceReactNativeScopeVoice
+                       body:@{
+                         kTwilioVoiceReactNativeVoiceEventType: kTwilioVoiceReactNativeVoiceEventTypeValueIncomingCallInvite,
+                         kTwilioVoiceReactNativeEventKeyCallInvite: [self callInviteInfo:callInvite]}];
+}
+
+- (void)cancelledCallInviteReceived:(TVOCancelledCallInvite *)cancelledCallInvite error:(NSError *)error {
+    NSString *uuid;
+    for (NSString *uuidKey in [self.callInviteMap allKeys]) {
+        TVOCallInvite *callInvite = self.callInviteMap[uuidKey];
+        if ([callInvite.callSid isEqualToString:cancelledCallInvite.callSid]) {
+            uuid = uuidKey;
+            break;
+        }
+    }
+    NSAssert(uuid, @"No matching call invite");
+    self.cancelledCallInviteMap[uuid] = cancelledCallInvite;
+
+    [self sendEventWithName:kTwilioVoiceReactNativeScopeCallInvite
+                       body:@{
+                         kTwilioVoiceReactNativeVoiceEventType: kTwilioVoiceReactNativeCallInviteEventTypeValueCancelled,
+                         kTwilioVoiceReactNativeCallInviteEventKeyCallSid: cancelledCallInvite.callSid,
+                         kTwilioVoiceReactNativeEventKeyCancelledCallInvite: [self cancelledCallInviteInfo:cancelledCallInvite],
+                         kTwilioVoiceReactNativeVoiceErrorKeyError: @{
+                           kTwilioVoiceReactNativeVoiceErrorKeyCode: @(error.code),
+                           kTwilioVoiceReactNativeVoiceErrorKeyMessage: [error localizedDescription]}}];
+    
+    [self.callInviteMap removeObjectForKey:uuid];
+    
+    [self endCallWithUuid:[[NSUUID alloc] initWithUUIDString:uuid]];
+}
+
+@end