eepy-launcher: improve main page, implement app updates

eepy-launcher/src/main.rs

···
 extern crate panic_halt;
 
 use core::arch::asm;
+use core::mem::offset_of;
 use core::sync::atomic::Ordering;
 use usb_device::bus::UsbBusAllocator;
 use eepy_gui::draw_target::EpdDrawTarget;
···
 use eepy_sys::usb::{self, UsbBus};
 use usb_device::prelude::*;
 use usbd_serial::SerialPort;
-use eepy_sys::eepy_app;
+use eepy_sys::{eepy_app, flash};
+use eepy_sys::header::{slot_ptr, ProgramSlotHeader};
 use crate::serial::{HOST_APP, NEEDS_REFRESH, NEEDS_REFRESH_PROGRAMS};
 use crate::ui::MainGui;
 
 static mut USB: Option<UsbBusAllocator<UsbBus>> = None;
 static mut USB_DEVICE: Option<UsbDevice<UsbBus>> = None;
 static mut USB_SERIAL: Option<SerialPort<UsbBus>> = None;
+
+pub(crate) unsafe fn delete_program(slot: u8) {
+    let ptr = unsafe { slot_ptr(slot) };
+    let mut buf = [0u8; 256];
+    unsafe { buf.copy_from_slice(core::slice::from_raw_parts(ptr, 256)) };
+    let offset = offset_of!(ProgramSlotHeader, len);
+    buf[offset..offset + 4].copy_from_slice(&0usize.to_ne_bytes());
+
+    unsafe { flash::program(slot as u32 * 512 * 1024, &buf) };
+}
 
 #[eepy_app(name = "Launcher")]
 fn main() {

eepy-launcher/src/serial.rs

···
 use usbd_serial::SerialPort;
 use eepy_serial::{Response, SerialCommand};
 use eepy_sys::flash::erase_and_program;
-use eepy_sys::header::{slot, slot_ptr};
+use eepy_sys::header::{slot, slot_ptr, Programs};
 use eepy_sys::image::refresh;
-use eepy_sys::IMAGE_BYTES;
+use eepy_sys::{header, IMAGE_BYTES};
 use eepy_sys::input::{next_event, set_touch_enabled};
 use eepy_sys::misc::{debug, info, trace};
 use eepy_sys::usb::UsbBus;
-use crate::{USB_DEVICE, USB_SERIAL};
+use crate::{delete_program, USB_DEVICE, USB_SERIAL};
 use crate::ui::flashing::draw_flashing_ui;
 
 #[derive(Copy, Clone, Debug)]
···
                                 buf[0..4].copy_from_slice(&(erase_cycles + 1).to_ne_bytes());
 
                                 unsafe { write_flash(&buf[0..4096], slot, 0) };
+
+                                let this_header = unsafe { header::slot(slot) };
+                                let this_name = unsafe { core::slice::from_raw_parts((*this_header).name_ptr, (*this_header).name_len) };
+
+                                // If there is an old program with the same name, delete it
+                                Programs::new()
+                                    .filter_map(|prog| unsafe {
+                                        let name = core::slice::from_raw_parts((*prog).name_ptr, (*prog).name_len);
+                                        if (*prog).slot() != slot && name == this_name {
+                                            Some((*prog).slot())
+                                        } else {
+                                            None
+                                        }
+                                    })
+                                    .for_each(|slot| unsafe { delete_program(slot) });
+
                                 PROG_SLOT.store(0, Ordering::Relaxed);
 
                                 NEEDS_REFRESH_PROGRAMS.store(true, Ordering::Relaxed);

eepy-launcher/src/ui/page/app_info.rs

···
-use core::mem::offset_of;
 use eepy_gui::element::button::Button;
 use embedded_graphics::prelude::*;
 use embedded_graphics::text::Text;
 use eepy_gui::draw_target::EpdDrawTarget;
 use eepy_gui::element::{Gui, DEFAULT_TEXT_STYLE};
-use eepy_sys::flash;
-use eepy_sys::header::{slot, slot_ptr, ProgramSlotHeader};
+use eepy_sys::header::slot;
 use eepy_sys::input_common::Event;
+use crate::delete_program;
 use crate::ui::MainGui;
 use crate::ui::page::main::MainPage;
 
···
     }
 
     fn tick(&mut self, target: &mut EpdDrawTarget, ev: Event) -> Self::Output {
+        let mut refresh = false;
+
         let b = self.back_button.tick(target, ev);
         if b.clicked {
             return Some(MainGui::MainPage(MainPage::new()));
         }
+        refresh |= b.needs_refresh;
 
         let d = self.delete_button.tick(target, ev);
         if d.clicked {
-            let ptr = unsafe { slot_ptr(self.slot) };
-            let mut buf = [0u8; 256];
-            unsafe { buf.copy_from_slice(core::slice::from_raw_parts(ptr, 256)) };
-            let offset = offset_of!(ProgramSlotHeader, len);
-            buf[offset..offset + 4].copy_from_slice(&[0; 4]);
-
-            unsafe { flash::program(self.slot as u32 * 512 * 1024, &buf) };
+            unsafe { delete_program(self.slot) };
             return Some(MainGui::MainPage(MainPage::new()));
+        }
+        refresh |= d.needs_refresh;
+
+        if refresh {
+            target.refresh(true);
         }
 
         None

eepy-launcher/src/ui/page/main.rs

···
 }
 
 impl MainPage {
+    fn app_button(x: usize, y: usize, label: &'static str) -> Button<'static> {
+        let x_coord = 10 + 115 * x as i32;
+        let y_coord = 8 + 25 * y as i32;
+        Button::with_default_style(
+            Rectangle::new(Point::new(x_coord, y_coord), Size::new(105, 20)),
+            label,
+            false,
+        )
+    }
+
     pub(crate) fn refresh_buttons(&mut self) {
         let mut programs = Programs::new();
 
         for y in 0..16 {
             for x in 0..2 {
+                // Reserve the first space for the scratchpad
+                if x == 0 && y == 0 {
+                    continue;
+                }
+
                 if let Some(prog) = programs.next() {
                     let bi = y * 2 + x;
-                    let x_coord = if x == 0 { 10 } else { 125 };
-                    let y_coord = 35 + 23 * y as i32;
-                    let button = Button::with_default_style(
-                        Rectangle::new(Point::new(x_coord, y_coord), Size::new(105, 20)),
-                        unsafe { (*prog).name().unwrap() },
-                        false,
-                    );
+                    let button = Self::app_button(x, y, unsafe { (*prog).name().unwrap_or("<invalid>") });
                     let slot_num = unsafe { (&*prog).slot() };
                     self.app_buttons[bi] = Some((button, slot_num))
                 }
···
 
     pub(crate) fn new() -> Self {
         let mut res = Self {
-            scratchpad_button: Button::with_default_style_auto_sized(Point::new(10, 10), "Scratchpad", true),
+            scratchpad_button: Button::with_default_style(
+                Rectangle::new(Point::new(10, 8), Size::new(105, 20)),
+                "Scratchpad",
+                true
+            ),
             app_buttons: [const { None }; 32],
         };
         res.refresh_buttons();
···
             draw_target.refresh(true);
         }
 
-        for b in &mut self.app_buttons {
+        for b in &mut self.app_buttons[1..] {
             if let Some((button, s)) = b {
                 let response = button.tick(draw_target, ev);
 

eepy-sys/src/header.rs

···
             return false;
         }
 
-        if self.name().is_err() {
+        if unsafe { self.name() }.is_err() {
             #[cfg(feature = "defmt")]
             warn!("Program name is not valid UTF-8");
             return false;
         }
 
-        if self.version().is_err() {
+        if unsafe { self.version() }.is_err() {
             #[cfg(feature = "defmt")]
             warn!("Program version string is not valid UTF-8");
             return false;
···
         crc == self.crc
     }
 
-    pub fn name(&self) -> Result<&str, Utf8Error> {
+    pub unsafe fn name(&self) -> Result<&str, Utf8Error> {
         unsafe {
             core::str::from_utf8(core::slice::from_raw_parts(self.name_ptr, self.name_len))
         }
     }
 
-    pub fn version(&self) -> Result<&str, Utf8Error> {
+    pub unsafe fn version(&self) -> Result<&str, Utf8Error> {
         unsafe {
             core::str::from_utf8(core::slice::from_raw_parts(self.version_ptr, self.version_len))
         }