Improved file manager

Author: Andrew Whaley

.github/workflows/release.yml

@@ -23,13 +23,31 @@ jobs:
       - name: Install cargo-espflash
         run: cargo install cargo-espflash --locked
 
-      - name: Build firmware image (app)
+      - name: Cache ESP-IDF
+        uses: actions/cache@v4
+        with:
+          path: |
+            ~/.espressif
+            ~/esp/esp-idf
+          key: esp-idf-v5.5.2-${{ runner.os }}
+
+      - name: Install ESP-IDF Toolchain
         run: |
+          sudo apt-get update
+          sudo apt-get install -y git python3 python3-venv python3-pip cmake ninja-build
+          mkdir -p $HOME/esp
+          if [ ! -d "$HOME/esp/esp-idf/.git" ]; then
+            git clone --depth 1 -b v5.5.2 https://github.com/espressif/esp-idf.git $HOME/esp/esp-idf
+          fi
+          if [ ! -d "$HOME/.espressif" ]; then
+            $HOME/esp/esp-idf/install.sh esp32c3
+          fi
+
+      - name: Build firmware image (app + full)
+        run: |
+          source $HOME/esp/esp-idf/export.sh
           cargo espflash save-image --release --chip=esp32c3 --target=riscv32imc-unknown-none-elf --package=tern-x4 firmware.bin
           cp firmware.bin tern-fw-${GITHUB_REF_NAME}.bin
-
-      - name: Build firmware image (full)
-        run: |
           cargo espflash save-image --merge --release --chip=esp32c3 --target=riscv32imc-unknown-none-elf --package=tern-x4 ternfull-${GITHUB_REF_NAME}.bin
 
       - name: Upload firmware artifact (app)

core/src/app/home.rs

@@ -19,10 +19,10 @@ use crate::ui::{flush_queue, ListItem, ListView, Rect, RenderQueue, UiContext, V
 const START_MENU_MARGIN: i32 = 16;
 const START_MENU_RECENT_THUMB: i32 = 74;
 const START_MENU_ACTION_GAP: i32 = 12;
-const HEADER_Y: i32 = 24;
-const LIST_TOP: i32 = 60;
-const LINE_HEIGHT: i32 = 24;
-const LIST_MARGIN_X: i32 = 16;
+const HEADER_Y: i32 = 28;
+const LIST_TOP: i32 = 72;
+const LINE_HEIGHT: i32 = 30;
+const LIST_MARGIN_X: i32 = 18;
 
 #[derive(Clone, Copy, Debug, PartialEq, Eq)]
 pub enum StartMenuSection {
@@ -143,9 +143,9 @@ impl HomeState {
 
     pub fn menu_title(&self) -> String {
         if self.path.is_empty() {
-            "Images".to_string()
+            "/".to_string()
         } else {
-            let mut title = String::from("Images/");
+            let mut title = String::from("/");
             title.push_str(&self.path.join("/"));
             title
         }
@@ -575,7 +575,7 @@ impl HomeState {
         let mut list = ListView::new(&items);
         list.title = Some(title.as_str());
         list.footer = Some("Up/Down: select  Confirm: open  Back: up");
-        list.empty_label = Some("No entries found in /images");
+        list.empty_label = Some("No files found.");
         list.selected = self.selected;
         list.margin_x = LIST_MARGIN_X;
         list.header_y = HEADER_Y;

core/src/application.rs

@@ -432,7 +432,7 @@ impl<'a, S: AppSource> Application<'a, S> {
         let action = match self.home.open_selected() {
             Ok(action) => action,
             Err(HomeOpenError::Empty) => {
-                self.error_message = Some("No entries found in /images.".into());
+                self.error_message = Some("No entries found.".into());
                 self.state = AppState::Error;
                 self.dirty = true;
                 return;
@@ -547,7 +547,7 @@ impl<'a, S: AppSource> Application<'a, S> {
 
     fn set_error(&mut self, err: ImageError) {
         let message = match err {
-            ImageError::Io => "I/O error while accessing /images.".into(),
+            ImageError::Io => "I/O error while accessing storage.".into(),
             ImageError::Decode => "Failed to decode image.".into(),
             ImageError::Unsupported => "Unsupported image format.".into(),
             ImageError::Message(message) => message,

x4/fatfs/ffconf.h

@@ -113,8 +113,8 @@
 */
 
 
-#define FF_USE_LFN		0
-#define FF_MAX_LFN		64
+#define FF_USE_LFN		1
+#define FF_MAX_LFN		255
 /* The FF_USE_LFN switches the support for LFN (long file name).
 /
 /   0: Disable LFN. FF_MAX_LFN has no effect.
@@ -133,7 +133,7 @@
 /  ff_memfree() exemplified in ffsystem.c, need to be added to the project. */
 
 
-#define FF_LFN_UNICODE	0
+#define FF_LFN_UNICODE	2
 /* This option switches the character encoding on the API when LFN is enabled.
 /
 /   0: ANSI/OEM in current CP (TCHAR = char)

x4/src/image_source.rs

@@ -46,6 +46,7 @@ pub trait UsbStorage {
         self.usb_write(path, offset, data)
     }
     fn usb_delete(&mut self, path: &str) -> Result<(), ImageError>;
+    fn usb_rmdir(&mut self, path: &str) -> Result<(), ImageError>;
     fn usb_rename(&mut self, from: &str, to: &str) -> Result<(), ImageError>;
     fn usb_mkdir(&mut self, path: &str) -> Result<(), ImageError>;
 }
@@ -70,6 +71,13 @@ impl<F> SdImageSource<F>
 where
     F: Filesystem + 'static,
 {
+    fn join_usb_path(dir: &str, name: &str) -> String {
+        if dir.is_empty() || dir == "/" {
+            return format!("/{}", name);
+        }
+        format!("{}/{}", dir.trim_end_matches('/'), name)
+    }
+
     fn build_path(path: &[String], name: &str) -> String {
         if path.is_empty() {
             return name.to_string();
@@ -253,8 +261,10 @@ where
     for<'a> F::File<'a>: 'static,
 {
     fn usb_list(&mut self, path: &str) -> Result<Vec<UsbDirEntry>, ImageError> {
-        let dir = self.fs.open_directory(path).map_err(|_| ImageError::Io)?;
-        let listed = dir.list().map_err(|_| ImageError::Io)?;
+        let listed = {
+            let dir = self.fs.open_directory(path).map_err(|_| ImageError::Io)?;
+            dir.list().map_err(|_| ImageError::Io)?
+        };
         let mut out = Vec::new();
         for entry in listed {
             out.push(UsbDirEntry {
@@ -361,6 +371,12 @@ where
         Ok(())
     }
 
+    fn usb_rmdir(&mut self, path: &str) -> Result<(), ImageError> {
+        self.usb_delete_dir_recursive(path)?;
+        self.fs.delete_file(path).map_err(|_| ImageError::Io)?;
+        Ok(())
+    }
+
     fn usb_rename(&mut self, from: &str, to: &str) -> Result<(), ImageError> {
         self.fs.rename_file(from, to).map_err(|_| ImageError::Io)
     }
@@ -428,6 +444,34 @@ where
             .fs
             .delete_file(&format!("{}/{}", cache_legacy, title));
     }
+
+    fn usb_delete_dir_recursive(&mut self, path: &str) -> Result<(), ImageError>
+    where
+        F: UsbFsOps,
+    {
+        let listed = {
+            let dir = self.fs.open_directory(path).map_err(|_| ImageError::Io)?;
+            dir.list().map_err(|_| ImageError::Io)?
+        };
+        let entries: Vec<(String, bool)> = listed
+            .into_iter()
+            .map(|entry| (entry.name().to_string(), entry.is_directory()))
+            .collect();
+        for (name, is_dir) in entries {
+            if name == "." || name == ".." {
+                continue;
+            }
+            let full_path = Self::join_usb_path(path, &name);
+            if is_dir {
+                self.usb_delete_dir_recursive(&full_path)?;
+                let _ = self.fs.delete_file(&full_path);
+            } else {
+                let _ = self.fs.delete_file(&full_path);
+                self.cleanup_deleted_path_with_usb(&full_path);
+            }
+        }
+        Ok(())
+    }
 }
 
 fn read_exact<R: Read + ?Sized>(reader: &mut R, mut buf: &mut [u8]) -> Result<(), ImageError> {
@@ -640,18 +684,27 @@ where
         for entry in listed {
             let name = entry.name().to_string();
             let short = entry.short_name().to_string();
+            let upper = name.to_ascii_uppercase();
+            let short_upper = short.to_ascii_uppercase();
+            let short_is_hidden = short.starts_with('.');
             if !name.is_empty() {
                 self.short_names.push((name.clone(), short));
             }
             if name.is_empty()
-                || name == Self::resume_filename()
-                || name == Self::resume_filename_legacy()
-                || name == Self::book_positions_filename()
-                || name == Self::book_positions_filename_legacy()
-                || name == Self::recent_entries_filename()
-                || name == Self::recent_entries_filename_legacy()
-                || name == Self::thumbnails_dirname()
-                || name == Self::thumbnails_dirname_legacy()
+                || name.starts_with('.')
+                || short_is_hidden
+                || upper == Self::resume_filename()
+                || upper == Self::resume_filename_legacy().to_ascii_uppercase()
+                || upper == Self::book_positions_filename()
+                || upper == Self::book_positions_filename_legacy().to_ascii_uppercase()
+                || upper == Self::recent_entries_filename()
+                || upper == Self::recent_entries_filename_legacy().to_ascii_uppercase()
+                || upper == Self::thumbnails_dirname()
+                || upper == Self::thumbnails_dirname_legacy().to_ascii_uppercase()
+                || short_upper == Self::resume_filename()
+                || short_upper == Self::book_positions_filename()
+                || short_upper == Self::recent_entries_filename()
+                || short_upper == Self::thumbnails_dirname()
             {
                 continue;
             }

x4/src/sdspi_fatfs.rs

@@ -343,12 +343,12 @@ impl FatFs {
     }
 }
 
-fn null_terminate(path: &str) -> [u8; 256] {
+fn null_terminate(path: &str) -> [u8; 512] {
     assert!(
-        path.len() < 256,
+        path.len() < 512,
         "Path too long for static null-terminated buffer"
     );
-    let mut null_terminated_path = [0u8; 256];
+    let mut null_terminated_path = [0u8; 512];
     null_terminated_path[..path.len()].copy_from_slice(path.as_bytes());
     null_terminated_path
 }

x4/src/usb_mode.rs

@@ -695,9 +695,25 @@ pub async fn poll<S: UsbStorage>(
                 }
             }
             x if x == Command::Rmdir as u8 => {
-                usb.last_err = Some(ErrorCode::NotPermitted);
-                let response = encode_error(frame.req_id, cmd, ErrorCode::NotPermitted, "rmdir not supported");
-                let _ = Write::write_all(tx, &response).await;
+                let mut cursor = 0usize;
+                let Some(path) = read_path(&frame.payload, &mut cursor) else {
+                    usb.last_err = Some(ErrorCode::InvalidArgs);
+                    let response = encode_error(frame.req_id, cmd, ErrorCode::InvalidArgs, "bad path");
+                    let _ = Write::write_all(tx, &response).await;
+                    continue;
+                };
+                match storage.usb_rmdir(&path) {
+                    Ok(()) => {
+                        usb.last_err = None;
+                        let response = encode_ok(frame.req_id, cmd, &[]);
+                        let _ = Write::write_all(tx, &response).await;
+                    }
+                    Err(err) => {
+                        usb.last_err = Some(ErrorCode::Io);
+                        let response = encode_error_for(frame.req_id, cmd, ErrorCode::Io, err, "rmdir failed");
+                        let _ = Write::write_all(tx, &response).await;
+                    }
+                }
             }
             x if x == Command::Rename as u8 => {
                 let mut cursor = 0usize;