rust: proper bip39 async unlock combined with unlock animation

We join the bip39 async task and the unlock animation task to run in
tandem until both are finished.

The old interrupt-timer based lock animation is now unused and deleted.

Author: benma

src/CMakeLists.txt

@@ -53,7 +53,6 @@ set(DBB-FIRMWARE-USB-SOURCES ${DBB-FIRMWARE-USB-SOURCES} PARENT_SCOPE)
 set(DBB-FIRMWARE-UI-SOURCES
     ${CMAKE_SOURCE_DIR}/src/screen.c
     ${CMAKE_SOURCE_DIR}/src/ui/graphics/graphics.c
-    ${CMAKE_SOURCE_DIR}/src/ui/graphics/lock_animation.c
     ${CMAKE_SOURCE_DIR}/src/ui/ugui/ugui.c
     ${CMAKE_SOURCE_DIR}/src/ui/fonts/font_a_9X9.c
     ${CMAKE_SOURCE_DIR}/src/ui/fonts/font_a_11X10.c

src/rust/bitbox02-rust/src/workflow/unlock.rs

@@ -133,7 +133,8 @@ pub async fn unlock_bip39(hal: &mut impl crate::hal::Hal, seed: &[u8]) {
         }
     }
 
-    let result = bitbox02::ui::with_lock_animation(async || {
+    let ((), result) = util::bb02_async::join(
+        super::unlock_animation::animate(),
         keystore::unlock_bip39(
             crate::secp256k1::SECP256K1,
             seed,
@@ -146,10 +147,10 @@ pub async fn unlock_bip39(hal: &mut impl crate::hal::Hal, seed: &[u8]) {
             // iteration to a minimum.
             #[cfg(not(feature = "c-unit-testing"))]
             async |_idx| util::bb02_async::yield_now().await,
-        )
-        .await
-    })
+        ),
+    )
     .await;
+
     if result.is_err() {
         abort("bip39 unlock failed");
     }

src/rust/bitbox02-sys/build.rs

@@ -86,8 +86,6 @@ const ALLOWLIST_FNS: &[&str] = &[
     "keystore_test_get_retained_bip39_seed_encrypted",
     "label_create",
     "localtime",
-    "lock_animation_start",
-    "lock_animation_stop",
     "memory_set_salt_root",
     "memory_add_noise_remote_static_pubkey",
     "memory_bootloader_hash",
@@ -215,6 +213,7 @@ const BITBOX02_SOURCES: &[&str] = &[
     "src/ui/components/label.c",
     "src/ui/components/left_arrow.c",
     "src/ui/components/lockscreen.c",
+    "src/ui/components/unlock_animation.c",
     "src/ui/components/menu.c",
     "src/ui/components/orientation_arrows.c",
     "src/ui/components/progress.c",
@@ -238,7 +237,6 @@ const BITBOX02_SOURCES: &[&str] = &[
     "src/ui/fonts/password_11X12.c",
     "src/ui/fonts/password_9X9.c",
     "src/ui/graphics/graphics.c",
-    "src/ui/graphics/lock_animation.c",
     "src/ui/oled/sh1107.c",
     "src/ui/oled/ssd1312.c",
     "src/ui/screen_process.c",

src/rust/bitbox02-sys/wrapper.h

@@ -44,7 +44,6 @@
 #include <ui/fonts/font_a_9X9.h>
 #include <ui/fonts/monogram_5X9.h>
 #include <ui/fonts/password_11X12.h>
-#include <ui/graphics/lock_animation.h>
 #include <ui/oled/oled.h>
 #include <ui/screen_process.h>
 #include <ui/screen_saver.h>

src/rust/bitbox02/src/ui/ui.rs

@@ -436,13 +436,6 @@ pub fn trinary_input_string_set_input(component: &mut Component, word: &str) {
     }
 }
 
-pub async fn with_lock_animation<F: AsyncFn() -> R, R>(f: F) -> R {
-    unsafe { bitbox02_sys::lock_animation_start() };
-    let result = f().await;
-    unsafe { bitbox02_sys::lock_animation_stop() };
-    result
-}
-
 pub fn screen_stack_pop_all() {
     unsafe {
         bitbox02_sys::ui_screen_stack_pop_all();

src/rust/bitbox02/src/ui/ui_stub.rs

@@ -119,10 +119,6 @@ pub fn trinary_input_string_set_input(_component: &mut Component, _word: &str) {
     panic!("not used")
 }
 
-pub fn with_lock_animation<F: Fn() -> R, R>(f: F) -> R {
-    f()
-}
-
 pub fn screen_stack_pop_all() {}
 
 pub fn progress_create<'a>(_title: &str) -> Component<'a> {

src/rust/bitbox02/src/ui/ui_stub_c_unit_tests.rs

@@ -162,10 +162,6 @@ pub fn trinary_input_string_set_input(_component: &mut Component, _word: &str) {
     panic!("not implemented")
 }
 
-pub fn with_lock_animation<F: Fn() -> R, R>(f: F) -> R {
-    f()
-}
-
 pub fn screen_stack_pop_all() {}
 
 pub fn progress_create<'a>(_title: &str) -> Component<'a> {

src/rust/util/src/bb02_async.rs

@@ -74,6 +74,38 @@ pub fn yield_now() -> impl core::future::Future<Output = ()> {
     })
 }
 
+/// Executes both futures in tandem, returning the results of both when both are done.
+pub fn join<O1, O2>(
+    fut1: impl core::future::Future<Output = O1>,
+    fut2: impl core::future::Future<Output = O2>,
+) -> impl core::future::Future<Output = (O1, O2)> {
+    let mut fut1 = Box::pin(fut1);
+    let mut fut2 = Box::pin(fut2);
+
+    let mut result1 = None;
+    let mut result2 = None;
+
+    core::future::poll_fn(move |cx| {
+        if result1.is_none() {
+            if let Poll::Ready(res) = fut1.as_mut().poll(cx) {
+                result1 = Some(res);
+            }
+        }
+
+        if result2.is_none() {
+            if let Poll::Ready(res) = fut2.as_mut().poll(cx) {
+                result2 = Some(res);
+            }
+        }
+
+        if result1.is_some() && result2.is_some() {
+            Poll::Ready((result1.take().unwrap(), result2.take().unwrap()))
+        } else {
+            Poll::Pending
+        }
+    })
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;
@@ -93,4 +125,21 @@ mod tests {
         assert_eq!(spin(&mut task), Poll::Pending);
         assert_eq!(spin(&mut task), Poll::Ready(42));
     }
+
+    #[test]
+    fn test_join() {
+        async fn f1() -> i32 {
+            -42
+        }
+
+        async fn f2() -> Box<u32> {
+            yield_now().await;
+            yield_now().await;
+            yield_now().await;
+            Box::new(42)
+        }
+
+        assert_eq!(block_on(join(f1(), f2())), (-42, Box::new(42)));
+        assert_eq!(block_on(join(f2(), f1())), (Box::new(42), -42));
+    }
 }

src/ui/components/unlock_animation.c

@@ -17,6 +17,7 @@
 #include <hardfault.h>
 #include <screen.h>
 #include <ui/component.h>
+#include <ui/screen_process.h>
 #include <ui/ui_util.h>
 
 #include <stdint.h>
@@ -25,7 +26,11 @@
 // This many iterations times the slowdown factor to render the whole animation.
 #define LOCK_ANIMATION_N_FRAMES (38)
 
-#define SLOWDOWN_FACTOR (10)
+// Since BIP39 unlock takes 2048 iterations, and the screen frame rate is 30 (SCREEN_FRAME_RATE,
+// render is called only every 30th iteration), if we want both to finish at the same time, the
+// slowdown factor becomes the following. 1 is subtracted so the animation takes longer, not
+// shorter, than the actual unlock.
+#define SLOWDOWN_FACTOR (2048 / ((float)LOCK_ANIMATION_N_FRAMES * (float)SCREEN_FRAME_RATE - 1))
 
 #define LOCK_ANIMATION_FRAME_WIDTH (28)
 #define LOCK_ANIMATION_FRAME_HEIGHT (25)