Merge pull request bkdev98#10 from bkdev98/v2

Version 2 is here 🥳

Author: bkdev98

.npmignore

@@ -0,0 +1,2 @@
+example/
+.github/

README.md

@@ -1,11 +1,31 @@
-# react-native-incoming-call
+# RN Incoming Call Version 2
 
 > React Native module to display custom incoming call activity, best result when using with firebase background messaging. Only for Android since iOS we have VoIP.
 
 Yes I heard you could use **self managed ConnectionService** thing. But since I'm not an Android expert, this is a solution I found acceptable.
 
 You could also wait for [this feature request](https://github.com/react-native-webrtc/react-native-callkeep/issues/43) from `react-native-callkeep` to be resolved and have an easier life.
 
+## Version 2 Breaking Changes
+
+Hello there! It's been a while since I first public version 1 of this library, which contains some bugs that I don't have much time to fix.
+
+Luckily I got a client project which needs this feature again and now I have time to improve it and make sure all major features work. So here is most of it I guess:
+
+[x] More generic incoming call UI.
+
+[x] Work nicely with all application state (foreground, background, killed, locked).
+
+[x] More flexible APIs.
+
+*Thanks to [jpudysz](https://github.com/jpudysz/react-native-callkeep)'s folk of react-native-callkeep, version 2 is heavily depended on it.*
+
+### Migrate from v1
+
+- `getLaunchParameters()` & `clearLaunchParameters()` is now replaced by `openAppFromHeadlessMode()` & `getExtrasFromHeadlessMode()`.
+
+- Answer calls from background / killed state no longer open app and send launchParams, you need to listen to `answerCall` event from headless job and trigger `backToForeground` or `openAppFromHeadlessMode` manually.
+
 ## Getting started
 
 `$ npm install react-native-incoming-call --save`
@@ -16,48 +36,103 @@ or
 
 ### Addition installation step
 
-In `AndroidManifest.xml`, add `<activity android:name="com.incomingcall.UnlockScreenActivity" />` line between `<application>` tag.
+In `AndroidManifest.xml`:
+
+- Add `<activity android:name="com.incomingcall.UnlockScreenActivity" />` line between `<application>` tag.
+
+- Add `<uses-permission android:name="android.permission.VIBRATE" />` permission.
+
+- Also, it's recommend to put `android:launchMode="singleInstance"` in `<activity android:name=".MainActivity"...` tag to prevent duplicate activities.
 
 For RN >= 0.60, it's done. Otherwise:
 
 `$ react-native link react-native-incoming-call`
 
 ## Usage
+
+In `App.js`:
+
 ```javascript
 import {useEffect} from 'react';
+import {DeviceEventEmitter, Platform} from 'react-native';
 import IncomingCall from 'react-native-incoming-call';
 
-// Display incoming call activity. Should be called in backgroundHandler function of react-native-firebase.
-IncomingCall.display(uuid, name, avatar);
-
-// Dismiss current activity. Should be called when call ended.
-IncomingCall.dismiss();
-
 // Listen to cancel and answer call events
 useEffect(() => {
   if (Platform.OS === "android") {
     /**
-     * App in background or killed state, if user press answer button
-     * IncomingCall open app and put payload to getLaunchParameters
-     * You could start the call action here.
-     * End call action in this case not supported yet.
+     * App open from killed state (headless mode)
     */
-    const payload = await IncomingCall.getLaunchParameters();
+    const payload = await IncomingCall.getExtrasFromHeadlessMode();
     console.log('launchParameters', payload);
-    IncomingCall.clearLaunchParameters();
     if (payload) {
-      // Start call here
+      // Start call action here. You probably want to navigate to some CallRoom screen with the payload.uuid.
     }
 
     /**
-     * App in foreground: listen to call events and determine what to do next
+     * App in foreground / background: listen to call events and determine what to do next
     */
     DeviceEventEmitter.addListener("endCall", payload => {
       // End call action here
     });
     DeviceEventEmitter.addListener("answerCall", payload => {
-      // Start call action here
+      // Start call action here. You probably want to navigate to some CallRoom screen with the payload.uuid.
     });
   }
 }, []);
 ```
+
+In `index.js` or anywhere firebase background handler lies: 
+
+```javascript
+import messaging from '@react-native-firebase/messaging';
+import {DeviceEventEmitter} from 'react-native';
+import IncomingCall from 'react-native-incoming-call';
+
+messaging().setBackgroundMessageHandler(async remoteMessage => {
+  // Receive remote message
+  if (remoteMessage?.notification?.title === 'Incoming Call') {
+    // Display incoming call activity.
+    IncomingCall.display(
+      'callUUIDv4', // Call UUID v4
+      'Quocs', // Username
+      'https://avatars3.githubusercontent.com/u/16166195', // Avatar URL
+      'Incomming Call' // Info text
+    );
+  } else if (remoteMessage?.notification?.title === 'Missed Call') {
+    // Terminate incoming activity. Should be called when call expired.
+    IncomingCall.dismiss();
+  }
+
+  // Listen to headless action events
+  DeviceEventEmitter.addListener("endCall", payload => {
+    // End call action here
+  });
+  DeviceEventEmitter.addListener("answerCall", (payload) => {
+    console.log('answerCall', payload);
+    if (payload.isHeadless) {
+      // Called from killed state
+      IncomingCall.openAppFromHeadlessMode(payload.uuid);
+    } else {
+      // Called from background state
+      IncomingCall.backToForeground();
+    }
+  });
+});
+```
+
+## Well-known issues
+
+### Incoming screen not show on android > 9:
+
+You need to turn on autostart and display pop-up windows permissions manually. I'm searching for a better solution.
+
+### No vibration when screen locked:
+
+PR is welcomed! 😂
+
+## License
+
+This project is licensed under the MIT License.
+
+[[email protected]](mailto:[email protected])

android/src/main/java/com/incomingcall/IncomingCallModule.java

@@ -4,18 +4,25 @@
 import android.os.Bundle;
 import android.app.Activity;
 import android.view.WindowManager;
+import android.content.Context;
+import android.util.Log;
 
 import com.facebook.react.bridge.ReactApplicationContext;
 import com.facebook.react.bridge.ReactContextBaseJavaModule;
 import com.facebook.react.bridge.ReactMethod;
 import com.facebook.react.bridge.Callback;
 import com.facebook.react.bridge.Promise;
+import com.facebook.react.bridge.WritableMap;
+import com.facebook.react.bridge.WritableNativeMap;
 
 public class IncomingCallModule extends ReactContextBaseJavaModule {
 
     public static ReactApplicationContext reactContext;
     public static Activity mainActivity;
 
+    private static final String TAG = "RNIC:IncomingCallModule";
+    private WritableMap headlessExtras;
+
     public IncomingCallModule(ReactApplicationContext context) {
         super(context);
         reactContext = context;
@@ -28,7 +35,7 @@ public String getName() {
     }
 
     @ReactMethod
-    public void display(String uuid, String name, String avatar) {
+    public void display(String uuid, String name, String avatar, String info) {
         if (UnlockScreenActivity.active) {
             return;
         }
@@ -37,6 +44,7 @@ public void display(String uuid, String name, String avatar) {
             bundle.putString("uuid", uuid);
             bundle.putString("name", name);
             bundle.putString("avatar", avatar);
+            bundle.putString("info", info);
             Intent i = new Intent(reactContext, UnlockScreenActivity.class);
             i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
             i.addFlags(WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED +
@@ -52,31 +60,63 @@ public void display(String uuid, String name, String avatar) {
     public void dismiss() {
         final Activity activity = reactContext.getCurrentActivity();
 
-        // if (MainActivity.active) {
-        //     Intent i = new Intent(reactContext, MainActivity.class);
-        //     i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_CLEAR_TOP | Intent.FLAG_ACTIVITY_SINGLE_TOP);
-        //     reactContext.getApplicationContext().startActivity(i);
-        // }
         assert activity != null;
     }
 
+    private Context getAppContext() {
+        return this.reactContext.getApplicationContext();
+    }
+
     @ReactMethod
-    public void getLaunchParameters(final Promise promise) {
-        final Activity activity = getCurrentActivity();
-        final Intent intent = activity.getIntent();
-        Bundle b = intent.getExtras();
-        String value = "";
-        if (b != null) {
-            value = b.getString("uuid", "");            
+    public void backToForeground() {
+        Context context = getAppContext();
+        String packageName = context.getApplicationContext().getPackageName();
+        Intent focusIntent = context.getPackageManager().getLaunchIntentForPackage(packageName).cloneFilter();
+        Activity activity = getCurrentActivity();
+        boolean isOpened = activity != null;
+        Log.d(TAG, "backToForeground, app isOpened ?" + (isOpened ? "true" : "false"));
+
+        if (isOpened) {
+            focusIntent.addFlags(Intent.FLAG_ACTIVITY_REORDER_TO_FRONT);
+            activity.startActivity(focusIntent);
         }
-        promise.resolve(value);
     }
 
     @ReactMethod
-    public void clearLaunchParameters() {
-        final Activity activity = getCurrentActivity();
-        final Intent intent = activity.getIntent();
-        Bundle b = new Bundle();
-        intent.putExtras(b);
+    public void openAppFromHeadlessMode(String uuid) {
+        Context context = getAppContext();
+        String packageName = context.getApplicationContext().getPackageName();
+        Intent focusIntent = context.getPackageManager().getLaunchIntentForPackage(packageName).cloneFilter();
+        Activity activity = getCurrentActivity();
+        boolean isOpened = activity != null;
+
+        if (!isOpened) {
+            focusIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK |
+                    WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON |
+                    WindowManager.LayoutParams.FLAG_SHOW_WHEN_LOCKED |
+                    WindowManager.LayoutParams.FLAG_DISMISS_KEYGUARD |
+                    WindowManager.LayoutParams.FLAG_TURN_SCREEN_ON);
+
+            final WritableMap response = new WritableNativeMap();
+            response.putBoolean("isHeadless", true);
+            response.putString("uuid", uuid);
+
+            this.headlessExtras = response;
+
+            getReactApplicationContext().startActivity(focusIntent);
+        }
+    }
+
+    @ReactMethod
+    public void getExtrasFromHeadlessMode(Promise promise) {
+        if (this.headlessExtras != null) {
+            promise.resolve(this.headlessExtras);
+
+            this.headlessExtras = null;
+
+            return;
+        }
+
+        promise.resolve(null);
     }
 }

android/src/main/java/com/incomingcall/UnlockScreenActivity.java

@@ -16,6 +16,7 @@
 
 import androidx.appcompat.app.AppCompatActivity;
 import android.app.ActivityManager;
+import android.app.ActivityManager.RunningAppProcessInfo;
 
 import com.facebook.react.bridge.Arguments;
 import com.facebook.react.bridge.ReactContext;
@@ -30,6 +31,7 @@ public class UnlockScreenActivity extends AppCompatActivity implements UnlockScr
 
     private static final String TAG = "MessagingService";
     private TextView tvName;
+    private TextView tvInfo;
     private ImageView ivAvatar;
     private String uuid = "";
     static boolean active = false;
@@ -56,6 +58,7 @@ protected void onCreate(Bundle savedInstanceState) {
         setContentView(R.layout.activity_call_incoming);
 
         tvName = findViewById(R.id.tvName);
+        tvInfo = findViewById(R.id.tvInfo);
         ivAvatar = findViewById(R.id.ivAvatar);
 
         Bundle bundle = getIntent().getExtras();
@@ -67,6 +70,10 @@ protected void onCreate(Bundle savedInstanceState) {
                 String name = bundle.getString("name");
                 tvName.setText(name);
             }
+            if (bundle.containsKey("info")) {
+                String info = bundle.getString("info");
+                tvInfo.setText(info);
+            }
             if (bundle.containsKey("avatar")) {
                 String avatar = bundle.getString("avatar");
                 if (avatar != null) {
@@ -117,46 +124,27 @@ public void onBackPressed() {
 
     private void acceptDialing() {
         WritableMap params = Arguments.createMap();
-        params.putBoolean("done", true);
+        params.putBoolean("accept", true);
         params.putString("uuid", uuid);
-
-        if (IncomingCallModule.reactContext.hasCurrentActivity() && isAppOnForeground(IncomingCallModule.reactContext)) {
-            // App in foreground, send event for app to listen
-            sendEvent("answerCall", params);
-        } else {
-            // App in background or killed, start app and add launch params
-            String packageNames = IncomingCallModule.reactContext.getPackageName();
-            Intent launchIntent = IncomingCallModule.reactContext.getPackageManager().getLaunchIntentForPackage(packageNames);
-            String className = launchIntent.getComponent().getClassName();
-            try {
-                Class<?> activityClass = Class.forName(className);
-                Intent i = new Intent(IncomingCallModule.reactContext, activityClass);
-                i.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_REORDER_TO_FRONT | Intent.FLAG_ACTIVITY_SINGLE_TOP);
-                Bundle b = new Bundle();
-                b.putString("uuid", uuid);
-                i.putExtras(b);
-                IncomingCallModule.reactContext.startActivity(i);
-            } catch (Exception e) {
-                Log.e("RNIncomingCall", "Class not found", e);
-                return;
-            }
+        if (!IncomingCallModule.reactContext.hasCurrentActivity()) {
+            params.putBoolean("isHeadless", true);
         }
 
+        sendEvent("answerCall", params);
+
         finish();
     }
 
     private void dismissDialing() {
         WritableMap params = Arguments.createMap();
-        params.putBoolean("done", false);
+        params.putBoolean("accept", false);
         params.putString("uuid", uuid);
-
-        if (IncomingCallModule.reactContext.hasCurrentActivity()) {
-            // App in foreground or background, send event for app to listen
-            sendEvent("endCall", params);
-        } else {
-            // App killed, need to do something after
+        if (!IncomingCallModule.reactContext.hasCurrentActivity()) {
+            params.putBoolean("isHeadless", true);
         }
 
+        sendEvent("endCall", params);
+
         finish();
     }
 
@@ -193,24 +181,4 @@ private void sendEvent(String eventName, WritableMap params) {
                 .getJSModule(DeviceEventManagerModule.RCTDeviceEventEmitter.class)
                 .emit(eventName, params);
     }
-
-    private boolean isAppOnForeground(ReactApplicationContext context) {
-        /**
-         * We need to check if app is in foreground otherwise the app will crash.
-         * http://stackoverflow.com/questions/8489993/check-android-application-is-in-foreground-or-not
-         **/
-        ActivityManager activityManager = (ActivityManager) context.getSystemService(Context.ACTIVITY_SERVICE);
-        List<ActivityManager.RunningAppProcessInfo> appProcesses = activityManager.getRunningAppProcesses();
-        if (appProcesses == null) {
-            return false;
-        }
-        final String packageName = context.getPackageName();
-        for (ActivityManager.RunningAppProcessInfo appProcess : appProcesses) {
-            if (appProcess.importance == ActivityManager.RunningAppProcessInfo.IMPORTANCE_FOREGROUND
-                    && appProcess.processName.equals(packageName)) {
-                return true;
-            }
-        }
-        return false;
-    }
 }