Implement persistent foreground service to keep calls active in background, with notification controls for managing the call

.gitignore

@@ -21,6 +21,7 @@ target/
 # Local configuration files (sdk path, etc)
 local.properties
 tests/local.properties
+.vscode/
 
 # Mac .DS_Store files
 .DS_Store

app/src/main/AndroidManifest.xml

@@ -193,7 +193,6 @@
         <activity
             android:name=".activities.CallActivity"
             android:configChanges="screenSize|smallestScreenSize|screenLayout|orientation"
-            android:excludeFromRecents="true"
             android:launchMode="singleTask"
             android:showOnLockScreen="true"
             android:supportsPictureInPicture="true"
@@ -313,6 +312,7 @@
         <receiver android:name=".receivers.DeclineCallReceiver" android:exported="false" />
         <receiver android:name=".receivers.DismissRecordingAvailableReceiver" />
         <receiver android:name=".receivers.ShareRecordingToChatReceiver" />
+        <receiver android:name=".receivers.EndCallReceiver" />
 
         <service
             android:name=".utils.SyncService"

app/src/main/java/com/nextcloud/talk/activities/CallBaseActivity.java

@@ -30,14 +30,14 @@ public abstract class CallBaseActivity extends BaseActivity {
 
     public PictureInPictureParams.Builder mPictureInPictureParamsBuilder;
     public Boolean isInPipMode = Boolean.FALSE;
-    long onCreateTime;
 
-
-    private OnBackPressedCallback onBackPressedCallback = new OnBackPressedCallback(true) {
+    private final OnBackPressedCallback onBackPressedCallback = new OnBackPressedCallback(true) {
         @Override
         public void handleOnBackPressed() {
             if (isPipModePossible()) {
                 enterPipMode();
+            } else {
+                moveTaskToBack(true);
             }
         }
     };
@@ -47,21 +47,25 @@ public void handleOnBackPressed() {
     public void onCreate(Bundle savedInstanceState) {
         super.onCreate(savedInstanceState);
 
-        onCreateTime = System.currentTimeMillis();
-
         requestWindowFeature(Window.FEATURE_NO_TITLE);
         dismissKeyguard();
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN);
         getWindow().addFlags(WindowManager.LayoutParams.FLAG_KEEP_SCREEN_ON);
 
         if (isPipModePossible()) {
             mPictureInPictureParamsBuilder = new PictureInPictureParams.Builder();
+            Rational pipRatio = new Rational(300, 500);
+            mPictureInPictureParamsBuilder.setAspectRatio(pipRatio);
+            if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S) {
+                mPictureInPictureParamsBuilder.setAutoEnterEnabled(true);
+            }
+            setPictureInPictureParams(mPictureInPictureParamsBuilder.build());
         }
 
         getOnBackPressedDispatcher().addCallback(this, onBackPressedCallback);
     }
 
-    public void hideNavigationIfNoPipAvailable(){
+    public void hideNavigationIfNoPipAvailable() {
         if (!isPipModePossible()) {
             getWindow().getDecorView().setSystemUiVisibility(View.SYSTEM_UI_FLAG_LAYOUT_STABLE |
                                                                  View.SYSTEM_UI_FLAG_LAYOUT_HIDE_NAVIGATION |
@@ -91,39 +95,89 @@ void enableKeyguard() {
         }
     }
 
+    /**
+     * On API 29+, fires BEFORE onPause while the window is still fully visible.
+     *
+     * On API 29-30: enter PIP immediately (no auto-enter available).
+     *
+     * On API 31+: auto-enter handles swipe-up/home gestures. Task switching
+     * (left/right swipe) does NOT trigger auto-enter — we accept no PIP for
+     * task switch since the call stays alive in the background via the ICE
+     * failure guard in CallActivity.
+     */
+    @Override
+    public void onTopResumedActivityChanged(boolean isTopResumedActivity) {
+        super.onTopResumedActivityChanged(isTopResumedActivity);
+        Log.d(TAG, "onTopResumedActivityChanged: isTopResumedActivity=" + isTopResumedActivity
+                + " isInPictureInPictureMode=" + isInPictureInPictureMode());
+        if (isTopResumedActivity || isInPictureInPictureMode()
+                || !isPipModePossible()
+                || isChangingConfigurations()
+                || isFinishing()) {
+            return;
+        }
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
+            enterPipMode();
+        }
+    }
+
+    @Override
+    public void onPause() {
+        super.onPause();
+        Log.d(TAG, "onPause: isInPipMode=" + isInPipMode
+                + " isInPictureInPictureMode=" + isInPictureInPictureMode());
+        // Fallback for API 26-28 where onTopResumedActivityChanged doesn't exist.
+        // On API 29+, onTopResumedActivityChanged already handled this.
+        if (Build.VERSION.SDK_INT < Build.VERSION_CODES.Q
+                && !isInPictureInPictureMode()
+                && isPipModePossible()
+                && !isChangingConfigurations()
+                && !isFinishing()) {
+            enterPipMode();
+        }
+    }
+
     @Override
     public void onStop() {
         super.onStop();
-        if (shouldFinishOnStop()) {
-            finish();
-        }
+        Log.d(TAG, "onStop: isInPipMode=" + isInPipMode + " isFinishing=" + isFinishing());
     }
 
     @Override
     protected void onUserLeaveHint() {
         super.onUserLeaveHint();
-        long onUserLeaveHintTime = System.currentTimeMillis();
-        long diff = onUserLeaveHintTime - onCreateTime;
-        Log.d(TAG, "onUserLeaveHintTime - onCreateTime: " + diff);
-
-        if (diff < 3000) {
-            Log.d(TAG, "enterPipMode skipped");
-        } else {
+        Log.d(TAG, "onUserLeaveHint: isInPipMode=" + isInPipMode
+                + " isInPictureInPictureMode=" + isInPictureInPictureMode());
+        // On API 26-30, enter PIP manually.
+        if (!isInPipMode
+                && isPipModePossible()
+                && Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
             enterPipMode();
+            return;
+        }
+        // On API 31+: if auto-enter didn't handle it (task switch), move the
+        // task to back so the activity survives instead of being destroyed
+        // (excludeFromRecents + separate taskAffinity causes task death).
+        if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.S
+                && !isInPictureInPictureMode()
+                && isPipModePossible()) {
+            Log.d(TAG, "onUserLeaveHint: not PIP, moving task to back to survive task switch");
+            moveTaskToBack(true);
         }
     }
 
     void enterPipMode() {
+        Log.d(TAG, "enterPipMode: isPipModePossible=" + isPipModePossible() + " isInPipMode=" + isInPipMode);
         enableKeyguard();
         if (isPipModePossible()) {
             Rational pipRatio = new Rational(300, 500);
             mPictureInPictureParamsBuilder.setAspectRatio(pipRatio);
-            enterPictureInPictureMode(mPictureInPictureParamsBuilder.build());
+            boolean entered = enterPictureInPictureMode(mPictureInPictureParamsBuilder.build());
+            Log.d(TAG, "enterPictureInPictureMode returned: " + entered);
         } else {
-            // we don't support other solutions than PIP to have a call in the background.
-            // If PIP is not available the call is ended when user presses the home button.
-            Log.d(TAG, "Activity was finished because PIP is not available.");
-            finish();
+            // If PIP is not available, move to background instead of finishing
+            Log.d(TAG, "PIP is not available, moving call to background.");
+            moveTaskToBack(true);
         }
     }
 

app/src/main/java/com/nextcloud/talk/chat/ChatActivity.kt

@@ -365,6 +365,8 @@ class ChatActivity :
     private lateinit var path: String
 
     var myFirstMessage: CharSequence? = null
+    var checkingLobbyStatus: Boolean = false
+    private var isLeavingRoom: Boolean = false
 
     private var lastHandledHighlightNonce: Long? = null
     private var pendingHighlightedMessageId: Long? = null
@@ -416,6 +418,42 @@ class ChatActivity :
 
     val typingParticipants = HashMap<String, TypingParticipant>()
 
+    var callStarted = false
+
+    private val leaveRoomObserver = androidx.lifecycle.Observer<ChatViewModel.ViewState> { state ->
+        when (state) {
+            is ChatViewModel.LeaveRoomSuccessState -> {
+                logConversationInfos("leaveRoom#onNext")
+
+                isLeavingRoom = false
+
+                checkingLobbyStatus = false
+
+                if (getRoomInfoTimerHandler != null) {
+                    getRoomInfoTimerHandler?.removeCallbacksAndMessages(null)
+                }
+
+                ApplicationWideCurrentRoomHolder.getInstance().clear()
+
+                if (webSocketInstance != null && currentConversation != null) {
+                    webSocketInstance?.joinRoomWithRoomTokenAndSession(
+                        "",
+                        sessionIdAfterRoomJoined
+                    )
+                }
+
+                sessionIdAfterRoomJoined = "0"
+
+                if (state.funToCallWhenLeaveSuccessful != null) {
+                    Log.d(TAG, "a callback action was set and is now executed because room was left successfully")
+                    state.funToCallWhenLeaveSuccessful.invoke()
+                }
+            }
+
+            else -> {}
+        }
+    }
+
     private val localParticipantMessageListener = SignalingMessageReceiver.LocalParticipantMessageListener { token ->
         if (CallActivity.active) {
             Log.d(TAG, "CallActivity is running. Ignore to switch chat in ChatActivity...")
@@ -1471,33 +1509,7 @@ class ChatActivity :
             }
         }
 
-        chatViewModel.leaveRoomViewState.observe(this) { state ->
-            when (state) {
-                is ChatViewModel.LeaveRoomSuccessState -> {
-                    logConversationInfos("leaveRoom#onNext")
-
-                    if (getRoomInfoTimerHandler != null) {
-                        getRoomInfoTimerHandler?.removeCallbacksAndMessages(null)
-                    }
-
-                    if (webSocketInstance != null && currentConversation != null) {
-                        webSocketInstance?.joinRoomWithRoomTokenAndSession(
-                            "",
-                            sessionIdAfterRoomJoined
-                        )
-                    }
-
-                    sessionIdAfterRoomJoined = "0"
-
-                    if (state.funToCallWhenLeaveSuccessful != null) {
-                        Log.d(TAG, "a callback action was set and is now executed because room was left successfully")
-                        state.funToCallWhenLeaveSuccessful.invoke()
-                    }
-                }
-
-                else -> {}
-            }
-        }
+        chatViewModel.leaveRoomViewState.observeForever(leaveRoomObserver)
 
         messageInputViewModel.sendChatMessageViewState.observe(this) { state ->
             when (state) {
@@ -2750,11 +2762,13 @@ class ChatActivity :
         }
 
         if (conversationUser != null && isActivityNotChangingConfigurations() && isNotInCall()) {
-            ApplicationWideCurrentRoomHolder.getInstance().clear()
-            if (validSessionId()) {
+            if (isLeavingRoom) {
+                Log.d(TAG, "not leaving room (leave already in progress)")
+            } else if (validSessionId()) {
                 leaveRoom(null)
             } else {
                 Log.d(TAG, "not leaving room (validSessionId is false)")
+                ApplicationWideCurrentRoomHolder.getInstance().clear()
             }
         } else {
             Log.d(TAG, "not leaving room...")
@@ -2809,6 +2823,8 @@ class ChatActivity :
         super.onDestroy()
         logConversationInfos("onDestroy")
 
+        chatViewModel.leaveRoomViewState.removeObserver(leaveRoomObserver)
+
         findViewById<View>(R.id.toolbar)?.setOnClickListener(null)
 
         if (actionBar != null) {
@@ -2844,6 +2860,7 @@ class ChatActivity :
 
     fun leaveRoom(funToCallWhenLeaveSuccessful: (() -> Unit)?) {
         logConversationInfos("leaveRoom")
+        isLeavingRoom = true
 
         var apiVersion = 1
         // FIXME Fix API checking with guests?

app/src/main/java/com/nextcloud/talk/receivers/EndCallReceiver.kt

@@ -0,0 +1,37 @@
+/*
+ * Nextcloud Talk - Android Client
+ *
+ * SPDX-FileCopyrightText: 2024 Nextcloud GmbH and Nextcloud contributors
+ * SPDX-License-Identifier: GPL-3.0-or-later
+ */
+package com.nextcloud.talk.receivers
+
+import android.content.BroadcastReceiver
+import android.content.Context
+import android.content.Intent
+import android.util.Log
+import com.nextcloud.talk.services.CallForegroundService
+
+class EndCallReceiver : BroadcastReceiver() {
+    companion object {
+        private val TAG = EndCallReceiver::class.simpleName
+        const val END_CALL_ACTION = "com.nextcloud.talk.END_CALL"
+        const val END_CALL_FROM_NOTIFICATION = "com.nextcloud.talk.END_CALL_FROM_NOTIFICATION"
+    }
+
+    override fun onReceive(context: Context?, intent: Intent?) {
+        if (intent?.action == END_CALL_ACTION) {
+            Log.i(TAG, "Received end call broadcast")
+
+            // Stop the foreground service
+            context?.let {
+                CallForegroundService.stop(it)
+
+                // Send broadcast to CallActivity to end the call
+                val endCallIntent = Intent(END_CALL_FROM_NOTIFICATION)
+                endCallIntent.setPackage(context.packageName)
+                context.sendBroadcast(endCallIntent)
+            }
+        }
+    }
+}