fix(core/ui): make button press cancel current hold

core/.changelog.d/3772.fixed

@@ -0,0 +1 @@
+[T3B1] Fix behavior of a button press during "hold to confirm".

core/embed/rust/src/ui/event/button.rs

@@ -12,8 +12,10 @@ pub enum ButtonEvent {
     /// Button released up.
     /// ▲ * | * ▲
     ButtonReleased(PhysicalButton),
+
     HoldStarted,
     HoldEnded,
+    HoldCanceled,
 }
 
 impl ButtonEvent {

core/embed/rust/src/ui/layout_samson/component/button_controller.rs

@@ -215,19 +215,26 @@ impl ButtonContainer {
         self.long_pressed_timer.expire(event)
     }
 
-    /// Registering hold event.
+    /// Registering the hold event
     pub fn hold_started(&mut self, ctx: &mut EventCtx) {
         if let ButtonType::HoldToConfirm(htc) = &mut self.button_type {
             htc.event(ctx, Event::Button(ButtonEvent::HoldStarted));
         }
     }
 
-    /// Cancelling hold event.
+    /// Ending the hold event by releasing the button held
     pub fn hold_ended(&mut self, ctx: &mut EventCtx) {
         if let ButtonType::HoldToConfirm(htc) = &mut self.button_type {
             htc.event(ctx, Event::Button(ButtonEvent::HoldEnded));
         }
     }
+
+    /// Canceling the hold event
+    pub fn hold_canceled(&mut self, ctx: &mut EventCtx) {
+        if let ButtonType::HoldToConfirm(htc) = &mut self.button_type {
+            htc.event(ctx, Event::Button(ButtonEvent::HoldCanceled));
+        }
+    }
 }
 
 /// Component responsible for handling buttons.
@@ -469,11 +476,19 @@ impl Component for ButtonController {
                                     Some(ButtonControllerMsg::Pressed(ButtonPos::Middle)),
                                 )
                             } else {
-                                self.got_pressed(ctx, b.into());
+                                // When a button gets pressed while another one is being held,
-                                (
+                                // cancel the hold and do not register the press.
-                                    ButtonState::BothDown,
+                                match which_down {
-                                    Some(ButtonControllerMsg::Pressed(b.into())),
+                                    PhysicalButton::Left => {
-                                )
+                                        self.left_btn.hold_canceled(ctx);
+                                    }
+                                    PhysicalButton::Right => {
+                                        self.right_btn.hold_canceled(ctx);
+                                    }
+                                    _ => {}
+                                }
+
+                                return None;
                             }
                         }
                         _ => (self.state, None),

core/embed/rust/src/ui/layout_samson/component/hold_to_confirm.rs

@@ -105,6 +105,9 @@ impl Component for HoldToConfirm {
                     self.loader.start_shrinking(ctx, Instant::now());
                 }
             }
+            Event::Button(ButtonEvent::HoldCanceled) => {
+                self.loader.shrink_completely(ctx, Instant::now());
+            }
             _ => {}
         };
 

core/embed/rust/src/ui/layout_samson/component/loader.rs

@@ -107,13 +107,13 @@ impl Loader {
         ctx.request_paint();
     }
 
-    pub fn start_shrinking(&mut self, ctx: &mut EventCtx, now: Instant) {
+    fn start_shrinking_with_duration(
-        let mut anim = Animation::new(
+        &mut self,
-            display::LOADER_MAX,
+        ctx: &mut EventCtx,
-            display::LOADER_MIN,
+        now: Instant,
-            self.shrinking_duration,
+        duration: Duration,
-            now,
+    ) {
-        );
+        let mut anim = Animation::new(display::LOADER_MAX, display::LOADER_MIN, duration, now);
         if let State::Growing(growing) = &self.state {
             anim.seek_to_value(display::LOADER_MAX - growing.value(now));
         }
@@ -125,6 +125,14 @@ impl Loader {
         ctx.request_paint();
     }
 
+    pub fn start_shrinking(&mut self, ctx: &mut EventCtx, now: Instant) {
+        self.start_shrinking_with_duration(ctx, now, self.shrinking_duration);
+    }
+
+    pub fn shrink_completely(&mut self, ctx: &mut EventCtx, now: Instant) {
+        self.start_shrinking_with_duration(ctx, now, Duration::from_millis(0));
+    }
+
     pub fn reset(&mut self) {
         self.state = State::Initial;
     }