improv: Display message when firmware doesn't support keymap API

Systems without Open EC firmware won't be detected at all, and this
doesn't change that.

Author: ids1024

backend/src/board.rs

@@ -16,6 +16,7 @@ pub struct BoardInner {
     thread_client: DerefCell<Arc<ThreadClient>>,
     board: DerefCell<BoardId>,
     model: DerefCell<String>,
+    version: DerefCell<String>,
     layout: DerefCell<Layout>,
     keys: DerefCell<Vec<Key>>,
     layers: DerefCell<Vec<Layer>>,
@@ -25,6 +26,7 @@ pub struct BoardInner {
     led_save_blocked: Cell<bool>,
     has_matrix: DerefCell<bool>,
     is_fake: DerefCell<bool>,
+    has_keymap: DerefCell<bool>,
 }
 
 #[glib::object_subclass]
@@ -66,6 +68,10 @@ impl Board {
                 return Err(format!("Failed to get board model: {}", err));
             }
         };
+        let version = daemon.version(board).unwrap_or_else(|err| {
+            error!("Error getting firmware version: {}", err);
+            String::new()
+        });
         let layout = Layout::from_board(&model)
             .ok_or_else(|| format!("Failed to locate layout for '{}'", model))?;
 
@@ -82,16 +88,20 @@ impl Board {
 
         let has_led_save = daemon.led_save(board).is_ok();
         let has_matrix = daemon.matrix_get(board).is_ok();
+        let logical = layout.layout.values().next().unwrap();
+        let has_keymap = daemon.keymap_get(board, 0, logical.0, logical.1).is_ok();
 
         let self_ = glib::Object::new::<Board>(&[]).unwrap();
         self_.inner().thread_client.set(thread_client);
         self_.inner().board.set(board);
         self_.inner().model.set(model);
+        self_.inner().version.set(version);
         self_.inner().layout.set(layout);
         self_.inner().max_brightness.set(max_brightness);
         self_.inner().has_led_save.set(has_led_save);
         self_.inner().has_matrix.set(has_matrix);
         self_.inner().is_fake.set(daemon.is_fake());
+        self_.inner().has_keymap.set(has_keymap);
 
         let keys = self_
             .layout()
@@ -162,6 +172,10 @@ impl Board {
         &self.inner().model
     }
 
+    pub fn version(&self) -> &str {
+        &self.inner().version
+    }
+
     pub fn has_matrix(&self) -> bool {
         *self.inner().has_matrix
     }
@@ -206,6 +220,10 @@ impl Board {
         *self.inner().has_led_save
     }
 
+    pub fn has_keymap(&self) -> bool {
+        *self.inner().has_keymap
+    }
+
     pub fn layout(&self) -> &Layout {
         &*self.inner().layout
     }

backend/src/daemon/dummy.rs

@@ -67,6 +67,10 @@ impl Daemon for DaemonDummy {
         Ok(self.board(board)?.name.clone())
     }
 
+    fn version(&self, _board: BoardId) -> Result<String, String> {
+        Ok("1970-01-01-deadbee".to_string())
+    }
+
     fn is_fake(&self) -> bool {
         true
     }

backend/src/daemon/mod.rs

@@ -110,6 +110,7 @@ macro_rules! commands {
 commands! {
     fn boards(&self) -> Result<Vec<BoardId>, String>;
     fn model(&self, board: BoardId) -> Result<String, String>;
+    fn version(&self, board: BoardId) -> Result<String, String>;
     fn refresh(&self) -> Result<(), String>;
     fn keymap_get(&self, board: BoardId, layer: u8, output: u8, input: u8) -> Result<u16, String>;
     fn keymap_set(&self, board: BoardId, layer: u8, output: u8, input: u8, value: u16) -> Result<(), String>;

backend/src/daemon/s76power.rs

@@ -85,6 +85,10 @@ impl Daemon for DaemonS76Power {
         Ok("system76/darp6".to_string())
     }
 
+    fn version(&self, _board: BoardId) -> Result<String, String> {
+        Err("Unimplemented".to_string())
+    }
+
     fn keymap_get(
         &self,
         _board: BoardId,

backend/src/daemon/server.rs

@@ -129,6 +129,15 @@ impl<R: Read + Send + 'static, W: Write + Send + 'static> Daemon for DaemonServe
         Ok(board.to_string())
     }
 
+    fn version(&self, board: BoardId) -> Result<String, String> {
+        let mut ec = self.board(board)?;
+        let data_size = unsafe { ec.access().data_size() };
+        let mut data = vec![0; data_size];
+        let len = unsafe { ec.version(&mut data).map_err(err_str)? };
+        let version = str::from_utf8(&data[..len]).map_err(err_str)?;
+        Ok(version.to_string())
+    }
+
     fn keymap_get(&self, board: BoardId, layer: u8, output: u8, input: u8) -> Result<u16, String> {
         let mut ec = self.board(board)?;
         unsafe { ec.keymap_get(layer, output, input).map_err(err_str) }

i18n/en/system76_keyboard_configurator.ftl

@@ -26,6 +26,8 @@ error-set-layer-mode = Failed to set layer mode
 error-unsupported-keymap = Unsupported keymap file
 error-unsupported-keymap-desc = Keymap file appears to be from newer Configurator version.
 
+firmware-version = Firmware version {$version} does not support keymap configuration.
+
 keyboard-brightness = Brightness:
 keyboard-color = Color:
 

src/main_window.rs

@@ -289,7 +289,7 @@ impl MainWindow {
         let app: ConfiguratorApp = self.get_application().unwrap().downcast().unwrap();
 
         let keyboard = cascade! {
-            Keyboard::new(board, app.debug_layers(), app.launch_test());
+            Keyboard::new(board.clone(), app.debug_layers(), app.launch_test());
             ..set_halign(gtk::Align::Center);
             ..show_all();
         };
@@ -330,6 +330,19 @@ impl MainWindow {
         };
         self.inner().keyboard_box.add(&row);
 
+        if !board.has_keymap() {
+            button.hide();
+            let label = cascade! {
+                gtk::Label::new(Some(&fl!("firmware-version", version = board.version())));
+                ..set_attributes(Some(&cascade! {
+                    pango::AttrList::new();
+                    ..insert(pango::Attribute::new_foreground(65535, 0, 0));
+                }));
+                ..show();
+            };
+            keyboard_box.add(&label);
+        }
+
         self.inner().stack.add(&keyboard);
         self.inner().keyboards.borrow_mut().push((keyboard, row));