fix(client): contain previews and recover offline sessions and calls

crates/core/src/call.rs

@@ -99,7 +99,7 @@ impl IncomingCall {
             caller_jid,
             is_video,
             is_offline: offer.offline,
-            received_at: wacore::time::now_utc(),
+            received_at: offer.timestamp,
         }
     }
 

crates/core/src/calls.rs

@@ -325,6 +325,22 @@ impl CallState {
     /// The first offer wins the slot rather than the last, because that is the
     /// one the user has already been shown.
     pub fn set_incoming(&mut self, call: IncomingCall) -> Admission {
+        // Redelivered signaling must not park a call behind itself, including
+        // after it was accepted and its stage became active.
+        if self
+            .stage
+            .as_ref()
+            .is_some_and(|stage| stage.call_id() == call.call_id)
+        {
+            return Admission::Ringing;
+        }
+        if self
+            .waiting
+            .as_ref()
+            .is_some_and(|waiting| waiting.call_id() == &call.call_id)
+        {
+            return Admission::Parked;
+        }
         let Some(stage) = &self.stage else {
             self.remote_before_connect = None;
             self.stage = Some(Stage::Incoming(call));
@@ -1258,6 +1274,38 @@ mod tests {
         );
     }
 
+    #[test]
+    fn duplicate_offers_never_park_a_call_behind_itself() {
+        let mut state = CallState::default();
+        state.set_incoming(incoming("FIRST"));
+        let before = state.clone();
+        assert_eq!(state.set_incoming(incoming("FIRST")), Admission::Ringing);
+        assert_eq!(state, before);
+        state.connect(&"FIRST".into());
+        state.set_incoming(incoming("SECOND"));
+        let before = state.clone();
+        assert_eq!(state.set_incoming(incoming("FIRST")), Admission::Ringing);
+        assert_eq!(state.set_incoming(incoming("SECOND")), Admission::Parked);
+        assert_eq!(state, before);
+        state.end(&"FIRST".into());
+        assert_eq!(state.incoming().unwrap().call_id, "SECOND");
+        assert!(state.waiting().is_none());
+    }
+
+    #[test]
+    fn incoming_calls_keep_the_protocol_timestamp() {
+        let mut wire = offer("OLD");
+        wire.timestamp = chrono::DateTime::from_timestamp(1_700_000_000, 0).unwrap();
+        let call = IncomingCall::new(
+            "OLD",
+            "Example".into(),
+            "a@s.whatsapp.net".into(),
+            false,
+            &wire,
+        );
+        assert_eq!(call.received_at, wire.timestamp);
+    }
+
     /// The same promotion, on the other way a stage can empty for good: a
     /// call this device never managed to place. `take_outgoing` cleared the
     /// stage and left the parked caller ringing behind an empty card.

crates/daemon/src/server/requests.rs

@@ -173,6 +173,9 @@ pub(super) async fn handle_request(
             .await
         }
         ClientRequest::ReloadHistory => acted(dispatch(hub, commands, Action::ReloadHistory).await),
+        ClientRequest::ReconnectSession => {
+            acted(dispatch(hub, commands, Action::ReconnectSession).await)
+        }
         // Answered with the page under this id, like a download and for the
         // same reason.
         ClientRequest::LoadMessages(request) => {

crates/daemon/src/server/tests.rs

@@ -613,6 +613,48 @@ fn a_mismatched_hello_is_rejected_with_both_versions() {
     }
 }
 
+#[test]
+fn a_daemon_before_manual_whatsapp_retry_is_rejected() {
+    let rejection = check_hello(&hello(39, false)).expect_err("v39 cannot carry ReconnectSession");
+    assert!(matches!(
+        serde_json::from_str::<DaemonMessage>(&rejection.unwrap()).unwrap(),
+        DaemonMessage::Error {
+            error: ProtocolError::VersionMismatch {
+                client: 39,
+                daemon: 40
+            },
+            ..
+        }
+    ));
+}
+
+#[tokio::test]
+async fn manual_whatsapp_retry_reaches_the_session_while_offline() {
+    let hub = connected_hub();
+    hub.apply(crate::state::Change::live(
+        oxidezap_ipc::DaemonEvent::ConnectionChanged(oxidezap_ipc::ConnectionState::Disconnected {
+            reason: "synthetic drop".into(),
+        }),
+    ));
+    let (commands, taken) = bridge(CommandOutcome::Accepted);
+    let answer = handle_request(
+        bare(ClientRequest::ReconnectSession),
+        &hub,
+        &no_plugins(),
+        &commands,
+        &outbox(),
+    )
+    .await;
+    assert!(matches!(
+        parse(answer.frame),
+        DaemonMessage::Accepted { .. }
+    ));
+    assert!(matches!(
+        taken.await.unwrap(),
+        Some(Action::ReconnectSession)
+    ));
+}
+
 #[test]
 fn state_is_not_served_before_a_hello() {
     let line = serde_json::to_string(&ClientRequest::Snapshot).unwrap();

crates/daemon/src/session_bridge/act.rs

@@ -1760,6 +1760,23 @@ impl Bridge {
                 client.reload_history();
                 CommandOutcome::Accepted
             }
+            Action::ReconnectSession => {
+                if matches!(
+                    self.hub.connection(),
+                    oxidezap_ipc::ConnectionState::LoggedOut { .. }
+                ) {
+                    return CommandOutcome::Refused(
+                        "this account must be paired again".to_string(),
+                    );
+                }
+                match client.retry_connection().await {
+                    Ok(Ok(())) => CommandOutcome::Accepted,
+                    Ok(Err(detail)) => CommandOutcome::NoSession(detail),
+                    Err(_) => CommandOutcome::NoSession(
+                        "the session stopped during reconnection".to_string(),
+                    ),
+                }
+            }
             Action::RefreshAvatars => {
                 client.reset_avatar_cache();
                 CommandOutcome::Accepted

crates/daemon/src/session_bridge/action.rs

@@ -55,6 +55,7 @@ pub enum Action {
     /// Reload the whole history, for a front end that has just attached and
     /// holds nothing.
     ReloadHistory,
+    ReconnectSession,
     /// Forget every resolved picture and resolve them again.
     ///
     /// For a cleared media cache: the metadata may be unchanged, but the bytes
@@ -224,6 +225,7 @@ impl Action {
             _ => !matches!(
                 self,
                 Self::ReloadHistory
+                    | Self::ReconnectSession
                     | Self::RefreshVideo
                     | Self::ForgetSession(_)
                     | Self::MarkStatusWatched(_)

crates/gui/src/app/body.rs

@@ -433,6 +433,34 @@ pub(super) mod tests {
         (cx, app)
     }
 
+    fn start_outgoing_call(
+        cx: &mut gpui::VisualTestContext,
+        app: &Entity<WhatsAppApp>,
+        call_id: &str,
+    ) {
+        app.update(cx, |app, cx| {
+            app.calls.update(cx, |calls, cx| {
+                calls.place_outgoing(
+                    OutgoingCall::new(
+                        call_id,
+                        "peer@example.invalid".into(),
+                        "Test peer".into(),
+                        false,
+                    ),
+                    cx,
+                );
+            });
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+    }
+
+    fn outgoing_call_cancel_point(cx: &mut gpui::VisualTestContext) -> gpui::Point<gpui::Pixels> {
+        cx.debug_bounds("call-cancel")
+            .expect("the outgoing call must render its Cancel control")
+            .center()
+    }
+
     #[gpui::test]
     fn pasted_image_waits_in_a_visible_preview(cx: &mut gpui::TestAppContext) {
         let (mut cx, app) = paste_preview_fixture(cx);
@@ -511,6 +539,182 @@ pub(super) mod tests {
         });
     }
 
+    #[gpui::test]
+    fn paste_preview_background_does_not_activate_overlapping_call_control(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let (mut cx, app) = connected_app_fixture(cx);
+        cx.simulate_resize(gpui::size(gpui::px(1600.), gpui::px(1100.)));
+        cx.run_until_parked();
+        start_outgoing_call(&mut cx, &app, "test-call-before-preview");
+        let baseline_point = outgoing_call_cancel_point(&mut cx);
+        cx.simulate_click(baseline_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.read(|cx| assert!(app.read(cx).call_state(cx).stage().is_none()));
+
+        start_outgoing_call(&mut cx, &app, "test-call-under-preview");
+        let call_cancel_point = outgoing_call_cancel_point(&mut cx);
+
+        cx.update(|_window, cx| {
+            app.update(cx, |app, cx| {
+                assert!(app.open_confirmation(
+                    "peer@example.invalid".into(),
+                    None,
+                    crate::platform::picker::Chosen {
+                        files: vec![crate::platform::picker::Picked::automatic(
+                            "pasted.png".into(),
+                            "image/png".into(),
+                            one_pixel_png(),
+                        )],
+                        refused: Vec::new(),
+                    },
+                    cx,
+                ));
+            });
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+
+        cx.read(|cx| {
+            let app = app.read(cx);
+            assert!(app.call_state(cx).stage().is_some());
+            assert!(app.paste_preview.is_some());
+            assert!(
+                !app.keyboard_surfaces.call_card,
+                "a confirmation modal must temporarily hide the interactive call card"
+            );
+            assert_eq!(app.keyboard_owner, Some(KeyboardOwner::PastePreview));
+        });
+        let preview = cx
+            .debug_bounds("paste-preview")
+            .expect("the modal preview must cover the window");
+        assert!(
+            preview.contains(&call_cancel_point),
+            "the modal covers the previously verified call control point"
+        );
+
+        cx.simulate_click(call_cancel_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+
+        cx.read(|cx| {
+            let app = app.read(cx);
+            assert!(
+                app.paste_preview.is_some(),
+                "background click keeps preview open"
+            );
+            assert!(
+                app.call_state(cx).stage().is_some(),
+                "the overlapping call control must not receive the modal click"
+            );
+            assert!(
+                !app.keyboard_surfaces.call_card,
+                "the card stays suppressed while the modal is open"
+            );
+        });
+
+        let cancel = cx
+            .debug_bounds("paste-preview-cancel")
+            .expect("cancel control");
+        cx.simulate_click(cancel.center(), gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+        cx.read(|cx| {
+            let app = app.read(cx);
+            assert!(app.paste_preview.is_none());
+            assert!(app.call_state(cx).stage().is_some());
+            assert_eq!(
+                app.keyboard_owner,
+                Some(KeyboardOwner::RingingCall("test-call-under-preview".into()))
+            );
+            assert!(
+                app.keyboard_surfaces.call_card,
+                "the card returns after close"
+            );
+        });
+
+        cx.simulate_click(call_cancel_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.read(|cx| assert!(app.read(cx).call_state(cx).stage().is_none()));
+    }
+
+    #[gpui::test]
+    fn media_viewer_scrim_does_not_activate_overlapping_call_control(
+        cx: &mut gpui::TestAppContext,
+    ) {
+        let (mut cx, app) = connected_app_fixture(cx);
+        cx.simulate_resize(gpui::size(gpui::px(1600.), gpui::px(1100.)));
+        cx.run_until_parked();
+
+        start_outgoing_call(&mut cx, &app, "test-call-before-viewer");
+        let baseline_point = outgoing_call_cancel_point(&mut cx);
+        cx.simulate_click(baseline_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.read(|cx| assert!(app.read(cx).call_state(cx).stage().is_none()));
+
+        start_outgoing_call(&mut cx, &app, "test-call-under-viewer");
+        let call_cancel_point = outgoing_call_cancel_point(&mut cx);
+        cx.update(|window, cx| {
+            app.update(cx, |app, cx| {
+                let mut photo = ChatMessage::new_incoming(
+                    "viewer-photo".into(),
+                    "peer@example.invalid".into(),
+                    String::new(),
+                );
+                photo.media = Some(
+                    oxidezap_core::MediaContent::image(
+                        std::sync::Arc::new(one_pixel_png()),
+                        "image/png".into(),
+                        false,
+                    )
+                    .with_size(Some(1), Some(1)),
+                );
+                Arc::make_mut(&mut app.chats[0]).messages.push(photo);
+                app.open_media_viewer("viewer-photo", window, cx);
+            });
+        });
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+
+        cx.read(|cx| {
+            let app = app.read(cx);
+            assert!(app.media_viewer(cx).is_some());
+            assert!(app.call_state(cx).stage().is_some());
+            assert!(
+                !app.keyboard_surfaces.call_card,
+                "a fullscreen viewer must temporarily hide the interactive call card"
+            );
+            assert_eq!(app.keyboard_owner, Some(KeyboardOwner::Viewer));
+        });
+
+        cx.simulate_click(call_cancel_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.update(|window, cx| window.draw(cx).clear(cx));
+        cx.read(|cx| {
+            let app = app.read(cx);
+            assert!(
+                app.media_viewer(cx).is_none(),
+                "the scrim keeps its close action"
+            );
+            assert!(
+                app.call_state(cx).stage().is_some(),
+                "the call control behind the scrim must not receive its click"
+            );
+            assert_eq!(
+                app.keyboard_owner,
+                Some(KeyboardOwner::RingingCall("test-call-under-viewer".into()))
+            );
+            assert!(
+                app.keyboard_surfaces.call_card,
+                "the card returns after close"
+            );
+        });
+
+        cx.simulate_click(call_cancel_point, gpui::Modifiers::default());
+        cx.run_until_parked();
+        cx.read(|cx| assert!(app.read(cx).call_state(cx).stage().is_none()));
+    }
+
     #[gpui::test]
     fn escape_cancels_preview_without_sending_and_restores_composer(cx: &mut gpui::TestAppContext) {
         let (mut cx, app) = paste_preview_fixture(cx);

crates/gui/src/app/calls_ctl.rs

@@ -962,6 +962,9 @@ impl WhatsAppApp {
     /// Take the daemon's call state as authoritative, and write down whatever
     /// ended on the way.
     pub(super) fn adopt_calls(&mut self, mut calls: CallState, cx: &mut Context<Self>) {
+        if self.is_offline() {
+            calls.end_all();
+        }
         // Named here rather than inside the entity, because a caller's name
         // comes from this window's chat list.
         self.name_callers(&mut calls);