Bugfix/1688/fix call background death

.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

@@ -318,6 +318,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

@@ -13,7 +13,6 @@
 import android.content.pm.PackageManager;
 import android.os.Build;
 import android.os.Bundle;
-import android.os.PowerManager;
 import android.util.Log;
 import android.util.Rational;
 import android.view.View;
@@ -30,14 +29,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 +46,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 +94,82 @@ 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. On API 31+ auto-enter handles swipe-up/home, and plain
+        // backgrounding (e.g. task switch) keeps the activity alive on its own. Deliberately no
+        // moveTaskToBack here: onUserLeaveHint also fires when a transient overlay like the
+        // permission dialog appears at call start, which would throw the call to the background.
+        if (!isInPipMode
+                && isPipModePossible()
+                && Build.VERSION.SDK_INT < Build.VERSION_CODES.S) {
             enterPipMode();
         }
     }
 
     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);
         }
     }
 
@@ -138,19 +184,6 @@ boolean isPipModePossible() {
             return deviceHasPipFeature && isPipFeatureGranted;
     }
 
-    private boolean shouldFinishOnStop() {
-        if (!isInPipMode) {
-            return false;
-        }
-
-        PowerManager powerManager = (PowerManager) getSystemService(Context.POWER_SERVICE);
-        if (powerManager == null) {
-            return true;
-        }
-
-        return powerManager.isInteractive();
-    }
-
     public abstract void updateUiForPipMode();
 
     public abstract void updateUiForNormalMode();

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

@@ -370,6 +370,7 @@ class ChatActivity :
     private lateinit var path: String
 
     var myFirstMessage: CharSequence? = null
+    private var isLeavingRoom: Boolean = false
 
     private var lastHandledHighlightNonce: Long? = null
     private var pendingHighlightedMessageId: Long? = null
@@ -422,6 +423,24 @@ class ChatActivity :
 
     val typingParticipants = HashMap<String, TypingParticipant>()
 
+    private val leaveRoomObserver = androidx.lifecycle.Observer<ChatViewModel.ViewState> { state ->
+        when (state) {
+            is ChatViewModel.LeaveRoomSuccessState -> {
+                logConversationInfos("leaveRoom#onNext")
+
+                isLeavingRoom = false
+
+                if (getRoomInfoTimerHandler != null) {
+                    getRoomInfoTimerHandler?.removeCallbacksAndMessages(null)
+                }
+
+                ApplicationWideCurrentRoomHolder.getInstance().clear()
+            }
+
+            else -> {}
+        }
+    }
+
     private val localParticipantMessageListener = SignalingMessageReceiver.LocalParticipantMessageListener { token ->
         if (CallActivity.active) {
             Log.d(TAG, "CallActivity is running. Ignore to switch chat in ChatActivity...")
@@ -1468,6 +1487,8 @@ class ChatActivity :
             }
         }
 
+        chatViewModel.leaveRoomViewState.observeForever(leaveRoomObserver)
+
         messageInputViewModel.sendChatMessageViewState.observe(this) { state ->
             when (state) {
                 is MessageInputViewModel.SendChatMessageSuccessState -> {
@@ -1821,6 +1842,9 @@ class ChatActivity :
 
         pullChatMessagesPending = false
 
+        // reset in case a previously started leave failed (success already resets this in leaveRoomObserver)
+        isLeavingRoom = false
+
         webSocketInstance?.getSignalingMessageReceiver()?.addListener(localParticipantMessageListener)
         webSocketInstance?.getSignalingMessageReceiver()?.addListener(conversationMessageListener)
 
@@ -2760,11 +2784,13 @@ class ChatActivity :
         }
 
         if (::conversationUser.isInitialized && 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...")
@@ -2819,6 +2845,8 @@ class ChatActivity :
         super.onDestroy()
         logConversationInfos("onDestroy")
 
+        chatViewModel.leaveRoomViewState.removeObserver(leaveRoomObserver)
+
         findViewById<View>(R.id.toolbar)?.setOnClickListener(null)
 
         if (actionBar != null) {
@@ -2854,6 +2882,7 @@ class ChatActivity :
 
     fun leaveRoom(functionToCallAfterLeave: (() -> Unit)?) {
         logConversationInfos("leaveRoom")
+        isLeavingRoom = true
 
         // Send the HPB "leave room" immediately, before waiting for the backend DELETE to
         // confirm. This minimises the window in which the HPB could still consider the user

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