session_manager_lib/

debug.rs

// Copyright 2026 The Fuchsia Authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

use fuchsia_sync::Mutex;
use futures::StreamExt;
use log::{debug, info, warn};
use std::sync::{Arc, LazyLock};
use zx;

use fidl::endpoints::create_request_stream;
use fidl_fuchsia_feedback as ffeedback;
use fidl_fuchsia_hardware_power_statecontrol as fpower;
use fidl_fuchsia_ui_input::MediaButtonsEvent;
use fidl_fuchsia_ui_policy as fuipolicy;

static MAX_PRESS_INTERVAL_NS: LazyLock<i64> = LazyLock::new(|| 500 * 1_000_000); // 500ms in nanoseconds
const REQUIRED_PRESS_COUNT: u32 = 5;

pub trait Clock: Send + Sync {
    fn now_ns(&self) -> i64;
}

pub struct BootClock;

impl Clock for BootClock {
    fn now_ns(&self) -> i64 {
        zx::BootInstant::get().into_nanos()
    }
}

#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
struct CurrentButtons {
    power_pressed: bool,
    volume_up_pressed: bool,
    volume_down_pressed: bool,
}

impl CurrentButtons {
    fn both_volume_pressed(self) -> bool {
        self.volume_up_pressed && self.volume_down_pressed
    }
}

#[derive(Debug)]
struct ButtonPressState {
    count: u32,
    last_press_time_ns: i64,
    buttons: CurrentButtons,
    crash_report_in_progress: bool,
    #[cfg(test)]
    action_triggered_count: u32,
}

impl ButtonPressState {
    fn new() -> Self {
        Self {
            count: 0,
            last_press_time_ns: 0,
            buttons: CurrentButtons::default(),
            crash_report_in_progress: false,
            #[cfg(test)]
            action_triggered_count: 0,
        }
    }
}

pub struct DebugState<C: Clock> {
    /// Whether the system supports 5-button press to debug.
    debug_enabled: bool,
    button_press_state: Mutex<ButtonPressState>,
    clock: C,
    crash_reporter_source: Option<ffeedback::CrashReporterProxy>,
    power_statecontrol_admin_source: Option<fpower::AdminProxy>,
    listener_task: Mutex<Option<fuchsia_async::Task<()>>>,
}

/// The concrete `DebugState` used in production.
pub type DebugManager = DebugState<BootClock>;

impl DebugState<BootClock> {
    pub fn new(debug_enabled: bool) -> Self {
        Self {
            debug_enabled,
            button_press_state: Mutex::new(ButtonPressState::new()),
            clock: BootClock,
            crash_reporter_source: fuchsia_component::client::connect_to_protocol::<
                ffeedback::CrashReporterMarker,
            >()
            .map_err(|e| warn!("Failed to connect to CrashReporter: {e}"))
            .ok(),
            power_statecontrol_admin_source: fuchsia_component::client::connect_to_protocol::<
                fpower::AdminMarker,
            >()
            .map_err(|e| warn!("Failed to connect to PowerStateControlAdmin: {e}"))
            .ok(),
            listener_task: Mutex::new(None),
        }
    }
}

impl<C: Clock + 'static> DebugState<C> {
    #[cfg(test)]
    fn new_for_test(
        debug_enabled: bool,
        clock: C,
        crash_reporter_proxy: Option<ffeedback::CrashReporterProxy>,
        power_statecontrol_admin_proxy: Option<fpower::AdminProxy>,
    ) -> Self {
        Self {
            debug_enabled,
            button_press_state: Mutex::new(ButtonPressState::new()),
            clock,
            crash_reporter_source: crash_reporter_proxy,
            power_statecontrol_admin_source: power_statecontrol_admin_proxy,
            listener_task: Mutex::new(None),
        }
    }

    pub fn start_media_buttons_listener(self: Arc<Self>) {
        if !self.debug_enabled {
            info!("Debug mode not enabled, skipping media button listener registration.");
            return;
        }

        let mut task_lock = self.listener_task.lock();
        if task_lock.is_some() {
            // Already listening.
            return;
        }

        info!("Registering for media button events to enable 5-button press for debug.");
        let weak_this = Arc::downgrade(&self);
        let task = fuchsia_async::Task::spawn(async move {
            match fuchsia_component::client::connect_to_protocol::<
                fuipolicy::DeviceListenerRegistryMarker,
            >() {
                Ok(device_listener_registry) => {
                    let (client_end, mut stream) =
                        create_request_stream::<fuipolicy::MediaButtonsListenerMarker>();
                    if let Err(e) = device_listener_registry.register_listener(client_end).await {
                        warn!("Failed to register media buttons listener: {e:?}");
                        return;
                    }
                    while let Some(Ok(request)) = stream.next().await {
                        if let fuipolicy::MediaButtonsListenerRequest::OnEvent {
                            event,
                            responder,
                        } = request
                        {
                            if let Some(this) = weak_this.upgrade() {
                                if this.process_button_event(&event) {
                                    info!(
                                        "Detected 5 volume up+down button presses in a row. Filing crash report."
                                    );
                                    if this.file_crash_report().await {
                                        if !this.reboot_device().await {
                                            this.button_press_state
                                                .lock()
                                                .crash_report_in_progress = false;
                                        }
                                    } else {
                                        this.button_press_state.lock().crash_report_in_progress =
                                            false;
                                    }
                                }
                            } else {
                                // DebugState was dropped, exit the task.
                                break;
                            }
                            if let Err(e) = responder.send() {
                                warn!("Failed to send response for media buttons event: {e:?}");
                            }
                        }
                    }
                }
                Err(e) => {
                    warn!("Failed to connect to fuchsia.ui.policy.DeviceListenerRegistry: {e:?}");
                }
            }
        });
        *task_lock = Some(task);
    }

    fn process_button_event(&self, event: &MediaButtonsEvent) -> bool {
        let mut state = self.button_press_state.lock();
        // Update volume button states from discrete fields. We deliberately ignore
        // the legacy `volume: int8` field here because simultaneous button presses
        // cancel out in that representation.
        let was_both_pressed = state.buttons.both_volume_pressed();

        if let Some(v_up) = event.volume_up {
            state.buttons.volume_up_pressed = v_up;
        }
        if let Some(v_down) = event.volume_down {
            state.buttons.volume_down_pressed = v_down;
        }

        let both_volume_pressed = state.buttons.both_volume_pressed();
        let is_new_press = both_volume_pressed && !was_both_pressed;

        if let Some(power_is_pressed) = event.power
            && (power_is_pressed || state.buttons.power_pressed)
        {
            if state.count >= 3 {
                info!(
                    "Detected overlapping POWER button activity; resetting VOLUME button counter."
                );
            } else {
                debug!(
                    "Detected overlapping POWER button activity; resetting VOLUME button counter."
                );
            }
            state.buttons.power_pressed = power_is_pressed;
            state.count = 0;
            return false;
        }

        if state.crash_report_in_progress {
            info!("Crash report in progress, ignoring button event.");
            return false;
        }

        if !is_new_press {
            return false;
        }

        // Rising edge of simultaneous press: both buttons are pressed at the same time.
        let now_ns = self.clock.now_ns();

        if now_ns - state.last_press_time_ns > *MAX_PRESS_INTERVAL_NS {
            state.count = 1;
        } else {
            state.count += 1;
        }

        state.last_press_time_ns = now_ns;

        if state.count >= 3 {
            info!(
                "Identified {:?} volume up+down button presses in a row. {:?} in a row will trigger a crash report and reboot sequence.",
                state.count, REQUIRED_PRESS_COUNT
            );
        }

        if state.count >= REQUIRED_PRESS_COUNT {
            state.count = 0;
            state.crash_report_in_progress = true;
            #[cfg(test)]
            {
                state.action_triggered_count += 1;
            }
            return true;
        }
        false
    }

    pub fn stop(&self) {
        if !self.debug_enabled {
            return;
        }
        info!("Resetting debug button press state.");
        *self.button_press_state.lock() = ButtonPressState::new();
    }

    #[cfg(test)]
    pub(crate) fn get_button_press_state_count(&self) -> u32 {
        self.button_press_state.lock().count
    }

    #[cfg(test)]
    pub(crate) fn set_button_press_state_count(&self, count: u32) {
        self.button_press_state.lock().count = count;
    }

    async fn file_crash_report(&self) -> bool {
        if let Some(reporter) = &self.crash_reporter_source {
            let report = ffeedback::CrashReport {
                program_name: Some("session_manager".to_string()),
                crash_signature: Some("fuchsia-user-SOS-device-stuck".to_string()),
                is_fatal: Some(false),
                ..Default::default()
            };
            match reporter.file_report(report).await {
                Ok(Ok(_)) => {
                    info!("Successfully filed crash report.");
                    true
                }
                Ok(Err(e)) => {
                    warn!("Failed to file crash report: {e:?}");
                    false
                }
                Err(e) => {
                    warn!("Failed to file crash report: {e:?}");
                    false
                }
            }
        } else {
            warn!("Failed to get fuchsia.feedback.CrashReporter");
            false
        }
    }

    async fn reboot_device(&self) -> bool {
        info!("Rebooting device due to 5-button press.");
        if let Some(proxy) = self.power_statecontrol_admin_source.clone() {
            let options = fpower::ShutdownOptions {
                action: Some(fpower::ShutdownAction::Reboot),
                reasons: Some(vec![fpower::ShutdownReason::UserRequestDeviceStuck]),
                ..Default::default()
            };
            if let Err(e) = proxy.shutdown(&options).await {
                warn!("Failed to reboot device: {e:?}");
                false
            } else {
                true
            }
        } else {
            warn!("Failed to connect to fuchsia.hardware.power.statecontrol.Admin");
            false
        }
    }
}

#[cfg(test)]
mod tests {
    use super::*;
    use fidl::endpoints::create_proxy_and_stream;
    use fidl_fuchsia_ui_input as fui_input;
    use futures::{TryStreamExt, join};

    struct FakeClock {
        now: Mutex<i64>,
    }

    impl FakeClock {
        fn new() -> Self {
            Self { now: Mutex::new(0) }
        }

        fn advance_ns(&self, duration_ns: i64) {
            *self.now.lock() += duration_ns;
        }
    }

    impl Clock for FakeClock {
        fn now_ns(&self) -> i64 {
            *self.now.lock()
        }
    }

    // By implementing Clock for Arc<T>, we can pass a clone of the Arc to the DebugState,
    // while the test retains ownership of the original Arc. This allows the test to call
    // `advance_ns` on the FakeClock.
    impl<T: Clock> Clock for Arc<T> {
        fn now_ns(&self) -> i64 {
            self.as_ref().now_ns()
        }
    }

    fn make_both_press_event() -> fui_input::MediaButtonsEvent {
        fui_input::MediaButtonsEvent {
            volume_up: Some(true),
            volume_down: Some(true),
            ..Default::default()
        }
    }

    fn make_release_event() -> fui_input::MediaButtonsEvent {
        fui_input::MediaButtonsEvent {
            volume_up: Some(false),
            volume_down: Some(false),
            ..Default::default()
        }
    }

    #[fuchsia::test]
    fn test_successful_simultaneous_press_sequence() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();
        let release_event = make_release_event();

        // Press the buttons REQUIRED_PRESS_COUNT - 1 times, which should not trigger the debug state.
        for i in 1..REQUIRED_PRESS_COUNT {
            assert!(
                !debug_state.process_button_event(&press_event),
                "Incorrectly triggered action after {i} presses"
            );
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, i);
            assert_eq!(
                state.action_triggered_count, 0,
                "Incorrectly incremented trigger count after {i} presses. State: {state:?}"
            );
            drop(state);

            assert!(!debug_state.process_button_event(&release_event));
        }

        assert!(
            debug_state.process_button_event(&press_event),
            "The final press should trigger the sequence."
        );
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.action_triggered_count, 1, "State: {state:?}");
    }

    #[fuchsia::test]
    fn test_staggered_press_triggers() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let vol_up_event =
            fui_input::MediaButtonsEvent { volume_up: Some(true), ..Default::default() };
        let vol_down_event =
            fui_input::MediaButtonsEvent { volume_down: Some(true), ..Default::default() };
        let release_event = make_release_event();

        for i in 1..REQUIRED_PRESS_COUNT {
            assert!(!debug_state.process_button_event(&vol_up_event));
            assert!(!debug_state.process_button_event(&vol_down_event));
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, i);
            drop(state);

            assert!(!debug_state.process_button_event(&release_event));
        }

        assert!(!debug_state.process_button_event(&vol_up_event));
        assert!(debug_state.process_button_event(&vol_down_event));
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.action_triggered_count, 1);
    }

    #[fuchsia::test]
    fn test_holding_both_buttons_does_not_repeat_count() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();

        // Initial press
        assert!(!debug_state.process_button_event(&press_event));
        assert_eq!(debug_state.button_press_state.lock().count, 1);

        // Repeated events with both still pressed (e.g. from repeat or other metadata changes)
        assert!(!debug_state.process_button_event(&press_event));
        assert_eq!(debug_state.button_press_state.lock().count, 1);
        assert!(!debug_state.process_button_event(&press_event));
        assert_eq!(debug_state.button_press_state.lock().count, 1);
    }

    #[fuchsia::test]
    fn test_counter_resets_after_successful_sequence() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();
        let release_event = make_release_event();

        // Test that the counter resets after a successful sequence.
        for _ in 1..REQUIRED_PRESS_COUNT {
            assert!(!debug_state.process_button_event(&press_event));
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
            drop(state);
            assert!(!debug_state.process_button_event(&release_event));
        }
        assert!(debug_state.process_button_event(&press_event));
        {
            let mut state = debug_state.button_press_state.lock();
            assert_eq!(state.action_triggered_count, 1, "State: {state:?}");
            assert!(state.crash_report_in_progress);
            // Manually reset for test purposes.
            state.crash_report_in_progress = false;
        }

        assert!(!debug_state.process_button_event(&release_event));
        assert!(
            !debug_state.process_button_event(&press_event),
            "The next press should start a new sequence."
        );
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.count, 1, "State: {state:?}");
        assert_eq!(state.action_triggered_count, 1, "State: {state:?}");
    }

    #[fuchsia::test]
    fn test_ignores_presses_while_crash_report_in_progress() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();
        let release_event = make_release_event();

        // Trigger the crash report.
        for _ in 1..REQUIRED_PRESS_COUNT {
            assert!(!debug_state.process_button_event(&press_event));
            assert!(!debug_state.process_button_event(&release_event));
        }
        assert!(debug_state.process_button_event(&press_event));
        {
            let state = debug_state.button_press_state.lock();
            assert!(state.crash_report_in_progress);
            assert_eq!(state.action_triggered_count, 1);
        }

        // Try to press again, it should be ignored.
        assert!(!debug_state.process_button_event(&release_event));
        assert!(!debug_state.process_button_event(&press_event));
        assert!(!debug_state.process_button_event(&release_event));
        {
            let state = debug_state.button_press_state.lock();
            assert!(state.crash_report_in_progress);
            assert_eq!(state.action_triggered_count, 1);
            assert_eq!(state.count, 0);
        }

        // Manually reset the flag.
        debug_state.button_press_state.lock().crash_report_in_progress = false;

        // The next press should start a new sequence.
        assert!(!debug_state.process_button_event(&press_event));
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.count, 1);
    }

    #[fuchsia::test]
    fn test_counter_resets_after_timeout() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();
        let release_event = make_release_event();

        // Test that the counter resets after a timeout.
        for _ in 1..REQUIRED_PRESS_COUNT - 1 {
            assert!(!debug_state.process_button_event(&press_event));
            assert!(!debug_state.process_button_event(&release_event));
        }
        // Wait for longer than the max interval.
        clock.advance_ns(*MAX_PRESS_INTERVAL_NS + 1);

        assert!(
            !debug_state.process_button_event(&press_event),
            "This press should reset the counter to 1, not increment it."
        );
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.count, 1, "State: {state:?}");
        assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
    }

    #[fuchsia::test]
    fn test_power_button_press_resets_counter() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let press_event = make_both_press_event();
        let release_event = make_release_event();
        let power_press_event =
            fui_input::MediaButtonsEvent { power: Some(true), ..Default::default() };

        assert!(
            !debug_state.process_button_event(&press_event),
            "first volume press should not trigger action"
        );
        assert!(!debug_state.process_button_event(&release_event));
        {
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, 1, "should have count of 1. State: {state:?}");
        }
        assert!(
            !debug_state.process_button_event(&power_press_event),
            "power press should not trigger action"
        );
        {
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, 0, "A power press should reset the counter. State: {state:?}");
            assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
        }

        assert!(
            !debug_state.process_button_event(&press_event),
            "The next press should start a new sequence."
        );
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.count, 1, "State: {state:?}");
        assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
    }

    #[fuchsia::test]
    fn test_power_button_release_resets_counter() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let vol_press_event = make_both_press_event();
        let vol_release_event = make_release_event();
        let power_press_event =
            fui_input::MediaButtonsEvent { power: Some(true), ..Default::default() };
        let power_release_event =
            fui_input::MediaButtonsEvent { power: Some(false), ..Default::default() };

        assert!(
            !debug_state.process_button_event(&power_press_event),
            "power press should not trigger action"
        );
        {
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, 0, "count should be 0 after power press. State: {state:?}");
        }
        assert!(
            !debug_state.process_button_event(&vol_press_event),
            "volume press should not trigger action"
        );
        assert!(!debug_state.process_button_event(&vol_release_event));
        {
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, 1, "count should be 1 after volume press. State: {state:?}");
        }
        assert!(
            !debug_state.process_button_event(&power_release_event),
            "A power button release should reset the counter."
        );
        {
            let state = debug_state.button_press_state.lock();
            assert_eq!(state.count, 0, "count should be 0 after power release. State: {state:?}");
            assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
        }
        assert!(
            !debug_state.process_button_event(&vol_press_event),
            "The next press should start a new sequence."
        );
        let state = debug_state.button_press_state.lock();
        assert_eq!(state.count, 1, "State: {state:?}");
        assert_eq!(state.action_triggered_count, 0, "State: {state:?}");
    }

    #[fuchsia::test]
    fn test_single_button_press_does_not_increment() {
        let clock = Arc::new(FakeClock::new());
        let debug_state = DebugState::new_for_test(true, clock.clone(), None, None);

        let vol_up_event =
            fui_input::MediaButtonsEvent { volume_up: Some(true), ..Default::default() };
        let vol_down_event =
            fui_input::MediaButtonsEvent { volume_down: Some(true), ..Default::default() };
        let release_event = make_release_event();

        // REQUIRED_PRESS_COUNT presses of Volume Up only
        for _ in 0..REQUIRED_PRESS_COUNT {
            assert!(!debug_state.process_button_event(&vol_up_event));
            assert!(!debug_state.process_button_event(&release_event));
        }
        assert_eq!(debug_state.button_press_state.lock().count, 0);

        // REQUIRED_PRESS_COUNT presses of Volume Down only
        for _ in 0..REQUIRED_PRESS_COUNT {
            assert!(!debug_state.process_button_event(&vol_down_event));
            assert!(!debug_state.process_button_event(&release_event));
        }
        assert_eq!(debug_state.button_press_state.lock().count, 0);
    }

    async fn run_report_server(mut stream: ffeedback::CrashReporterRequestStream) {
        let request =
            stream.try_next().await.expect("failed to read from stream").expect("stream is empty");
        match request {
            ffeedback::CrashReporterRequest::FileReport { report, responder } => {
                assert_eq!(
                    report,
                    ffeedback::CrashReport {
                        program_name: Some("session_manager".to_string()),
                        crash_signature: Some("fuchsia-user-SOS-device-stuck".to_string()),
                        is_fatal: Some(false),
                        ..Default::default()
                    }
                );
                responder
                    .send(Ok(&ffeedback::FileReportResults::default()))
                    .expect("failed to send response");
            }
        }
    }

    #[fuchsia::test]
    async fn test_file_crash_report() {
        let clock = Arc::new(FakeClock::new());
        let (crash_reporter_proxy, stream) =
            create_proxy_and_stream::<ffeedback::CrashReporterMarker>();
        let (power_statecontrol_admin_proxy, _) = create_proxy_and_stream::<fpower::AdminMarker>();

        let server_fut = run_report_server(stream);

        // File the crash report.
        let debug_state = DebugState::new_for_test(
            true,
            clock.clone(),
            Some(crash_reporter_proxy),
            Some(power_statecontrol_admin_proxy),
        );
        let client_fut = async {
            assert!(debug_state.file_crash_report().await);
        };

        join!(client_fut, server_fut);
    }

    async fn run_reboot_server(mut stream: fpower::AdminRequestStream) {
        let request =
            stream.try_next().await.expect("failed to read from stream").expect("stream is empty");
        match request {
            fpower::AdminRequest::Shutdown { options, responder } => {
                assert_eq!(
                    options,
                    fpower::ShutdownOptions {
                        action: Some(fpower::ShutdownAction::Reboot),
                        reasons: Some(vec![fpower::ShutdownReason::UserRequestDeviceStuck]),
                        ..Default::default()
                    }
                );
                responder.send(Ok(())).expect("failed to send response");
            }
            _ => panic!("unexpected request"),
        }
    }

    #[fuchsia::test]
    async fn test_reboot_device() {
        let clock = Arc::new(FakeClock::new());
        let (crash_reporter_proxy, _) = create_proxy_and_stream::<ffeedback::CrashReporterMarker>();
        let (power_statecontrol_admin_proxy, stream) =
            create_proxy_and_stream::<fpower::AdminMarker>();

        let server_fut = run_reboot_server(stream);

        // Reboot the device.
        let debug_state = DebugState::new_for_test(
            true,
            clock.clone(),
            Some(crash_reporter_proxy),
            Some(power_statecontrol_admin_proxy),
        );
        let reboot_fut = debug_state.reboot_device();

        // Wait for the server to have received the call.
        let (reboot_succeeded, ()) = join!(reboot_fut, server_fut);
        assert!(reboot_succeeded);
    }
}