Android Self-Managed Calls

plugin.xml

@@ -21,22 +21,35 @@
         <config-file parent="/*" target="AndroidManifest.xml">
             <uses-permission android:name="android.permission.CALL_PHONE"/>
             <uses-permission android:name="android.permission.MANAGE_OWN_CALLS"/>
-            <uses-permission android:name="android.permission.READ_PHONE_NUMBERS"/>
-            <uses-permission android:name="android.permission.READ_PHONE_STATE"/>
+            <uses-permission android:name="android.permission.READ_PHONE_NUMBERS"/> <!-- needed by TelecomManager.getPhoneAccount() -->
+            <uses-permission android:name="android.permission.USE_FULL_SCREEN_INTENT" />
         </config-file>
 
         <config-file parent="/manifest/application" target="AndroidManifest.xml">
+            <activity
+                android:name="com.dmarc.cordovacall.IncomingCallActivity"
+                android:showOnLockScreen="true"
+                android:turnScreenOn="true"
+                android:launchMode="singleTask"
+                android:exported="false"
+                android:theme="@style/Theme.AppCompat.NoActionBar"
+            />
             <service android:name="com.dmarc.cordovacall.MyConnectionService"
                      android:permission="android.permission.BIND_TELECOM_CONNECTION_SERVICE"
                      android:exported="true">
                 <intent-filter>
                     <action android:name="android.telecom.ConnectionService" />
                 </intent-filter>
             </service>
+            <receiver android:name="com.dmarc.cordovacall.CallActionReceiver" />
         </config-file>
 
+        <source-file src="src/android/CallActionReceiver.java" target-dir="src/com/dmarc/cordovacall" />
+        <source-file src="src/android/CallNotification.java" target-dir="src/com/dmarc/cordovacall" />
         <source-file src="src/android/CordovaCall.java" target-dir="src/com/dmarc/cordovacall" />
+        <source-file src="src/android/IncomingCallActivity.java" target-dir="src/com/dmarc/cordovacall" />
         <source-file src="src/android/MyConnectionService.java" target-dir="src/com/dmarc/cordovacall" />
+        <source-file src="src/android/PhoneAccountManager.java" target-dir="src/com/dmarc/cordovacall" />
   </platform>
 
     <platform name="ios">

src/android/CallActionReceiver.java

@@ -0,0 +1,41 @@
+package com.dmarc.cordovacall;
+
+import android.app.NotificationManager;
+import android.content.BroadcastReceiver;
+import android.content.Context;
+import android.content.Intent;
+import android.telecom.Connection;
+import android.util.Log;
+
+public class CallActionReceiver extends BroadcastReceiver {
+    static final String TAG = "CallActionReceiver";
+
+    @Override
+    public void onReceive(Context context, Intent intent) {
+        String action = intent.getAction();
+        Log.d(TAG, "onReceive, intent action: " + action);
+        String pushMessagePayload = intent.getStringExtra("pushMessagePayload");
+
+        Connection conn = MyConnectionService.getConnectionByPayload(pushMessagePayload);
+
+        if (conn != null) {
+            if (action.equals("declineCall")) {
+                conn.onReject();
+            } else if (action.equals("answerCall")) {
+                conn.onAnswer();
+            } else {
+                throw new RuntimeException("Invalid action: " + action);
+            }
+        } else {
+            Log.d(TAG, "Exiting, connection no longer exists. pushMessagePayload: " + pushMessagePayload);
+            if (intent.hasExtra("notificationID")) {
+                // For safety ensure any associated notification is closed (avoids bad UX if the normal logic
+                // that closes the notification when the connection is disconnected fails/crashes/etc.)
+                int notificationID = intent.getIntExtra("notificationID", 0);
+                Log.e(TAG, "Closing orphaned notification, ID: " + notificationID);
+                NotificationManager nm = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+                nm.cancel(notificationID);
+            }
+        }
+    }
+}

src/android/CallNotification.java

@@ -0,0 +1,153 @@
+package com.dmarc.cordovacall;
+
+import android.app.NotificationChannel;
+import android.app.NotificationManager;
+import android.app.PendingIntent;
+import android.content.Context;
+import android.content.Intent;
+import android.graphics.BitmapFactory;
+import android.media.RingtoneManager;
+import android.net.Uri;
+import android.os.Build;
+import android.os.Handler;
+import android.util.Log;
+
+import androidx.core.app.NotificationCompat;
+import androidx.core.app.Person;
+import org.json.JSONException;
+import org.json.JSONObject;
+
+import java.net.URI;
+import java.util.Random;
+
+
+public class CallNotification {
+    private static final String TAG = "CallNotification";
+
+    private String pushMessagePayload;
+    private Integer notificationID;
+    private Context context;
+    private NotificationManager notificationManager;
+    private Runnable timeoutRunnable;
+    private Handler timeoutHandler = new Handler();
+
+    private static final String NOTIFICATION_CHANNEL_ID = "incoming_calls";
+
+    public CallNotification(String pushMessagePayload, Context context) {
+        this.pushMessagePayload = pushMessagePayload;
+        this.notificationID = new Random().nextInt(100000) + 1; // Random int > 0 TODO: maybe derive from call UUID string
+        this.context = context;
+        this.notificationManager = (NotificationManager) context.getSystemService(Context.NOTIFICATION_SERVICE);
+
+        this.createNotificationChannel();
+    }
+
+    public void show() {
+        int timeout = 30000;
+
+        // NOTE: "Notifications should only launch a BroadcastReceiver from notification actions"
+
+        Intent answerIntent = new Intent(this.context, CallActionReceiver.class);
+        answerIntent.setAction("answerCall");
+        answerIntent.putExtra("pushMessagePayload", this.pushMessagePayload);
+        answerIntent.putExtra("notificationID", this.notificationID);
+        PendingIntent answerPendingIntent = PendingIntent.getBroadcast(
+                this.context, 0, answerIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+
+        Intent declineIntent = new Intent(this.context, CallActionReceiver.class);
+        declineIntent.setAction("declineCall");
+        declineIntent.putExtra("pushMessagePayload", this.pushMessagePayload);
+        declineIntent.putExtra("notificationID", this.notificationID);
+        PendingIntent declinePendingIntent = PendingIntent.getBroadcast(
+                this.context, 1, declineIntent,
+                PendingIntent.FLAG_UPDATE_CURRENT | PendingIntent.FLAG_IMMUTABLE
+        );
+
+        JSONObject payload = null;
+        try {
+            payload = new JSONObject(this.pushMessagePayload);
+        } catch (JSONException e) {
+            throw new RuntimeException("CallNotification unable to parse pushMessagePayload, error: " + e);
+        }
+
+        String callerName = payload.optString("from", "UNKNOWN");
+
+        NotificationCompat.Builder builder = new NotificationCompat.Builder(this.context, CallNotification.NOTIFICATION_CHANNEL_ID)
+                .setContentTitle("Incoming call")
+                .setSmallIcon(android.R.drawable.ic_menu_call)
+                .setLargeIcon(BitmapFactory.decodeResource(this.context.getResources(), android.R.drawable.sym_def_app_icon))
+                .setPriority(NotificationCompat.PRIORITY_HIGH)
+                .setCategory(NotificationCompat.CATEGORY_CALL)
+                .setSound(this.getRingtoneURI()) // For compatibility with Android 8.0 and less. (normally set through channel)
+                .setOngoing(true); // Can't be "dismissed" by the user, app will handle closing it
+
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.P) {
+            Log.d(TAG, "Creating CallStyle.forIncomingCall style notification (as this is supported by the device)...");
+            Person callerPerson = new Person.Builder()
+                    .setName(callerName)
+                    .setImportant(true)
+                    .build();
+
+            // "CallStyle notifications must be for a foreground service or user initated job or use a fullScreenIntent."
+            Intent fullScreenIntent = new Intent(this.context, IncomingCallActivity.class);
+            fullScreenIntent.putExtra("pushMessagePayload", this.pushMessagePayload);
+            PendingIntent fullScreenPendingIntent = PendingIntent.getActivity(
+                    this.context, 0, fullScreenIntent,
+                    PendingIntent.FLAG_IMMUTABLE
+            );
+
+            builder.setStyle(NotificationCompat.CallStyle.forIncomingCall(callerPerson, declinePendingIntent, answerPendingIntent));
+            builder.setFullScreenIntent(fullScreenPendingIntent, true);
+        } else {
+            builder.setContentText(callerName);
+            builder.addAction(android.R.drawable.ic_menu_call, "Answer", answerPendingIntent)
+                    .addAction(android.R.drawable.ic_menu_close_clear_cancel, "Decline", declinePendingIntent);
+        }
+
+        Log.d(TAG, "launching call notification via android NotificationManager notify()...");
+        notificationManager.notify(this.notificationID, builder.build());
+
+        if (this.timeoutRunnable != null) {
+            this.timeoutHandler.removeCallbacks(this.timeoutRunnable);
+        }
+
+        this.timeoutRunnable = new Runnable() {
+            @Override
+            public void run() {
+                close();
+            }
+        };
+
+        this.timeoutHandler.postDelayed(timeoutRunnable, timeout);
+    }
+
+    public void close() {
+        Log.d(TAG, "closing call notification");
+        this.notificationManager.cancel(this.notificationID);
+        if (this.timeoutRunnable != null) {
+            this.timeoutHandler.removeCallbacks(this.timeoutRunnable);
+        }
+    }
+
+    private Uri getRingtoneURI() {
+        return RingtoneManager.getDefaultUri(RingtoneManager.TYPE_RINGTONE);
+    }
+
+    // Intentional create the notification channel here (rather than in javascript via window.FirebasePlugin.createChannel)
+    // so that the users default ringtone can be referenced, and so that the channel is guaranteed to be established prior to the notification.
+    // The notification sound on > Android 8.0 comes from the notification channel.
+    private void createNotificationChannel() {
+        NotificationChannel channel = new NotificationChannel(
+                CallNotification.NOTIFICATION_CHANNEL_ID,
+                "Incoming Calls",
+                NotificationManager.IMPORTANCE_HIGH
+        );
+        channel.setDescription("Incoming call alerts");
+        channel.setSound(this.getRingtoneURI(), null);
+        channel.setVibrationPattern(new long[]{ 0, 1000, 500, 1000 });
+        channel.enableVibration(true);
+        this.notificationManager.createNotificationChannel(channel);
+    }
+}