Merge pull request #79 from react-native-webrtc/wakeup_outgoing_call

Wakeup on outgoing call

Author: manuquentin

README.md

@@ -352,6 +352,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 }) => {
 

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
+    );
+  }
+}

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

@@ -204,8 +204,8 @@ public void run() {
                     Bundle extras = new Bundle();
                     extras.putSerializable("attributeMap", attributeMap);
                     intent.putExtras(extras);
-                    LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
                 }
+                LocalBroadcastManager.getInstance(context).sendBroadcast(intent);
             }
         });
     }

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

@@ -19,6 +19,8 @@
 
 import android.annotation.TargetApi;
 import android.content.Intent;
+import android.content.Context;
+import android.content.ComponentName;
 import android.net.Uri;
 import android.os.Build;
 import android.os.Bundle;
@@ -35,6 +37,13 @@
 import android.telecom.TelecomManager;
 import android.util.Log;
 
+import android.app.ActivityManager;
+import android.app.ActivityManager.RunningTaskInfo;
+
+import com.facebook.react.HeadlessJsTaskService;
+import com.facebook.react.bridge.ReactContext;
+import com.facebook.react.common.LifecycleState;
+
 import java.util.ArrayList;
 import java.util.HashMap;
 import java.util.Iterator;
@@ -103,29 +112,46 @@ public Connection onCreateIncomingConnection(PhoneAccountHandle connectionManage
 
     @Override
     public Connection onCreateOutgoingConnection(PhoneAccountHandle connectionManagerPhoneAccount, ConnectionRequest request) {
-        if (!this.canMakeOutgoingCall()) {
-            return Connection.createFailedConnection(new DisconnectCause(DisconnectCause.LOCAL));
-        }
-        // TODO: Hold all other calls
-
         Bundle extras = request.getExtras();
         Connection outgoingCallConnection = null;
         String number = request.getAddress().getSchemeSpecificPart();
         String extrasNumber = extras.getString(EXTRA_CALL_NUMBER);
-        String name = extras.getString(EXTRA_CALLER_NAME);
+        String displayName = extras.getString(EXTRA_CALLER_NAME);
+        String uuid = UUID.randomUUID().toString();
+
+         Log.d(TAG, "onCreateOutgoingConnection:" + uuid + ", number: " + number);
+
+        // Wakeup application if needed
+        if (!VoiceConnectionService.isRunning(this.getApplicationContext())) {
+            Log.d(TAG, "onCreateOutgoingConnection: Waking up application");
+            Intent headlessIntent = new Intent(
+                this.getApplicationContext(),
+                RNCallKeepBackgroundMessagingService.class
+            );
+            headlessIntent.putExtra("callUUID", uuid);
+            headlessIntent.putExtra("name", displayName);
+            headlessIntent.putExtra("handle", number);
+            ComponentName name = this.getApplicationContext().startService(headlessIntent);
+            if (name != null) {
+              HeadlessJsTaskService.acquireWakeLockNow(this.getApplicationContext());
+            }
+        } else if (!this.canMakeOutgoingCall()) {
+            return Connection.createFailedConnection(new DisconnectCause(DisconnectCause.LOCAL));
+        }
 
+        // TODO: Hold all other calls
         if (extrasNumber != null && extrasNumber.equals(number)) {
             outgoingCallConnection = createConnection(request);
         } else {
-            String uuid = UUID.randomUUID().toString();
             extras.putString(EXTRA_CALL_UUID, uuid);
-            extras.putString(EXTRA_CALLER_NAME, name);
+            extras.putString(EXTRA_CALLER_NAME, displayName);
             extras.putString(EXTRA_CALL_NUMBER, number);
             outgoingCallConnection = createConnection(request);
         }
+
         outgoingCallConnection.setDialing();
         outgoingCallConnection.setAudioModeIsVoip(true);
-        outgoingCallConnection.setCallerDisplayName(name, TelecomManager.PRESENTATION_ALLOWED);
+        outgoingCallConnection.setCallerDisplayName(displayName, TelecomManager.PRESENTATION_ALLOWED);
         outgoingCallConnection.setInitialized();
 
         HashMap<String, String> extrasMap = this.bundleToMap(extras);
@@ -197,8 +223,8 @@ public void run() {
                     Bundle extras = new Bundle();
                     extras.putSerializable("attributeMap", attributeMap);
                     intent.putExtras(extras);
-                    LocalBroadcastManager.getInstance(instance).sendBroadcast(intent);
                 }
+                LocalBroadcastManager.getInstance(instance).sendBroadcast(intent);
             }
         });
     }
@@ -216,4 +242,22 @@ private HashMap<String, String> bundleToMap(Bundle extras) {
         }
         return extrasMap;
     }
+
+    /**
+     * https://stackoverflow.com/questions/5446565/android-how-do-i-check-if-activity-is-running
+     *
+     * @param context Context
+     * @return boolean
+     */
+    public static boolean isRunning(Context context) {
+        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
+        List<RunningTaskInfo> tasks = activityManager.getRunningTasks(Integer.MAX_VALUE);
+
+        for (RunningTaskInfo task : tasks) {
+            if (context.getPackageName().equalsIgnoreCase(task.baseActivity.getPackageName()))
+                return true;
+        }
+
+        return false;
+    }
 }

docs/android-installation.md

@@ -79,3 +79,22 @@ public class MainActivity extends ReactActivity {
     // ....
 </application>
 ```
+
+2. To be able to wake up your killed application when making an outgoing call form the native Phone application:
+
+Add this in the `application` node of `android/app/src/main/AndroidManifest.xml` :
+
+```xml
+<service android:name="io.wazo.callkeep.RNCallKeepBackgroundMessagingService" />
+```
+
+
+In your `index.android.js` file :
+
+```js
+AppRegistry.registerHeadlessTask('RNCallKeepBackgroundMessage', () => ({ name, callUUID, handle }) => {
+  // Make your call here
+  
+  return Promise.resolve();
+});
+```