Merge branch 'master' of https://github.com/react-native-webrtc/react-native-callkeep

Author: Brandon Huang

.github/ISSUE_TEMPLATE.md

@@ -0,0 +1,27 @@
+# Bug report
+
+- [ ] I've checked the [example](https://github.com/react-native-webrtc/react-native-callkeep/tree/master/example) to reproduce the issue.
+
+- Reproduced on:
+ - [ ] Android
+ - [ ] iOS
+
+## Description
+
+
+## Steps to Reproduce
+
+
+## Versions
+    - Callkeep:
+    - React Native:
+    - iOS:
+    - Android:
+    - Phone model: 
+
+
+## Logs
+
+```
+Paste here
+```

.npmignore

@@ -0,0 +1,2 @@
+example/
+node_modules/

AUTHORS

@@ -1,5 +1,12 @@
 CallKeep is a fork of react-native-callkit by ianlin.
-Since it only target iOS devices, we created CallKeep to target both Android and iOS.
+Since react-native-callkit only targets iOS devices, we created react-native-callkeep to target both Android and iOS.
 
     Ian Yu-Hsun Lin <[email protected]>
     Wazo Communication inc. <[email protected]>
+    Dan Jenkins <[email protected]>
+    Kyle Kurz <[email protected]>
+    bhuangy <[email protected]>
+    Chevon Christie
+    Linus Unnebäck <[email protected]>
+    Geraint White <[email protected]>
+    Samuel Bégin

MIGRATION_v2_v3.md

@@ -0,0 +1,63 @@
+# Migration from CallKeep v2 to v3
+
+Thanks to the Sangoma team, CallKeep now allows multi calls through native UI. 
+Here's how to upgrade your codebase for this new version.
+
+## Common
+
+### setup
+
+Since the v3, you have to call `setup` each time your application is launched.
+
+### didPerformDTMFAction
+
+`didPerformDTMFAction` now take `digits` instead of `dtmf` as key of its argument.
+
+### didPerformSetMutedCallAction
+
+`didPerformSetMutedCallAction` now returns an object as argument with `{ muted, callUUID }`.
+
+### startCall
+
+`startCall` takes 3 arguments now : `uuid`, `handle`, `contactIdentifier`.
+
+### Call uuids
+
+`setCurrentCallActive`, `endCall`, now takes a `callUuid` argument.
+
+Events are also with an `callUUID` in the argument object.
+
+### ⚠️ Lower case your uuids
+
+There is no more check on the uuid case, everything is returned to your application in lower case.
+So you have to send lower cased uuid to allow matching your calls.
+
+### News methods
+
+There is now new method like [updateDisplay]()
+
+## Android
+
+### Update `MainActivity.java`
+
+- Add new imports
+
+```diff
++ import android.support.annotation.NonNull;
++ import android.support.annotation.Nullable;
+```
+
+- Update `onRequestPermissionsResult` method:
+
+```java
+// Permission results
+@Override
+public void onRequestPermissionsResult(int requestCode, @NonNull String[] permissions, @NonNull int[] grantResults) {
+    super.onRequestPermissionsResult(requestCode, permissions, grantResults);
+    switch (requestCode) {
+        case RNCallKeepModule.REQUEST_READ_PHONE_STATE:
+            RNCallKeepModule.onRequestPermissionsResult(requestCode, permissions, grantResults);
+            break;
+    }
+}
+```

README.md

@@ -90,9 +90,10 @@ RNCallKeep.setup(options);
 ### setAvailable
 _This feature is available only on Android._
 
-Tell _ConnectionService_ that the device is ready to make outgoing calls.
+Tell _ConnectionService_ that the device is ready to make outgoing calls via the native Phone app.
 If not the user will be stuck in the build UI screen without any actions.
-Eg: Call it with `false` when disconnected from the sip client, when your token expires ...
+Eg: Call it with `false` when disconnected from the sip client, when your token expires, when your user log out ...
+Eg: When your used log out (or the connection to your server is broken, etc..), you have to call `setAvailable(false)` so CallKeep will refuse the call and your user will not be stuck in the native UI.
 
 ```js
 RNCallKeep.setAvailable(true);
@@ -180,21 +181,17 @@ RNCallKeep.startCall(uuid, handle, contactIdentifier);
 
 
 ### updateDisplay
-_This feature is available only on Android._
-
-Sets the Android caller name and number
-Use this to update the Android display after an outgoing call has started
+Use this to update the display after an outgoing call has started.
 
 ```js
-RNCallKeep.updateDisplay(uuid, localizedCallerName, handle)
+RNCallKeep.updateDisplay(uuid, displayName, handle)
 ```
 - `uuid`: string
   - The `uuid` used for `startCall` or `displayIncomingCall`
+- `displayName`: string (optional)
+  - Name of the caller to be displayed on the native UI
 - `handle`: string
   - Phone number of the caller
-- `localizedCallerName`: string (optional)
-  - Name of the caller to be displayed on the native UI
-
 
 ### endCall
 
@@ -324,6 +321,20 @@ _This feature is available only on Android._
 await RNCallKeep.hasPhoneAccount();
 ```
 
+### hasOutgoingCall (async)
+
+_This feature is available only on Android, useful when waking up the application for an outgoing call._
+
+When waking up the Android application in background mode (eg: when the application is killed and the user make a call from the native Phone application).
+The user can hang up the call before your application has been started in background mode, and you can lost the `RNCallKeepPerformEndCallAction` event.
+
+To be sure that the outgoing call is still here, you can call `hasOutgoingCall` when you app waken up.
+
+
+```js
+const hasOutgoingCall = await RNCallKeep.hasOutgoingCall();
+```
+
 ### hasDefaultPhoneAccount
 
 Checks if the user has set a default [phone account](https://developer.android.com/reference/android/telecom/PhoneAccount).
@@ -352,6 +363,8 @@ or by the app calling `RNCallKeep.startCall`.
 
 Try to start your app call action from here (e.g. get credentials of the user by `data.handle` and/or send INVITE to your SIP server)
 
+Note: on iOS `callUUID` is not defined as the call is not yet managed by CallKit. You have to generate your own and call `startCall`.
+
 ```js
 RNCallKeep.addEventListener('didReceiveStartCallAction', ({ handle, callUUID, name }) => {
 
@@ -407,7 +420,7 @@ RNCallKeep.addEventListener('didActivateAudioSession', () => {
 Callback for `RNCallKeep.displayIncomingCall`
 
 ```js
-RNCallKeep.addEventListener('didDisplayIncomingCall', ({ error }) => {
+RNCallKeep.addEventListener('didDisplayIncomingCall', ({ error, uuid, handle, localizedCallerName, fromPushKit }) => {
   // you might want to do following things when receiving this event:
   // - Start playing ringback if it is an outgoing call
 });
@@ -458,6 +471,17 @@ RNCallKeep.addEventListener('didPerformDTMFAction', ({ digits, callUUID }) => {
   - The digits that emit the dtmf tone
 - `callUUID` (string)
   - The UUID of the call.
+  
+### - checkReachability
+
+On Android when the application is in background, after a certain delay the OS will close every connection with informing about it.
+So we have to check if the application is reachable before making a call from the native phone application.
+
+```js
+RNCallKeep.addEventListener('checkReachability', () => {
+  RNCallKeep.setReachable();
+});
+```
 
 ## Example
 
@@ -564,7 +588,7 @@ class RNCallKeepExample extends React.Component {
   onDTMFAction = (data) => {
     let { digits, callUUID } = data;
     // Called when the system or user performs a DTMF action
-  }
+  };
 
   audioSessionActivated = (data) => {
     // you might want to do following things when receiving this event:
@@ -584,6 +608,36 @@ class RNCallKeepExample extends React.Component {
 }
 ```
 
+## Receiving a call when the application is not reachable.
+
+In some case your application can be unreachable :
+- when the user kill the application 
+- when it's in background since a long time (eg: after ~5mn the os will kill all connections).
+
+To be able to wake up your application to display the incoming call, you can use [https://github.com/ianlin/react-native-voip-push-notification](react-native-voip-push-notification) on iOS or BackgroundMessaging from [react-native-firebase](https://rnfirebase.io/docs/v5.x.x/messaging/receiving-messages#4)-(Optional)(Android-only)-Listen-for-FCM-messages-in-the-background).
+
+You have to send a push to your application, like with Firebase for Android and with a library supporting PushKit pushes for iOS.
+
+### PushKit
+
+Since iOS 13, you'll have to report the incoming calls that wakes up your application with a VoIP push. Add this in your `AppDelegate.m` if you're using VoIP pushes to wake up your application :
+
+```objective-c
+- (void)pushRegistry:(PKPushRegistry *)registry didReceiveIncomingPushWithPayload:(PKPushPayload *)payload forType:(PKPushType)type withCompletionHandler:(void (^)(void))completion {
+  // Process the received push
+  [RNVoipPushNotificationManager didReceiveIncomingPushWithPayload:payload forType:(NSString *)type];
+  
+  // Retrieve information like handle and callerName here
+  // NSString *uuid = /* fetch for payload or ... */ [[[NSUUID UUID] UUIDString] lowercaseString];
+  // NSString *callerName = @"caller name here";
+  // NSString *handle = @"caller number here";
+  
+  [RNCallKeep reportNewIncomingCall:uuid handle:handle handleType:@"generic" hasVideo:false localizedCallerName:callerName fromPushKit: YES];
+
+  completion();
+}
+```
+
 ## Debug
 
 ### Android

actions.js

@@ -13,10 +13,17 @@ const RNCallKeepDidPerformSetMutedCallAction = 'RNCallKeepDidPerformSetMutedCall
 const RNCallKeepDidToggleHoldAction = 'RNCallKeepDidToggleHoldAction';
 const RNCallKeepDidPerformDTMFAction = 'RNCallKeepDidPerformDTMFAction';
 const RNCallKeepProviderReset = 'RNCallKeepProviderReset';
+const RNCallKeepCheckReachability = 'RNCallKeepCheckReachability';
 const isIOS = Platform.OS === 'ios';
 
-const didReceiveStartCallAction = handler => 
-  eventEmitter.addListener(RNCallKeepDidReceiveStartCallAction, (data) => handler(data));
+const didReceiveStartCallAction = handler => {
+  if (isIOS) {
+    // Tell CallKeep that we are ready to receive `RNCallKeepDidReceiveStartCallAction` event and prevent delay
+    RNCallKeepModule._startCallActionEventListenerAdded();
+  }
+
+  return eventEmitter.addListener(RNCallKeepDidReceiveStartCallAction, (data) => handler(data));
+};
 
 const answerCall = handler =>
   eventEmitter.addListener(RNCallKeepPerformAnswerCallAction, (data) => handler(data));
@@ -45,6 +52,9 @@ const didPerformDTMFAction = handler =>
 const didResetProvider = handler =>
   eventEmitter.addListener(RNCallKeepProviderReset, handler);
 
+const checkReachability = handler =>
+  eventEmitter.addListener(RNCallKeepCheckReachability, handler);
+
 export const listeners = {
   didReceiveStartCallAction,
   answerCall,
@@ -56,5 +66,5 @@ export const listeners = {
   didToggleHoldCallAction,
   didPerformDTMFAction,
   didResetProvider,
+  checkReachability,
 };
-

android/src/main/java/io/wazo/callkeep/RNCallKeepBackgroundMessagingService.java

@@ -0,0 +1,48 @@
+/*
+ * Copyright (c) 2016-2019 The CallKeep Authors (see the AUTHORS file)
+ * SPDX-License-Identifier: ISC, MIT
+ *
+ * Permission to use, copy, modify, and distribute this software for any
+ * purpose with or without fee is hereby granted, provided that the above
+ * copyright notice and this permission notice appear in all copies.
+ *
+ * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
+ * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
+ * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
+ * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
+ * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
+ * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
+ * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
+ */
+
+package io.wazo.callkeep;
+
+import android.content.Intent;
+import android.os.Bundle;
+import android.util.Log;
+
+import com.facebook.react.HeadlessJsTaskService;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.Arguments;
+import com.facebook.react.jstasks.HeadlessJsTaskConfig;
+
+import static io.wazo.callkeep.RNCallKeepModule.EXTRA_CALLER_NAME;
+import static io.wazo.callkeep.RNCallKeepModule.EXTRA_CALL_NUMBER;
+import static io.wazo.callkeep.RNCallKeepModule.EXTRA_CALL_UUID;
+
+import javax.annotation.Nullable;
+
+public class RNCallKeepBackgroundMessagingService extends HeadlessJsTaskService {
+  @Override
+  protected @Nullable
+  HeadlessJsTaskConfig getTaskConfig(Intent intent) {
+    Bundle extras = intent.getExtras();
+
+    return new HeadlessJsTaskConfig(
+      "RNCallKeepBackgroundMessage",
+      Arguments.fromBundle(extras),
+      60000,
+      false
+    );
+  }
+}