Merge pull request 'feat(ios): env migration for ios 27' (#1077 ) from misha/eatvio_app:main into main

Reviewed-on: eatvio/eatvio_app#1077
feat(ios): env migration for ios 27
2026-10-16 05:27:39 +00:00 · 2026-10-16 08:26:26 +03:00 · 2026-10-15 13:32:29 +00:00 · 2026-10-15 15:22:04 +03:00 · 2026-10-15 15:21:38 +03:00 · 2026-10-15 14:06:37 +03:00
33 changed files with 1030 additions and 191 deletions
--- a/android/app/build.gradle
+++ b/android/app/build.gradle
@@ -69,6 +69,7 @@ android {
 }

 dependencies {
+    testImplementation 'junit:junit:4.13.2'
    implementation platform('com.google.firebase:firebase-bom:34.4.0')
    implementation 'com.google.firebase:firebase-messaging'
    implementation 'com.huawei.agconnect:agconnect-core:1.9.5.300'
--- a/android/app/src/main/kotlin/com/eatvioapp/app/CallKitIntentBridge.kt
+++ b/android/app/src/main/kotlin/com/eatvioapp/app/CallKitIntentBridge.kt
@@ -8,6 +8,10 @@ import com.hiennv.flutter_callkit_incoming.CallkitIncomingBroadcastReceiver

 object CallKitIntentBridge {
    fun dispatchCallKitAction(context: Context, action: String, data: Bundle?) {
+        if (IncomingCallRingtonePolicy.actionStopsRingtone(action)) {
+            VideoCallPushBridge.silenceIncomingCall(context)
+        }
+
        if (data != null) {
            CallKitAcceptIntentMapper.payloadFromBundle(data, action)?.let { payload ->
                PendingCallKitAcceptBridge.store(payload)
--- a/android/app/src/main/kotlin/com/eatvioapp/app/IncomingCallRingtonePolicy.kt
+++ b/android/app/src/main/kotlin/com/eatvioapp/app/IncomingCallRingtonePolicy.kt
@@ -0,0 +1,15 @@
+package com.eatvioapp.app
+
+/**
+ * Call actions that must stop the incoming ringtone.
+ * Accept is included: answering the call is not the same as ending it,
+ * but the ringing player is a separate object from the in-call audio.
+ */
+internal object IncomingCallRingtonePolicy {
+    fun actionStopsRingtone(action: String): Boolean {
+        return action.contains("ACTION_CALL_ACCEPT") ||
+            action.contains("ACTION_CALL_DECLINE") ||
+            action.contains("ACTION_CALL_ENDED") ||
+            action.contains("ACTION_CALL_TIMEOUT")
+    }
+}
--- a/android/app/src/main/kotlin/com/eatvioapp/app/VideoCallPushBridge.kt
+++ b/android/app/src/main/kotlin/com/eatvioapp/app/VideoCallPushBridge.kt
@@ -8,6 +8,7 @@ import android.util.Log
 import androidx.core.app.NotificationCompat
 import androidx.core.app.NotificationManagerCompat
 import com.hiennv.flutter_callkit_incoming.CallkitConstants
+import com.hiennv.flutter_callkit_incoming.CallkitEventCallback
 import com.hiennv.flutter_callkit_incoming.CallkitNotificationManager
 import com.hiennv.flutter_callkit_incoming.CallkitNotificationService
 import com.hiennv.flutter_callkit_incoming.CallkitSoundPlayerManager
@@ -17,14 +18,36 @@ import com.hiennv.flutter_callkit_incoming.addCall
 import com.hiennv.flutter_callkit_incoming.getDataActiveCalls
 import com.hiennv.flutter_callkit_incoming.removeAllCalls
 import java.util.HashMap
+import java.util.concurrent.atomic.AtomicInteger

 object VideoCallPushBridge {
    private const val TAG = "VideoCallPushBridge"
    private const val ANDROID_ACCENT_COLOR = "#2787F5"
    private const val MISSED_CALL_CLEANUP_DELAY_MS = 250L

+    private val mainHandler = Handler(Looper.getMainLooper())
+    private val playbackLock = Any()
+    private val playbackGeneration = AtomicInteger(0)
+
    private var activeSoundManager: CallkitSoundPlayerManager? = null
    private var activeNotificationManager: CallkitNotificationManager? = null
+    private var activeCallBundle: Bundle? = null
+    private var storedAppContext: Context? = null
+    private var ringtoneTimeout: Runnable? = null
+    private var callbackRegistered = false
+
+    /**
+     * The plugin stops only the sound player owned by [FlutterCallkitIncomingPlugin].
+     * Incoming pushes start a different player, so accept/decline never reached it
+     * and the ringtone kept looping until the process died.
+     */
+    private val incomingCallEventCallback = object : CallkitEventCallback {
+        override fun onCallEvent(event: CallkitEventCallback.CallEvent, callData: Bundle) {
+            val context = storedAppContext ?: return
+            Log.i(TAG, "incoming call event=$event, stopping ringtone")
+            silenceIncomingCall(context)
+        }
+    }

    fun isIncomingVideoCall(data: Map<String, String>): Boolean {
        val rawType = data["type"]
@@ -89,18 +112,114 @@ object VideoCallPushBridge {

    fun showIncomingCall(context: Context, data: Map<String, String>) {
        val appContext = context.applicationContext
+        storedAppContext = appContext
+        ensureIncomingCallCallbackRegistered()
+
        val callData = buildCallDataBundle(data)
        if (callData == null) {
            Log.w(TAG, "showIncomingCall: missing conversation uuid, data=$data")
            return
        }

+        val generation = playbackGeneration.incrementAndGet()
        Log.i(TAG, "showIncomingCall: conversation=${callData.getString(CallkitConstants.EXTRA_CALLKIT_ID)}")

+        // Ringtone.play() and stop() must run on the same thread. FCM delivers
+        // pushes on a background thread, while Answer runs on the main thread.
+        mainHandler.post {
+            synchronized(playbackLock) {
+                if (generation != playbackGeneration.get()) {
+                    Log.i(TAG, "showIncomingCall: skipped stale playback generation=$generation")
+                    return@post
+                }
+                startIncomingCallLocked(appContext, callData, generation)
+            }
+        }
+    }
+
+    /**
+     * Stops the ringtone that [showIncomingCall] started and removes the incoming
+     * notification. Safe to call more than once.
+     */
+    fun silenceIncomingCall(context: Context) {
+        val appContext = context.applicationContext
+        storedAppContext = appContext
+        Log.i(TAG, "silenceIncomingCall")
+        playbackGeneration.incrementAndGet()
+        val stop = Runnable {
+            synchronized(playbackLock) {
+                stopPlaybackLocked(appContext)
+            }
+        }
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            stop.run()
+        } else {
+            mainHandler.post(stop)
+        }
+    }
+
+    fun dismissAllIncomingCalls(context: Context) {
+        val appContext = context.applicationContext
+        val calls = getDataActiveCalls(appContext)
+        Log.i(TAG, "dismissAllIncomingCalls: active calls=${calls.size}")
+        playbackGeneration.incrementAndGet()
+
+        val dismiss = Runnable {
+            synchronized(playbackLock) {
+                val notificationManager = resolveNotificationManager(appContext)
+                val bundles = calls.map { it.toBundle() }
+                stopPlaybackLocked(appContext)
+
+                for (bundle in bundles) {
+                    try {
+                        dismissIncomingCallNotification(appContext, notificationManager, bundle)
+                    } catch (error: Exception) {
+                        Log.w(
+                            TAG,
+                            "dismissAllIncomingCalls: failed for call ${bundle.getString(CallkitConstants.EXTRA_CALLKIT_ID)}",
+                            error,
+                        )
+                    }
+                }
+
+                try {
+                    CallkitNotificationService.stopService(appContext)
+                } catch (error: Exception) {
+                    Log.w(TAG, "dismissAllIncomingCalls: failed to stop callkit service", error)
+                }
+
+                try {
+                    removeAllCalls(appContext)
+                } catch (error: Exception) {
+                    Log.w(TAG, "dismissAllIncomingCalls: failed to remove persisted calls", error)
+                }
+
+                stopIncomingRingtone()
+                scheduleMissedCallCleanup(notificationManager, bundles)
+            }
+        }
+
+        if (Looper.myLooper() == Looper.getMainLooper()) {
+            dismiss.run()
+        } else {
+            mainHandler.post(dismiss)
+        }
+    }
+
+    private fun ensureIncomingCallCallbackRegistered() {
+        if (callbackRegistered) return
+        FlutterCallkitIncomingPlugin.registerEventCallback(incomingCallEventCallback)
+        callbackRegistered = true
+    }
+
+    private fun startIncomingCallLocked(appContext: Context, callData: Bundle, generation: Int) {
+        stopPlaybackLocked(appContext)
+
        val soundManager = CallkitSoundPlayerManager(appContext)
        val notificationManager = CallkitNotificationManager(appContext, soundManager)
        activeSoundManager = soundManager
        activeNotificationManager = notificationManager
+        activeCallBundle = callData
        notificationManager.createNotificationChanel(callData)
        notificationManager.showIncomingNotification(callData)

@@ -109,46 +228,41 @@ object VideoCallPushBridge {
        } catch (error: Exception) {
            Log.w(TAG, "showIncomingCall: failed to persist active call", error)
        }
+
+        val durationMs = callData.getLong(CallkitConstants.EXTRA_CALLKIT_DURATION, 45_000L)
+        if (durationMs > 0L) {
+            val timeout = Runnable {
+                synchronized(playbackLock) {
+                    if (generation != playbackGeneration.get()) return@Runnable
+                    Log.i(TAG, "incoming ringtone timed out")
+                    stopPlaybackLocked(appContext)
+                }
+            }
+            ringtoneTimeout = timeout
+            mainHandler.postDelayed(timeout, durationMs)
+        }
    }

-    fun dismissAllIncomingCalls(context: Context) {
-        val appContext = context.applicationContext
-        val calls = getDataActiveCalls(appContext)
-        Log.i(TAG, "dismissAllIncomingCalls: active calls=${calls.size}")
-
-        stopIncomingRingtone(appContext)
-
-        val notificationManager = resolveNotificationManager(appContext)
-        val bundles = calls.map { it.toBundle() }
-
-        for (bundle in bundles) {
+    private fun stopPlaybackLocked(appContext: Context) {
+        cancelRingtoneTimeoutLocked()
+        val notificationManager = activeNotificationManager
+        val bundle = activeCallBundle
+        stopIncomingRingtone()
+        if (notificationManager != null && bundle != null) {
            try {
                dismissIncomingCallNotification(appContext, notificationManager, bundle)
            } catch (error: Exception) {
-                Log.w(
-                    TAG,
-                    "dismissAllIncomingCalls: failed for call ${bundle.getString(CallkitConstants.EXTRA_CALLKIT_ID)}",
-                    error,
-                )
+                Log.w(TAG, "stopPlayback: failed to dismiss incoming notification", error)
            }
        }
-
-        try {
-            CallkitNotificationService.stopService(appContext)
-        } catch (error: Exception) {
-            Log.w(TAG, "dismissAllIncomingCalls: failed to stop callkit service", error)
-        }
-
-        try {
-            removeAllCalls(appContext)
-        } catch (error: Exception) {
-            Log.w(TAG, "dismissAllIncomingCalls: failed to remove persisted calls", error)
-        }
-
-        stopIncomingRingtone(appContext)
-        scheduleMissedCallCleanup(notificationManager, bundles)
        activeSoundManager = null
        activeNotificationManager = null
+        activeCallBundle = null
+    }
+
+    private fun cancelRingtoneTimeoutLocked() {
+        ringtoneTimeout?.let { mainHandler.removeCallbacks(it) }
+        ringtoneTimeout = null
    }

    private fun resolveNotificationManager(context: Context): CallkitNotificationManager {
@@ -161,11 +275,19 @@ object VideoCallPushBridge {
        return CallkitNotificationManager(context, soundManager)
    }

-    private fun stopIncomingRingtone(context: Context) {
-        activeSoundManager?.stop()
-        FlutterCallkitIncomingPlugin.getInstance()
-            ?.getCallkitSoundPlayerManager()
-            ?.stop()
+    private fun stopIncomingRingtone() {
+        try {
+            activeSoundManager?.stop()
+        } catch (error: Exception) {
+            Log.w(TAG, "stopIncomingRingtone: active player", error)
+        }
+        try {
+            FlutterCallkitIncomingPlugin.getInstance()
+                ?.getCallkitSoundPlayerManager()
+                ?.stop()
+        } catch (error: Exception) {
+            Log.w(TAG, "stopIncomingRingtone: plugin player", error)
+        }
    }

    /**
--- a/android/app/src/test/kotlin/com/eatvioapp/app/IncomingCallRingtonePolicyTest.kt
+++ b/android/app/src/test/kotlin/com/eatvioapp/app/IncomingCallRingtonePolicyTest.kt
@@ -0,0 +1,45 @@
+package com.eatvioapp.app
+
+import org.junit.Assert.assertFalse
+import org.junit.Assert.assertTrue
+import org.junit.Test
+
+class IncomingCallRingtonePolicyTest {
+    @Test
+    fun answerDeclineEndAndTimeoutStopTheRingtone() {
+        assertTrue(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_ACCEPT",
+            ),
+        )
+        assertTrue(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_DECLINE",
+            ),
+        )
+        assertTrue(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_ENDED",
+            ),
+        )
+        assertTrue(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_TIMEOUT",
+            ),
+        )
+    }
+
+    @Test
+    fun incomingAndStartActionsKeepTheRingtonePlaying() {
+        assertFalse(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_INCOMING",
+            ),
+        )
+        assertFalse(
+            IncomingCallRingtonePolicy.actionStopsRingtone(
+                "com.hiennv.flutter_callkit_incoming.ACTION_CALL_START",
+            ),
+        )
+    }
+}
--- a/ios/Runner.xcodeproj/project.pbxproj
+++ b/ios/Runner.xcodeproj/project.pbxproj
@@ -11,6 +11,7 @@
 		3B3967161E833CAA004F5970 /* AppFrameworkInfo.plist in Resources */ = {isa = PBXBuildFile; fileRef = 3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */; };
 		46B43B96F809CEC6058EFDD3 /* Pods_Runner.framework in Frameworks */ = {isa = PBXBuildFile; fileRef = 15ADDB2A35F334AF0AE50011 /* Pods_Runner.framework */; };
 		74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = 74858FAE1ED2DC5600515810 /* AppDelegate.swift */; };
+		C4A8E2022E9A4B1000123456 /* SceneDelegate.swift in Sources */ = {isa = PBXBuildFile; fileRef = C4A8E2012E9A4B1000123456 /* SceneDelegate.swift */; };
 		97C146FC1CF9000F007C117D /* Main.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FA1CF9000F007C117D /* Main.storyboard */; };
 		97C146FE1CF9000F007C117D /* Assets.xcassets in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FD1CF9000F007C117D /* Assets.xcassets */; };
 		97C147011CF9000F007C117D /* LaunchScreen.storyboard in Resources */ = {isa = PBXBuildFile; fileRef = 97C146FF1CF9000F007C117D /* LaunchScreen.storyboard */; };
@@ -37,6 +38,7 @@
 		3B3967151E833CAA004F5970 /* AppFrameworkInfo.plist */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.plist.xml; name = AppFrameworkInfo.plist; path = Flutter/AppFrameworkInfo.plist; sourceTree = "<group>"; };
 		74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; path = "Runner-Bridging-Header.h"; sourceTree = "<group>"; };
 		74858FAE1ED2DC5600515810 /* AppDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = AppDelegate.swift; sourceTree = "<group>"; };
+		C4A8E2012E9A4B1000123456 /* SceneDelegate.swift */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.swift; path = SceneDelegate.swift; sourceTree = "<group>"; };
 		7AFA3C8E1D35360C0083082E /* Release.xcconfig */ = {isa = PBXFileReference; lastKnownFileType = text.xcconfig; name = Release.xcconfig; path = Flutter/Release.xcconfig; sourceTree = "<group>"; };
 		938EE8FB5BAA359AAEDEFFF8 /* Pods-Runner.debug.xcconfig */ = {isa = PBXFileReference; includeInIndex = 1; lastKnownFileType = text.xcconfig; name = "Pods-Runner.debug.xcconfig"; path = "Target Support Files/Pods-Runner/Pods-Runner.debug.xcconfig"; sourceTree = "<group>"; };
 		9740EEB21CF90195004384FC /* Debug.xcconfig */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = text.xcconfig; name = Debug.xcconfig; path = Flutter/Debug.xcconfig; sourceTree = "<group>"; };
@@ -115,6 +117,7 @@
 				1498D2321E8E86230040F4C2 /* GeneratedPluginRegistrant.h */,
 				1498D2331E8E89220040F4C2 /* GeneratedPluginRegistrant.m */,
 				74858FAE1ED2DC5600515810 /* AppDelegate.swift */,
+				C4A8E2012E9A4B1000123456 /* SceneDelegate.swift */,
 				74858FAD1ED2DC5600515810 /* Runner-Bridging-Header.h */,
 				FEE92A0E2D772EA300E6E989 /* Runner.entitlements */,
 			);
@@ -300,6 +303,7 @@
 			buildActionMask = 2147483647;
 			files = (
 				74858FAF1ED2DC5600515810 /* AppDelegate.swift in Sources */,
+				C4A8E2022E9A4B1000123456 /* SceneDelegate.swift in Sources */,
 				1498D2341E8E89220040F4C2 /* GeneratedPluginRegistrant.m in Sources */,
 			);
 			runOnlyForDeploymentPostprocessing = 0;
--- a/ios/Runner/AppDelegate.swift
+++ b/ios/Runner/AppDelegate.swift
@@ -42,50 +42,77 @@ import flutter_foreground_task

    let launched = super.application(application, didFinishLaunchingWithOptions: launchOptions)

-    if let controller = window?.rootViewController as? FlutterViewController {
-      let channel = FlutterMethodChannel(
-        name: voipDiagnosticsChannelName,
-        binaryMessenger: controller.binaryMessenger
-      )
-      voipDiagnosticsChannel = channel
-      channel.setMethodCallHandler { [weak self] call, result in
-        guard let self else {
-          result(nil)
-          return
-        }
-        switch call.method {
-        case "drainVoipDiagnostics":
-          result(self.drainVoipDiagnostics())
-        case "drainPendingAcceptedVoipCall":
-          result(self.drainPendingAcceptedVoipCall())
-        default:
-          result(FlutterMethodNotImplemented)
-        }
-      }
+    // WebRTC must not activate the session itself. CallKit and the in-app
+    // call both own AVAudioSession, and a second activation drops the mic.
+    let rtcSession = RTCAudioSession.sharedInstance()
+    rtcSession.useManualAudio = true
+    rtcSession.isAudioEnabled = false

-      let callAudioChannel = FlutterMethodChannel(
-        name: callAudioSessionChannelName,
-        binaryMessenger: controller.binaryMessenger
-      )
-      callAudioChannel.setMethodCallHandler { [weak self] call, result in
-        guard let self else {
-          result(nil)
-          return
-        }
-        switch call.method {
-        case "activate":
-          self.activateInAppCallAudioSession()
-          result(nil)
-        case "deactivate":
-          self.deactivateInAppCallAudioSession()
-          result(nil)
-        default:
-          result(FlutterMethodNotImplemented)
-        }
+    registerCallChannels(from: window?.rootViewController as? FlutterViewController)
+
+    return launched
+  }
+
+  func registerCallChannels(from controller: FlutterViewController?) {
+    guard voipDiagnosticsChannel == nil else { return }
+    let flutterController = controller ?? flutterViewControllerFromScenes()
+    guard let flutterController else { return }
+
+    let channel = FlutterMethodChannel(
+      name: voipDiagnosticsChannelName,
+      binaryMessenger: flutterController.binaryMessenger
+    )
+    voipDiagnosticsChannel = channel
+    channel.setMethodCallHandler { [weak self] call, result in
+      guard let self else {
+        result(nil)
+        return
+      }
+      switch call.method {
+      case "drainVoipDiagnostics":
+        result(self.drainVoipDiagnostics())
+      case "drainPendingAcceptedVoipCall":
+        result(self.drainPendingAcceptedVoipCall())
+      default:
+        result(FlutterMethodNotImplemented)
      }
    }

-    return launched
+    let callAudioChannel = FlutterMethodChannel(
+      name: callAudioSessionChannelName,
+      binaryMessenger: flutterController.binaryMessenger
+    )
+    callAudioChannel.setMethodCallHandler { [weak self] call, result in
+      guard let self else {
+        result(nil)
+        return
+      }
+      switch call.method {
+      case "activate":
+        self.activateInAppCallAudioSession()
+        result(nil)
+      case "restart":
+        self.restartInAppCallAudioUnit()
+        result(nil)
+      case "deactivate":
+        self.deactivateInAppCallAudioSession()
+        result(nil)
+      default:
+        result(FlutterMethodNotImplemented)
+      }
+    }
+  }
+
+  private func flutterViewControllerFromScenes() -> FlutterViewController? {
+    for scene in UIApplication.shared.connectedScenes {
+      guard let windowScene = scene as? UIWindowScene else { continue }
+      for sceneWindow in windowScene.windows {
+        if let controller = sceneWindow.rootViewController as? FlutterViewController {
+          return controller
+        }
+      }
+    }
+    return nil
  }

  @available(iOS 8.0, *)
@@ -109,6 +136,14 @@ import flutter_foreground_task
    open url: URL,
    options: [UIApplication.OpenURLOptionsKey: Any] = [:]
  ) -> Bool {
+    handleOpenURL(
+      url,
+      sourceApplication: options[UIApplication.OpenURLOptionsKey.sourceApplication] as? String
+    )
+  }
+
+  @discardableResult
+  func handleOpenURL(_ url: URL, sourceApplication: String?) -> Bool {
    if url.scheme == appUrlScheme {
      let components = URLComponents(url: url, resolvingAgainstBaseURL: false)
      let queryItems = components?.queryItems ?? []
@@ -142,7 +177,7 @@ import flutter_foreground_task

    return YXLSdk.shared.handleOpen(
      url,
-      sourceApplication: options[UIApplication.OpenURLOptionsKey.sourceApplication] as? String
+      sourceApplication: sourceApplication
    )
  }

@@ -574,6 +609,7 @@ import flutter_foreground_task

  func didActivateAudioSession(_ audioSession: AVAudioSession) {
    let rtcSession = RTCAudioSession.sharedInstance()
+    rtcSession.useManualAudio = true
    rtcSession.audioSessionDidActivate(audioSession)
    rtcSession.isAudioEnabled = true
  }
@@ -581,10 +617,13 @@ import flutter_foreground_task
  func didDeactivateAudioSession(_ audioSession: AVAudioSession) {
    let rtcSession = RTCAudioSession.sharedInstance()
    rtcSession.audioSessionDidDeactivate(audioSession)
+    // The audio unit is stopped, but isAudioEnabled stays true. A later
+    // assignment of true is then a no-op and the microphone never restarts.
+    rtcSession.isAudioEnabled = false
    guard resumeAudioAfterCallKitEnds else { return }
    DispatchQueue.main.async { [weak self] in
      guard let self, self.resumeAudioAfterCallKitEnds else { return }
-      self.activateInAppCallAudioSession()
+      self.restartInAppCallAudioUnit()
    }
  }

@@ -606,14 +645,26 @@ import flutter_foreground_task

  private func activateInAppCallAudioSession() {
    let rtcSession = RTCAudioSession.sharedInstance()
+    rtcSession.useManualAudio = true
    rtcSession.lockForConfiguration()
-    defer { rtcSession.unlockForConfiguration() }
    do {
      try rtcSession.setConfiguration(callAudioConfiguration(), active: true)
-      rtcSession.isAudioEnabled = true
    } catch {
      NSLog("[EatvioVoIP] activate call audio session failed: \(error)")
    }
+    rtcSession.unlockForConfiguration()
+    // Starting the audio unit while the configuration lock is held deadlocks
+    // the capture thread, so the mic stays silent.
+    rtcSession.isAudioEnabled = true
+  }
+
+  /// Cycles the audio unit after the microphone track exists. Enabling audio
+  /// before the track is created leaves capture attached to nothing.
+  private func restartInAppCallAudioUnit() {
+    activateInAppCallAudioSession()
+    let rtcSession = RTCAudioSession.sharedInstance()
+    rtcSession.isAudioEnabled = false
+    rtcSession.isAudioEnabled = true
  }

  private func deactivateInAppCallAudioSession() {
@@ -636,7 +687,10 @@ import flutter_foreground_task
      .allowBluetooth,
      .defaultToSpeaker,
    ]
-    configuration.mode = AVAudioSession.Mode.voiceChat.rawValue
+    // videoChat is the speakerphone mode for a video call. voiceChat keeps
+    // the input on the receiver, so the mic is silent once audio goes to
+    // the loudspeaker.
+    configuration.mode = AVAudioSession.Mode.videoChat.rawValue
    return configuration
  }
 }
--- a/ios/Runner/Info.plist
+++ b/ios/Runner/Info.plist
@@ -41,6 +41,27 @@
 	<string>Может использоваться для стабильного поддержания связи во время звонка.</string>
 	<key>NSPhotoLibraryUsageDescription</key>
 	<string>Предоставление доступа позволит Вам добавлять фото к записям</string>
+	<key>UIApplicationSceneManifest</key>
+	<dict>
+		<key>UIApplicationSupportsMultipleScenes</key>
+		<false/>
+		<key>UISceneConfigurations</key>
+		<dict>
+			<key>UIWindowSceneSessionRoleApplication</key>
+			<array>
+				<dict>
+					<key>UISceneClassName</key>
+					<string>UIWindowScene</string>
+					<key>UISceneConfigurationName</key>
+					<string>flutter</string>
+					<key>UISceneDelegateClassName</key>
+					<string>$(PRODUCT_MODULE_NAME).SceneDelegate</string>
+					<key>UISceneStoryboardFile</key>
+					<string>Main</string>
+				</dict>
+			</array>
+		</dict>
+	</dict>
 	<key>UIApplicationSupportsIndirectInputEvents</key>
 	<true/>
 	<key>UIBackgroundModes</key>
--- a/ios/Runner/SceneDelegate.swift
+++ b/ios/Runner/SceneDelegate.swift
@@ -0,0 +1,86 @@
+import Flutter
+import UIKit
+import YandexLoginSDK
+
+/// iOS 27 requires a UIScene lifecycle. Flutter 3.38 does not yet have
+/// `FlutterImplicitEngineDelegate`, so channels and URL handling are wired
+/// here after the scene creates the Flutter view.
+class SceneDelegate: FlutterSceneDelegate {
+  override func scene(
+    _ scene: UIScene,
+    willConnectTo session: UISceneSession,
+    options connectionOptions: UIScene.ConnectionOptions
+  ) {
+    super.scene(scene, willConnectTo: session, options: connectionOptions)
+    registerCallChannels()
+    handleConnectionOptions(connectionOptions)
+  }
+
+  override func sceneDidBecomeActive(_ scene: UIScene) {
+    super.sceneDidBecomeActive(scene)
+    registerCallChannels()
+  }
+
+  override func scene(_ scene: UIScene, openURLContexts URLContexts: Set<UIOpenURLContext>) {
+    var handledCustomURL = false
+    if let appDelegate = UIApplication.shared.delegate as? AppDelegate {
+      for context in URLContexts {
+        if appDelegate.handleOpenURL(
+          context.url,
+          sourceApplication: context.options.sourceApplication
+        ) {
+          handledCustomURL = true
+        }
+      }
+    }
+    if !handledCustomURL {
+      super.scene(scene, openURLContexts: URLContexts)
+    }
+  }
+
+  override func scene(_ scene: UIScene, continue userActivity: NSUserActivity) {
+    if YXLSdk.shared.processUserActivity(userActivity) {
+      return
+    }
+    super.scene(scene, continue: userActivity)
+  }
+
+  private func registerCallChannels() {
+    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
+      return
+    }
+    appDelegate.registerCallChannels(from: flutterViewController)
+  }
+
+  private var flutterViewController: FlutterViewController? {
+    if let controller = window?.rootViewController as? FlutterViewController {
+      return controller
+    }
+    for scene in UIApplication.shared.connectedScenes {
+      guard let windowScene = scene as? UIWindowScene else { continue }
+      for sceneWindow in windowScene.windows {
+        if let controller = sceneWindow.rootViewController as? FlutterViewController {
+          return controller
+        }
+      }
+    }
+    return nil
+  }
+
+  private func handleConnectionOptions(_ options: UIScene.ConnectionOptions) {
+    guard let appDelegate = UIApplication.shared.delegate as? AppDelegate else {
+      return
+    }
+    for context in options.urlContexts {
+      _ = appDelegate.handleOpenURL(
+        context.url,
+        sourceApplication: context.options.sourceApplication
+      )
+    }
+    for activity in options.userActivities {
+      if YXLSdk.shared.processUserActivity(activity) {
+        continue
+      }
+    }
+  }
+}
--- a/lib/core/app_config.dart
+++ b/lib/core/app_config.dart
@@ -1,8 +1,12 @@
+import 'dart:async';
+
 import 'package:eatvio_app/core/app_initializer.dart';
 import 'package:eatvio_app/core/cubit/marketing/marketing_cubit.dart';
 import 'package:eatvio_app/core/env_config.dart';
 import 'package:eatvio_app/core/internet_connection_cubit/internet_connection_cubit.dart';
 import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/prefs.dart';
+import 'package:eatvio_app/core/prefs_keys.dart';
 import 'package:eatvio_app/core/views/cubit/views_cubit.dart';
 import 'package:eatvio_app/features/bottom_navigation_bar/presentation/bloc/new_messages_cubit/new_messages_cubit.dart';
 import 'package:eatvio_app/features/notifications/presentation/notifications_cubit/notifications_cubit.dart';
@@ -31,20 +35,50 @@ class AppConfig {

  void setBaseUrl(String baseUrls) {
    _baseUrl = baseUrls;
+    _persistBaseUrl(baseUrls);
+  }
+
+  void _persistBaseUrl(String baseUrl) {
+    if (!sl.isRegistered<Prefs>()) {
+      return;
+    }
+    final normalized = baseUrl.trim();
+    if (normalized.isEmpty) {
+      unawaited(sl<Prefs>().remove(PrefsKeys.customBaseUrl));
+      return;
+    }
+    unawaited(sl<Prefs>().setString(PrefsKeys.customBaseUrl, normalized));
  }

  /// Список глобальных BlocProvider'ов
  /// Используются lazy: true для отложенной инициализации, чтобы не блокировать старт приложения
  List<BlocProvider> get globalBlocProviders => [
-    BlocProvider<VideoCallSessionCubit>.value(value: sl<VideoCallSessionCubit>()),
-    BlocProvider<NewMessagesCubit>(lazy: true, create: (context) => sl<NewMessagesCubit>()),
-    BlocProvider<NotificationsCubit>(lazy: true, create: (context) => sl<NotificationsCubit>()),
+    BlocProvider<VideoCallSessionCubit>.value(
+      value: sl<VideoCallSessionCubit>(),
+    ),
+    BlocProvider<NewMessagesCubit>(
+      lazy: true,
+      create: (context) => sl<NewMessagesCubit>(),
+    ),
+    BlocProvider<NotificationsCubit>(
+      lazy: true,
+      create: (context) => sl<NotificationsCubit>(),
+    ),
    BlocProvider<FeedCubit>(lazy: true, create: (context) => sl<FeedCubit>()),
-    BlocProvider<ProfileAvatarCubit>(lazy: true, create: (context) => sl<ProfileAvatarCubit>()),
+    BlocProvider<ProfileAvatarCubit>(
+      lazy: true,
+      create: (context) => sl<ProfileAvatarCubit>(),
+    ),
    BlocProvider<ChatsCubit>(lazy: true, create: (context) => sl<ChatsCubit>()),
    BlocProvider<ViewsCubit>(lazy: true, create: (context) => sl<ViewsCubit>()),
-    BlocProvider<InternetConnectionCubit>(lazy: false, create: (context) => sl<InternetConnectionCubit>()),
-    BlocProvider<MarketingCubit>(lazy: true, create: (context) => sl<MarketingCubit>()),
+    BlocProvider<InternetConnectionCubit>(
+      lazy: false,
+      create: (context) => sl<InternetConnectionCubit>(),
+    ),
+    BlocProvider<MarketingCubit>(
+      lazy: true,
+      create: (context) => sl<MarketingCubit>(),
+    ),
  ];

  /// Делегаты локализации
@@ -56,5 +90,7 @@ class AppConfig {
  ];

  /// Поддерживаемые локали
-  List<Locale> get supportedLocales => [const Locale.fromSubtags(languageCode: 'ru')];
+  List<Locale> get supportedLocales => [
+    const Locale.fromSubtags(languageCode: 'ru'),
+  ];
 }
--- a/lib/core/cached_base_url.dart
+++ b/lib/core/cached_base_url.dart
@@ -0,0 +1,16 @@
+import 'package:eatvio_app/core/app_config.dart';
+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/prefs.dart';
+import 'package:eatvio_app/core/prefs_keys.dart';
+
+/// Подставляет сохранённый base URL до создания HTTP-клиента.
+void applyCachedBaseUrl() {
+  if (!sl.isRegistered<Prefs>() || !sl.isRegistered<AppConfig>()) {
+    return;
+  }
+  final cached = sl<Prefs>().getString(PrefsKeys.customBaseUrl)?.trim();
+  if (cached == null || cached.isEmpty) {
+    return;
+  }
+  sl<AppConfig>().setBaseUrl(cached);
+}
--- a/lib/core/locator_service.dart
+++ b/lib/core/locator_service.dart
@@ -1,4 +1,5 @@
 import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/cached_base_url.dart';
 import 'package:eatvio_app/core/di/app_config_registration.dart';
 import 'package:eatvio_app/core/di/cubit_registrations.dart';
 import 'package:eatvio_app/core/di/external_registrations.dart';
@@ -21,6 +22,8 @@ Future<void> init({required AppBuildType buildType}) async {

  // Ожидание инициализации асинхронных зависимостей
  await sl.getAsync<Prefs>();
+  // До создания Dio и любых запросов к бэкенду.
+  applyCachedBaseUrl();

  // Регистрация сервисов
  ServiceRegistrations.registerAll();
@@ -32,5 +35,7 @@ Future<void> init({required AppBuildType buildType}) async {
  CubitRegistrations.registerAll();

  // Регистрация WebSocket менеджера
-    sl.registerLazySingleton<WsManager>(() => WsManager(wsService: sl(), errorReporter: sl()));
+  sl.registerLazySingleton<WsManager>(
+    () => WsManager(wsService: sl(), errorReporter: sl()),
+  );
 }
--- a/lib/core/notifications/push_navigation_handler.dart
+++ b/lib/core/notifications/push_navigation_handler.dart
@@ -65,7 +65,11 @@ class PushNavigationHandler {
        'PushNavigationHandler: dismiss incoming call UI, source=$source',
        name: 'PushNavigationHandler',
      );
-      unawaited(VideoCallEndedPushHandler.dismissIncomingCallUi());
+      unawaited(
+        VideoCallEndedPushHandler.dismissIncomingCallUi(
+          conversationUuid: endedPayload.conversationUuid,
+        ),
+      );
      return;
    }

--- a/lib/core/prefs_keys.dart
+++ b/lib/core/prefs_keys.dart
@@ -1 +1,8 @@
-enum PrefsKeys { hasAnonymousTokenBeenSent, welcomeScreenWasShowed, registrationDate, marketingBottomSheetHasBeenShown, isEmailVerificationSkipped }
+enum PrefsKeys {
+  hasAnonymousTokenBeenSent,
+  welcomeScreenWasShowed,
+  registrationDate,
+  marketingBottomSheetHasBeenShown,
+  isEmailVerificationSkipped,
+  customBaseUrl,
+}
--- a/lib/features/chat/presentation/bloc/chats_cubit/chats_cubit.dart
+++ b/lib/features/chat/presentation/bloc/chats_cubit/chats_cubit.dart
@@ -231,6 +231,9 @@ class ChatsCubit extends Cubit<ChatsState> {
    final kind = VideoCallChatSignal.kindOf(message);
    if (kind == VideoCallChatSignalKind.ended) {
      unawaited(_dismissIncomingVideoCallUi());
+      unawaited(
+        VideoCallEndedPushHandler.endActiveCallIfMatches(message.roomId),
+      );
      return;
    }
    if (isOwn || kind != VideoCallChatSignalKind.started) return;
--- a/lib/features/video_calls/managers/video_call_manager.dart
+++ b/lib/features/video_calls/managers/video_call_manager.dart
@@ -1,4 +1,5 @@
 import 'dart:async';
+import 'dart:io';

 import 'package:eatvio_app/core/app_router.dart';
 import 'package:eatvio_app/core/device/device_hw_id_provider.dart';
@@ -8,6 +9,7 @@ import 'package:eatvio_app/features/video_calls/managers/video_call_manager_snap
 import 'package:eatvio_app/features/video_calls/services/video_call_audio_session_coordinator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_foreground_coordinator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_lifecycle_binding.dart';
+import 'package:eatvio_app/features/video_calls/services/video_call_peer_departure.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_notification_navigator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_task_handler.dart';
 import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_state.dart';
@@ -37,6 +39,12 @@ class VideoCallManager {
       _audioSession =
           audioSessionCoordinator ?? VideoCallAudioSessionCoordinator() {
    FlutterForegroundTask.addTaskDataCallback(_onForegroundTaskData);
+    if (Platform.isIOS) {
+      // LiveKit rewrites the audio session whenever a remote audio track
+      // appears. That second configuration stops the microphone and does
+      // not start it again.
+      lk.Hardware.instance.setAutomaticConfigurationEnabled(enable: false);
+    }
  }

  final VideoCallRepository _videoCallRepository;
@@ -46,7 +54,10 @@ class VideoCallManager {
  final VideoCallAudioSessionCoordinator _audioSession;

  static const lk.AudioCaptureOptions _micCaptureOptions =
-      lk.AudioCaptureOptions(stopAudioCaptureOnMute: false);
+      lk.AudioCaptureOptions(
+        stopAudioCaptureOnMute: false,
+        voiceIsolation: false,
+      );
  static const Duration _mutedMicPollInterval = Duration(milliseconds: 320);
  static const Duration _mutedMicOverlayMinInterval = Duration(
    milliseconds: 2600,
@@ -65,6 +76,7 @@ class VideoCallManager {
  num? _lastMutedMicTotalEnergy;
  bool _liveKitDisposed = true;
  bool _callEndedNotified = true;
+  bool _forceEndRequested = false;
  final Set<String> _callAcceptNotifiedConversationUuids = {};
  bool _callStageEntered = false;
  bool _joinInProgress = false;
@@ -86,6 +98,8 @@ class VideoCallManager {
  String? get counterpartName => _snapshot.counterpartName;
  String? get localParticipantName => _snapshot.localParticipantName;

+  bool get callEndedNotified => _callEndedNotified;
+
  bool get isActiveCall =>
      _snapshot.connectPhase == VideoCallConnectPhase.connected &&
      _callStageEntered &&
@@ -207,6 +221,7 @@ class VideoCallManager {

    _resetSessionFlagsForNewRoom();
    _callEndedNotified = false;
+    _forceEndRequested = false;
    _liveKitDisposed = false;
    _callStageEntered = false;
    _room = lk.Room(
@@ -391,10 +406,17 @@ class VideoCallManager {

  Future<void> endCall() async {
    final uuid = _snapshot.conversationUuid;
+    final shouldNotifyBackend = shouldNotifyCallEnded(
+      alreadyNotified: _callEndedNotified,
+      hasConversation: uuid.isNotEmpty,
+      peerStillInRoom: _roomHasRemoteUser(),
+    );
+    if (uuid.isNotEmpty) {
+      _callEndedNotified = true;
+    }
    _disposeRoomEphemerals();
    await _disconnectLiveKitOnly();
-    if (!_callEndedNotified && uuid.isNotEmpty) {
-      _callEndedNotified = true;
+    if (shouldNotifyBackend) {
      try {
        await _videoCallRepository.notifyCallEnded(uuid);
      } catch (_) {}
@@ -477,6 +499,9 @@ class VideoCallManager {
        next,
        audioCaptureOptions: _micCaptureOptions,
      );
+      if (next) {
+        await _audioSession.restartCapture();
+      }
    } catch (_) {
      return;
    }
@@ -674,6 +699,7 @@ class VideoCallManager {
          true,
          audioCaptureOptions: _micCaptureOptions,
        );
+        await _audioSession.restartCapture();
      } catch (_) {}
    }
    await _resumeVideoAfterForeground();
@@ -814,6 +840,12 @@ class VideoCallManager {
    }
  }

+  void _requestForceEnd() {
+    if (_forceEndRequested || _liveKitDisposed) return;
+    _forceEndRequested = true;
+    _emitSnapshot(_snapshot.copyWith(forceEndCall: true));
+  }
+
  void _attachRoomEventListeners() {
    final room = _room;
    if (room == null) return;
@@ -825,11 +857,34 @@ class VideoCallManager {
        if (_snapshot.linkIssue.needsManualReconnect) return;
        _emitSnapshot(_snapshot.copyWith(linkIssue: VideoCallLinkIssue.none));
      })
-      ..on<lk.RoomDisconnectedEvent>((_) {
+      ..on<lk.RoomDisconnectedEvent>((event) {
        if (_liveKitDisposed) return;
        if (_snapshot.connectPhase != VideoCallConnectPhase.connected) return;
+        if (shouldForceEndCallAfterRoomDisconnect(
+          callStageEntered: _callStageEntered,
+          sessionConnected: true,
+          reason: event.reason,
+        )) {
+          _requestForceEnd();
+          return;
+        }
        _emitSnapshot(_snapshot.copyWith(linkIssue: VideoCallLinkIssue.lost));
      })
+      ..on<lk.ParticipantDisconnectedEvent>((_) {
+        final room = _room;
+        if (room == null) return;
+        if (!shouldForceEndCallAfterPeerLeft(
+          callStageEntered: _callStageEntered,
+          sessionConnected:
+              _snapshot.connectPhase == VideoCallConnectPhase.connected,
+          remoteIdentities: room.remoteParticipants.values.map(
+            (participant) => participant.identity,
+          ),
+        )) {
+          return;
+        }
+        _requestForceEnd();
+      })
      ..on<lk.ParticipantConnectionQualityUpdatedEvent>((e) {
        if (e.participant != room.localParticipant) return;
        _syncPoorConnectionOverlay(e.connectionQuality);
@@ -1048,6 +1103,14 @@ class VideoCallManager {
    return false;
  }

+  bool _roomHasRemoteUser() {
+    final room = _room;
+    if (room == null) return false;
+    return videoCallRoomStillHasRemoteUser(
+      room.remoteParticipants.values.map((participant) => participant.identity),
+    );
+  }
+
  bool get _canHandleCallAudio =>
      _callStageEntered &&
      !_liveKitDisposed &&
@@ -1089,6 +1152,7 @@ class VideoCallManager {
          true,
          audioCaptureOptions: _micCaptureOptions,
        );
+        await _audioSession.restartCapture();
      } catch (_) {
        effectiveMic = false;
      }
--- a/lib/features/video_calls/managers/video_call_manager_snapshot.dart
+++ b/lib/features/video_calls/managers/video_call_manager_snapshot.dart
@@ -11,6 +11,7 @@ class VideoCallManagerSnapshot {
    required this.connectPhase,
    required this.linkIssue,
    this.counterpartPresentInLobby = false,
+    this.forceEndCall = false,
  });

  final String conversationUuid;
@@ -22,6 +23,7 @@ class VideoCallManagerSnapshot {
  final VideoCallConnectPhase connectPhase;
  final VideoCallLinkIssue linkIssue;
  final bool counterpartPresentInLobby;
+  final bool forceEndCall;

  static const initial = VideoCallManagerSnapshot(
    conversationUuid: '',
@@ -41,6 +43,7 @@ class VideoCallManagerSnapshot {
    VideoCallConnectPhase? connectPhase,
    VideoCallLinkIssue? linkIssue,
    bool? counterpartPresentInLobby,
+    bool? forceEndCall,
    bool clearConnectError = false,
  }) {
    return VideoCallManagerSnapshot(
@@ -54,6 +57,7 @@ class VideoCallManagerSnapshot {
      linkIssue: linkIssue ?? this.linkIssue,
      counterpartPresentInLobby:
          counterpartPresentInLobby ?? this.counterpartPresentInLobby,
+      forceEndCall: forceEndCall ?? this.forceEndCall,
    );
  }
 }
--- a/lib/features/video_calls/presentation/bloc/video_call_session/video_call_session_cubit.dart
+++ b/lib/features/video_calls/presentation/bloc/video_call_session/video_call_session_cubit.dart
@@ -4,6 +4,7 @@ import 'package:eatvio_app/core/cubit/base_cubit.dart';
 import 'package:eatvio_app/features/video_calls/managers/video_call_manager.dart';
 import 'package:eatvio_app/features/video_calls/managers/video_call_manager_snapshot.dart';
 import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_state.dart';
+import 'package:eatvio_app/features/video_calls/services/video_call_notification_navigator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_screen_wake_lock_coordinator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_system_pip_coordinator.dart';
 import 'package:flutter/material.dart';
@@ -30,6 +31,8 @@ class VideoCallSessionCubit extends BaseCubit<VideoCallSessionState> {
  final VideoCallSystemPipCoordinator _systemPipCoordinator;
  final VideoCallScreenWakeLockCoordinator _screenWakeLock;
  bool _callScreenRouteVisible = false;
+  bool _handlingRemoteCallEnd = false;
+  bool _suppressDisposeSideEffects = false;
  bool _autoEnterInFlight = false;
  bool _counterpartPresentWhenLobbyReady = false;
  bool _sawEmptyLobbyWhenConnected = false;
@@ -74,6 +77,10 @@ class VideoCallSessionCubit extends BaseCubit<VideoCallSessionState> {

  void _onManagerSnapshot(VideoCallManagerSnapshot snapshot) {
    if (isClosed) return;
+    if (snapshot.forceEndCall) {
+      unawaited(handleRemoteCallEnded());
+      return;
+    }
    if (_isCallSessionInactive(snapshot)) {
      unawaited(_systemPipCoordinator.disarm());
      if (_callScreenRouteVisible) {
@@ -377,8 +384,32 @@ class VideoCallSessionCubit extends BaseCubit<VideoCallSessionState> {
    }
  }

+  /// The other participant hung up or was removed from the room.
+  Future<void> handleRemoteCallEnded() async {
+    if (_handlingRemoteCallEnd || isClosed) return;
+    if (_videoCallManager.callEndedNotified) return;
+    final inCall =
+        state.callStageEntered ||
+        state.connectPhase == VideoCallConnectPhase.connected;
+    if (!inCall) return;
+
+    _handlingRemoteCallEnd = true;
+    _suppressDisposeSideEffects = true;
+    try {
+      await endCall();
+      if (isClosed) return;
+      emit(const VideoCallSessionState());
+      await _restoreSystemUiAfterCall();
+      VideoCallNotificationNavigator.closeCallRouteIfOpen();
+    } finally {
+      _suppressDisposeSideEffects = false;
+      _handlingRemoteCallEnd = false;
+    }
+  }
+
  void onCallScreenDisposed() {
    _callScreenRouteVisible = false;
+    if (_suppressDisposeSideEffects) return;
    if (state.uiMode != VideoCallUiMode.fullscreen) {
      if (state.uiMode == VideoCallUiMode.pip && state.callStageEntered) {
        // [isCallScreenRouteVisible] is not in bloc state; refresh the global
@@ -510,9 +541,20 @@ class VideoCallSessionCubit extends BaseCubit<VideoCallSessionState> {
  }

  Future<void> endCall() async {
-    await _screenWakeLock.release();
-    await _systemPipCoordinator.disarm();
-    await _videoCallManager.endCall();
+    _suppressDisposeSideEffects = true;
+    try {
+      await _screenWakeLock.release();
+      await _systemPipCoordinator.disarm();
+      await _videoCallManager.endCall();
+      if (isClosed) return;
+      // The idle snapshot is ignored while the call screen is still visible,
+      // so hang up has to clear the session before the route pops. Otherwise
+      // dispose keeps the call and the next token request rings both users.
+      emit(const VideoCallSessionState());
+      await _restoreSystemUiAfterCall();
+    } finally {
+      _suppressDisposeSideEffects = false;
+    }
  }

  void expandLocal() {
--- a/lib/features/video_calls/services/video_call_audio_session_coordinator.dart
+++ b/lib/features/video_calls/services/video_call_audio_session_coordinator.dart
@@ -31,7 +31,7 @@ class VideoCallAudioSessionCoordinator {
        avAudioSessionCategoryOptions:
            AVAudioSessionCategoryOptions.allowBluetooth |
            AVAudioSessionCategoryOptions.defaultToSpeaker,
-        avAudioSessionMode: AVAudioSessionMode.voiceChat,
+        avAudioSessionMode: AVAudioSessionMode.videoChat,
        avAudioSessionRouteSharingPolicy:
            AVAudioSessionRouteSharingPolicy.defaultPolicy,
        avAudioSessionSetActiveOptions: AVAudioSessionSetActiveOptions.none,
@@ -88,6 +88,15 @@ class VideoCallAudioSessionCoordinator {
    }
  }

+  /// Restarts capture after the microphone track has been created.
+  Future<void> restartCapture() async {
+    if (!_isIos) return;
+    try {
+      await _iosCallAudioSession('restart');
+      _iosActive = true;
+    } catch (_) {}
+  }
+
  Future<void> stop() async {
    if (_isIos) {
      _iosActive = false;
--- a/lib/features/video_calls/services/video_call_ended_push_handler.dart
+++ b/lib/features/video_calls/services/video_call_ended_push_handler.dart
@@ -1,5 +1,7 @@
 import 'dart:io';

+import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_cubit.dart';
 import 'package:flutter/services.dart';
 import 'package:flutter_callkit_incoming/flutter_callkit_incoming.dart';

@@ -9,7 +11,10 @@ abstract final class VideoCallEndedPushHandler {
    'com.eatvioapp/video_call_push',
  );

-  static Future<void> dismissIncomingCallUi() async {
+  static Future<void> dismissIncomingCallUi({
+    String? conversationUuid,
+  }) async {
+    await endActiveCallIfMatches(conversationUuid);
    if (Platform.isAndroid) {
      try {
        await _androidPushChannel.invokeMethod<void>('dismissIncomingCalls');
@@ -20,6 +25,18 @@ abstract final class VideoCallEndedPushHandler {
    await _dismissViaCallKit();
  }

+  static Future<void> endActiveCallIfMatches(String? conversationUuid) async {
+    final uuid = conversationUuid?.trim();
+    if (uuid == null || uuid.isEmpty) return;
+    if (!sl.isRegistered<VideoCallSessionCubit>()) return;
+
+    final cubit = sl<VideoCallSessionCubit>();
+    if (cubit.state.conversationUuid != uuid) return;
+    try {
+      await cubit.handleRemoteCallEnded();
+    } catch (_) {}
+  }
+
  static Future<void> _dismissViaCallKit() async {
    try {
      final activeCalls = await FlutterCallkitIncoming.activeCalls();
--- a/lib/features/video_calls/services/video_call_ended_push_payload.dart
+++ b/lib/features/video_calls/services/video_call_ended_push_payload.dart
@@ -1,11 +1,23 @@
 import 'package:eatvio_app/features/video_calls/services/video_call_push_payload.dart';

-/// Marker for a data-only `video_call_ended` push (no conversation uuid required).
+/// Marker for a data-only `video_call_ended` push.
 class VideoCallEndedPushPayload {
-  const VideoCallEndedPushPayload._();
+  const VideoCallEndedPushPayload({this.conversationUuid});
+
+  final String? conversationUuid;

  static VideoCallEndedPushPayload? tryParse(Map<String, dynamic> data) {
    if (!VideoCallPushPayload.isEndedVideoCall(data)) return null;
-    return const VideoCallEndedPushPayload._();
+    final rawUuid =
+        data['conversationUuid'] ??
+        data['conversation_uuid'] ??
+        data['uuid'];
+    final conversationUuid = rawUuid?.toString().trim();
+    return VideoCallEndedPushPayload(
+      conversationUuid:
+          conversationUuid == null || conversationUuid.isEmpty
+          ? null
+          : conversationUuid,
+    );
  }
 }
--- a/lib/features/video_calls/services/video_call_fcm_handler.dart
+++ b/lib/features/video_calls/services/video_call_fcm_handler.dart
@@ -62,7 +62,9 @@ abstract final class VideoCallFcmHandler {
        name: 'VideoCallFcm',
      );
      try {
-        await VideoCallEndedPushHandler.dismissIncomingCallUi();
+        await VideoCallEndedPushHandler.dismissIncomingCallUi(
+          conversationUuid: endedPayload.conversationUuid,
+        );
      } catch (e, st) {
        log(
          'VideoCallFcmHandler: failed to dismiss incoming call UI: $e',
--- a/lib/features/video_calls/services/video_call_notification_navigator.dart
+++ b/lib/features/video_calls/services/video_call_notification_navigator.dart
@@ -74,6 +74,17 @@ class VideoCallNotificationNavigator {
    return isOnCallRoute();
  }

+  static void closeCallRouteIfOpen() {
+    try {
+      if (!isOnCallRoute()) return;
+      final context = AppRouter.navigatorKey.currentContext;
+      if (context == null || !context.mounted) return;
+      if (Navigator.canPop(context)) {
+        Navigator.pop(context);
+      }
+    } catch (_) {}
+  }
+
  static bool isOnCallRoute() {
    final matches =
        AppRouter.appRouter.routerDelegate.currentConfiguration.matches;
--- a/lib/features/video_calls/services/video_call_peer_departure.dart
+++ b/lib/features/video_calls/services/video_call_peer_departure.dart
@@ -0,0 +1,41 @@
+import 'package:livekit_client/livekit_client.dart' as lk;
+
+/// Real call participants use the `user-{id}` identity. Egress and other
+/// bots must not keep the call alive after the other person leaves.
+bool videoCallRoomStillHasRemoteUser(Iterable<String> remoteIdentities) {
+  for (final identity in remoteIdentities) {
+    if (identity.startsWith('user-')) return true;
+  }
+  return false;
+}
+
+bool shouldForceEndCallAfterPeerLeft({
+  required bool callStageEntered,
+  required bool sessionConnected,
+  required Iterable<String> remoteIdentities,
+}) {
+  if (!callStageEntered || !sessionConnected) return false;
+  return !videoCallRoomStillHasRemoteUser(remoteIdentities);
+}
+
+/// The participant who taps hang up must not report the end while the other
+/// person is still in the room. That report and the remaining client's report
+/// both see an empty room and each one rings the other user again.
+bool shouldNotifyCallEnded({
+  required bool alreadyNotified,
+  required bool hasConversation,
+  required bool peerStillInRoom,
+}) {
+  if (!hasConversation || alreadyNotified || peerStillInRoom) return false;
+  return true;
+}
+
+bool shouldForceEndCallAfterRoomDisconnect({
+  required bool callStageEntered,
+  required bool sessionConnected,
+  required lk.DisconnectReason? reason,
+}) {
+  if (!callStageEntered || !sessionConnected) return false;
+  return reason == lk.DisconnectReason.participantRemoved ||
+      reason == lk.DisconnectReason.roomDeleted;
+}
--- a/pubspec.yaml
+++ b/pubspec.yaml
@@ -1,6 +1,6 @@
 name: eatvio_app
 description: A new Flutter project.
-version: 1.3.50+139
+version: 1.3.53+142
 publish_to: 'none'

 environment:
--- a/test/core/app_config_test.dart
+++ b/test/core/app_config_test.dart
@@ -1,19 +1,27 @@
+import 'package:dio/dio.dart';
 import 'package:eatvio_app/core/app_config.dart';
 import 'package:eatvio_app/core/app_initializer.dart';
+import 'package:eatvio_app/core/cached_base_url.dart';
 import 'package:eatvio_app/core/env_config.dart';
 import 'package:eatvio_app/core/locator_service.dart';
+import 'package:eatvio_app/core/prefs.dart';
+import 'package:eatvio_app/core/prefs_keys.dart';
 import 'package:eatvio_app/features/video_calls/presentation/bloc/video_call_session/video_call_session_cubit.dart';
 import 'package:flutter_bloc/flutter_bloc.dart';
 import 'package:flutter_dotenv/flutter_dotenv.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:mockito/mockito.dart';
+import 'package:shared_preferences/shared_preferences.dart';

-class _MockVideoCallSessionCubit extends Mock implements VideoCallSessionCubit {}
+class _MockVideoCallSessionCubit extends Mock
+    implements VideoCallSessionCubit {}

 void main() {
  setUpAll(() async {
    // Initialize dotenv for tests
-    dotenv.loadFromString(envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost');
+    dotenv.loadFromString(
+      envString: 'DEV_BASE_URL=http://localhost\nBASE_URL=http://localhost',
+    );
  });

  setUp(() async {
@@ -90,6 +98,75 @@ void main() {
      expect(devConfig.baseUrl, testConfig.baseUrl);
    });

+    test('setBaseUrl saves override to prefs', () async {
+      SharedPreferences.setMockInitialValues({});
+      final prefs = Prefs(await SharedPreferences.getInstance());
+      sl.registerSingleton<Prefs>(prefs);
+      final config = AppConfig(buildType: AppBuildType.prod);
+
+      config.setBaseUrl('https://custom.example');
+      await Future<void>.delayed(Duration.zero);
+
+      expect(
+        prefs.getString(PrefsKeys.customBaseUrl),
+        'https://custom.example',
+      );
+    });
+
+    test('setBaseUrl removes cached override when url is blank', () async {
+      SharedPreferences.setMockInitialValues({
+        'customBaseUrl': 'https://custom.example',
+      });
+      final prefs = Prefs(await SharedPreferences.getInstance());
+      sl.registerSingleton<Prefs>(prefs);
+      final config = AppConfig(buildType: AppBuildType.prod);
+
+      config.setBaseUrl('   ');
+      await Future<void>.delayed(Duration.zero);
+
+      expect(prefs.getString(PrefsKeys.customBaseUrl), isNull);
+      expect(config.baseUrl, '   ');
+    });
+
+    test(
+      'applyCachedBaseUrl replaces env base url before dio is created',
+      () async {
+        SharedPreferences.setMockInitialValues({
+          'customBaseUrl': 'https://cached.example',
+        });
+        sl.registerLazySingleton<AppConfig>(
+          () => AppConfig(buildType: AppBuildType.prod),
+        );
+        sl.registerSingleton<Prefs>(
+          Prefs(await SharedPreferences.getInstance()),
+        );
+        sl.registerLazySingleton<Dio>(
+          () => Dio(BaseOptions(baseUrl: sl<AppConfig>().baseUrl)),
+        );
+
+        applyCachedBaseUrl();
+
+        expect(sl<AppConfig>().baseUrl, 'https://cached.example');
+        expect(sl<Dio>().options.baseUrl, 'https://cached.example');
+      },
+    );
+
+    test('applyCachedBaseUrl keeps env base url when cache is empty', () async {
+      SharedPreferences.setMockInitialValues({});
+      sl.registerLazySingleton<AppConfig>(
+        () => AppConfig(buildType: AppBuildType.prod),
+      );
+      sl.registerSingleton<Prefs>(Prefs(await SharedPreferences.getInstance()));
+      sl.registerLazySingleton<Dio>(
+        () => Dio(BaseOptions(baseUrl: sl<AppConfig>().baseUrl)),
+      );
+
+      applyCachedBaseUrl();
+
+      expect(sl<AppConfig>().baseUrl, EnvConfig.baseUrl);
+      expect(sl<Dio>().options.baseUrl, EnvConfig.baseUrl);
+    });
+
    test('setBaseUrl can be called multiple times', () {
      final config = AppConfig(buildType: AppBuildType.prod);
      const url1 = 'https://url1.com';
--- a/test/core/enums/prefs_keys_test.dart
+++ b/test/core/enums/prefs_keys_test.dart
@@ -4,57 +4,46 @@ import 'package:flutter_test/flutter_test.dart';
 void main() {
  group('PrefsKeys', () {
    test('has all expected values', () {
-      expect(PrefsKeys.values.length, 5);
+      expect(PrefsKeys.values.length, 6);
      expect(PrefsKeys.values, contains(PrefsKeys.hasAnonymousTokenBeenSent));
      expect(PrefsKeys.values, contains(PrefsKeys.welcomeScreenWasShowed));
      expect(PrefsKeys.values, contains(PrefsKeys.registrationDate));
-      expect(PrefsKeys.values, contains(PrefsKeys.marketingBottomSheetHasBeenShown));
+      expect(
+        PrefsKeys.values,
+        contains(PrefsKeys.marketingBottomSheetHasBeenShown),
+      );
      expect(PrefsKeys.values, contains(PrefsKeys.isEmailVerificationSkipped));
+      expect(PrefsKeys.values, contains(PrefsKeys.customBaseUrl));
    });

    test('can be compared', () {
-      expect(PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.hasAnonymousTokenBeenSent, true);
-      expect(PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.welcomeScreenWasShowed, false);
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent ==
+            PrefsKeys.hasAnonymousTokenBeenSent,
+        true,
+      );
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.welcomeScreenWasShowed,
+        false,
+      );
    });

    test('has correct name property', () {
-      expect(PrefsKeys.hasAnonymousTokenBeenSent.name, 'hasAnonymousTokenBeenSent');
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent.name,
+        'hasAnonymousTokenBeenSent',
+      );
      expect(PrefsKeys.welcomeScreenWasShowed.name, 'welcomeScreenWasShowed');
      expect(PrefsKeys.registrationDate.name, 'registrationDate');
-      expect(PrefsKeys.marketingBottomSheetHasBeenShown.name, 'marketingBottomSheetHasBeenShown');
-      expect(PrefsKeys.isEmailVerificationSkipped.name, 'isEmailVerificationSkipped');
+      expect(
+        PrefsKeys.marketingBottomSheetHasBeenShown.name,
+        'marketingBottomSheetHasBeenShown',
+      );
+      expect(
+        PrefsKeys.isEmailVerificationSkipped.name,
+        'isEmailVerificationSkipped',
+      );
+      expect(PrefsKeys.customBaseUrl.name, 'customBaseUrl');
    });
  });
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/test/core/prefs_keys_test.dart
+++ b/test/core/prefs_keys_test.dart
@@ -4,25 +4,46 @@ import 'package:flutter_test/flutter_test.dart';
 void main() {
  group('PrefsKeys', () {
    test('все значения enum определены', () {
-      expect(PrefsKeys.values.length, 5);
+      expect(PrefsKeys.values.length, 6);
      expect(PrefsKeys.values, contains(PrefsKeys.hasAnonymousTokenBeenSent));
      expect(PrefsKeys.values, contains(PrefsKeys.welcomeScreenWasShowed));
      expect(PrefsKeys.values, contains(PrefsKeys.registrationDate));
-      expect(PrefsKeys.values, contains(PrefsKeys.marketingBottomSheetHasBeenShown));
+      expect(
+        PrefsKeys.values,
+        contains(PrefsKeys.marketingBottomSheetHasBeenShown),
+      );
      expect(PrefsKeys.values, contains(PrefsKeys.isEmailVerificationSkipped));
+      expect(PrefsKeys.values, contains(PrefsKeys.customBaseUrl));
    });

    test('имена ключей корректны', () {
-      expect(PrefsKeys.hasAnonymousTokenBeenSent.name, 'hasAnonymousTokenBeenSent');
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent.name,
+        'hasAnonymousTokenBeenSent',
+      );
      expect(PrefsKeys.welcomeScreenWasShowed.name, 'welcomeScreenWasShowed');
      expect(PrefsKeys.registrationDate.name, 'registrationDate');
-      expect(PrefsKeys.marketingBottomSheetHasBeenShown.name, 'marketingBottomSheetHasBeenShown');
-      expect(PrefsKeys.isEmailVerificationSkipped.name, 'isEmailVerificationSkipped');
+      expect(
+        PrefsKeys.marketingBottomSheetHasBeenShown.name,
+        'marketingBottomSheetHasBeenShown',
+      );
+      expect(
+        PrefsKeys.isEmailVerificationSkipped.name,
+        'isEmailVerificationSkipped',
+      );
+      expect(PrefsKeys.customBaseUrl.name, 'customBaseUrl');
    });

    test('can be compared', () {
-      expect(PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.hasAnonymousTokenBeenSent, true);
-      expect(PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.welcomeScreenWasShowed, false);
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent ==
+            PrefsKeys.hasAnonymousTokenBeenSent,
+        true,
+      );
+      expect(
+        PrefsKeys.hasAnonymousTokenBeenSent == PrefsKeys.welcomeScreenWasShowed,
+        false,
+      );
    });

    test('has correct index', () {
@@ -33,43 +54,22 @@ void main() {
    });

    test('can access by name', () {
-      expect(PrefsKeys.values.byName('hasAnonymousTokenBeenSent'), PrefsKeys.hasAnonymousTokenBeenSent);
-      expect(PrefsKeys.values.byName('welcomeScreenWasShowed'), PrefsKeys.welcomeScreenWasShowed);
-      expect(PrefsKeys.values.byName('registrationDate'), PrefsKeys.registrationDate);
-      expect(PrefsKeys.values.byName('marketingBottomSheetHasBeenShown'), PrefsKeys.marketingBottomSheetHasBeenShown);
+      expect(
+        PrefsKeys.values.byName('hasAnonymousTokenBeenSent'),
+        PrefsKeys.hasAnonymousTokenBeenSent,
+      );
+      expect(
+        PrefsKeys.values.byName('welcomeScreenWasShowed'),
+        PrefsKeys.welcomeScreenWasShowed,
+      );
+      expect(
+        PrefsKeys.values.byName('registrationDate'),
+        PrefsKeys.registrationDate,
+      );
+      expect(
+        PrefsKeys.values.byName('marketingBottomSheetHasBeenShown'),
+        PrefsKeys.marketingBottomSheetHasBeenShown,
+      );
    });
  });
 }
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
--- a/test/features/video_calls/presentation/video_call_manager_lifecycle_test.dart
+++ b/test/features/video_calls/presentation/video_call_manager_lifecycle_test.dart
@@ -2,6 +2,8 @@ import 'package:eatvio_app/features/video_calls/managers/video_call_manager.dart
 import 'package:eatvio_app/features/video_calls/services/video_call_foreground_coordinator.dart';
 import 'package:eatvio_app/features/video_calls/services/video_call_lifecycle_binding.dart';
 import 'package:eatvio_app/features/video_calls/repositories/video_call_repository.dart';
+import 'dart:collection';
+
 import 'package:flutter/widgets.dart';
 import 'package:flutter_test/flutter_test.dart';
 import 'package:livekit_client/livekit_client.dart' as lk;
@@ -53,6 +55,9 @@ void main() {
      mockRoom = MockRoom();
      when(mockRoom.connectionState).thenReturn(lk.ConnectionState.connected);
      when(mockRoom.localParticipant).thenReturn(null);
+      when(
+        mockRoom.remoteParticipants,
+      ).thenReturn(UnmodifiableMapView(<String, lk.RemoteParticipant>{}));
    });

    tearDown(() {
--- a/test/features/video_calls/presentation/video_call_session_cubit_test.dart
+++ b/test/features/video_calls/presentation/video_call_session_cubit_test.dart
@@ -124,6 +124,36 @@ void main() {
      },
    );

+    test('force end from the other participant closes the call', () async {
+      when(mockManager.callEndedNotified).thenReturn(false);
+      when(mockManager.endCall()).thenAnswer((_) async {});
+      cubit.emit(
+        const VideoCallSessionState(
+          conversationUuid: 'uuid',
+          connectPhase: VideoCallConnectPhase.connected,
+          callStageEntered: true,
+          uiMode: VideoCallUiMode.fullscreen,
+        ),
+      );
+
+      managerListener(
+        const VideoCallManagerSnapshot(
+          conversationUuid: 'uuid',
+          micEnabled: true,
+          videoEnabled: true,
+          connectPhase: VideoCallConnectPhase.connected,
+          linkIssue: VideoCallLinkIssue.none,
+          forceEndCall: true,
+        ),
+      );
+      await Future<void>.delayed(Duration.zero);
+
+      verify(mockManager.endCall()).called(1);
+      expect(cubit.state.connectPhase, VideoCallConnectPhase.idle);
+      expect(cubit.state.callStageEntered, isFalse);
+      expect(cubit.state.uiMode, VideoCallUiMode.hidden);
+    });
+
    test('isMicActiveForUi mirrors micEnabled', () {
      const state = VideoCallSessionState(micEnabled: true);
      expect(state.isMicActiveForUi, isTrue);
--- a/test/features/video_calls/services/video_call_audio_session_coordinator_test.dart
+++ b/test/features/video_calls/services/video_call_audio_session_coordinator_test.dart
@@ -20,9 +20,12 @@ void main() {
      final resumed = await coordinator.reactivate();
      expect(resumed, isTrue);

+      await coordinator.restartCapture();
+      expect(coordinator.isActive, isTrue);
+
      await coordinator.stop();
      expect(coordinator.isActive, isFalse);
-      expect(calls, ['activate', 'activate', 'deactivate']);
+      expect(calls, ['activate', 'activate', 'restart', 'deactivate']);
    });

    test('stop clears the active session when deactivate fails', () async {
--- a/test/features/video_calls/services/video_call_peer_departure_test.dart
+++ b/test/features/video_calls/services/video_call_peer_departure_test.dart
@@ -0,0 +1,109 @@
+import 'package:eatvio_app/features/video_calls/services/video_call_peer_departure.dart';
+import 'package:flutter_test/flutter_test.dart';
+import 'package:livekit_client/livekit_client.dart' as lk;
+
+void main() {
+  test('ends the call when the other user leaves the room', () {
+    expect(
+      shouldForceEndCallAfterPeerLeft(
+        callStageEntered: true,
+        sessionConnected: true,
+        remoteIdentities: const [],
+      ),
+      isTrue,
+    );
+  });
+
+  test('keeps the call when another user is still in the room', () {
+    expect(
+      shouldForceEndCallAfterPeerLeft(
+        callStageEntered: true,
+        sessionConnected: true,
+        remoteIdentities: const ['user-7', 'EG_recorder'],
+      ),
+      isFalse,
+    );
+  });
+
+  test('ignores an egress bot after the other user has left', () {
+    expect(
+      shouldForceEndCallAfterPeerLeft(
+        callStageEntered: true,
+        sessionConnected: true,
+        remoteIdentities: const ['EG_recorder'],
+      ),
+      isTrue,
+    );
+  });
+
+  test('does not end a call that has not entered the stage', () {
+    expect(
+      shouldForceEndCallAfterPeerLeft(
+        callStageEntered: false,
+        sessionConnected: true,
+        remoteIdentities: const [],
+      ),
+      isFalse,
+    );
+  });
+
+  test('ends the call when the server removes this participant', () {
+    expect(
+      shouldForceEndCallAfterRoomDisconnect(
+        callStageEntered: true,
+        sessionConnected: true,
+        reason: lk.DisconnectReason.participantRemoved,
+      ),
+      isTrue,
+    );
+    expect(
+      shouldForceEndCallAfterRoomDisconnect(
+        callStageEntered: true,
+        sessionConnected: true,
+        reason: lk.DisconnectReason.roomDeleted,
+      ),
+      isTrue,
+    );
+  });
+
+  test('does not report the end while the other user is still in the room', () {
+    expect(
+      shouldNotifyCallEnded(
+        alreadyNotified: false,
+        hasConversation: true,
+        peerStillInRoom: true,
+      ),
+      isFalse,
+    );
+  });
+
+  test('reports the end when this client is the last participant', () {
+    expect(
+      shouldNotifyCallEnded(
+        alreadyNotified: false,
+        hasConversation: true,
+        peerStillInRoom: false,
+      ),
+      isTrue,
+    );
+    expect(
+      shouldNotifyCallEnded(
+        alreadyNotified: true,
+        hasConversation: true,
+        peerStillInRoom: false,
+      ),
+      isFalse,
+    );
+  });
+
+  test('keeps a connection-loss screen when the link drops', () {
+    expect(
+      shouldForceEndCallAfterRoomDisconnect(
+        callStageEntered: true,
+        sessionConnected: true,
+        reason: lk.DisconnectReason.disconnected,
+      ),
+      isFalse,
+    );
+  });
+}
--- a/test/features/video_calls/services/video_call_push_payload_test.dart
+++ b/test/features/video_calls/services/video_call_push_payload_test.dart
@@ -57,6 +57,7 @@ void main() {
      });

      expect(payload, isNotNull);
+      expect(payload!.conversationUuid, 'abc-123');
    });

    test('parses message id for a stable CallKit uuid', () {
Author	SHA1	Message	Date
misha	293601f1e1	Merge pull request 'feat(ios): env migration for ios 27' (#1077 ) from misha/eatvio_app:main into main Reviewed-on: eatvio/eatvio_app#1077	2026-10-16 05:27:39 +00:00
misha	ff17b813ac	feat(ios): env migration for ios 27	2026-10-16 08:26:26 +03:00
misha	6a259e5452	Merge pull request 'feat(video_calls): ios mic fix, android call fix. feat(dev_tools): base url caching' (#1076 ) from misha/eatvio_app:main into main Reviewed-on: eatvio/eatvio_app#1076 Reviewed-by: Анатолий Полоз <t0ly.od@ya.ru>	2026-10-15 13:32:29 +00:00
misha	9288a5c849	version changed	2026-10-15 15:22:04 +03:00
misha	4ef174ebde	feat(video_calls): repeated calls after call termination fix	2026-10-15 15:21:38 +03:00
misha	1901248539	feat(video_calls): ios mic fix, android call fix. feat(dev_tools): base url caching	2026-10-15 14:06:37 +03:00