From aa8c0e5792296d09fee73a909a3f0738df819f45 Mon Sep 17 00:00:00 2001 From: bunnie Date: Thu, 4 Mar 2021 16:02:42 +0800 Subject: [PATCH] a bit more deck shuffling on the APIs feels a lot cleaner now. --- Cargo.lock | 1 + services/gam/src/main.rs | 3 + services/ime-frontend/src/lib.rs | 13 +++ services/ime-frontend/src/main.rs | 75 +++++++-------- services/ime-plugin-api/Cargo.toml | 1 + services/ime-plugin-api/src/lib.rs | 133 +++++++++++++++----------- services/ime-plugin-shell/src/lib.rs | 8 +- services/ime-plugin-shell/src/main.rs | 7 +- 8 files changed, 136 insertions(+), 105 deletions(-) diff --git a/Cargo.lock b/Cargo.lock index c18a2cc3f..156595a97 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -547,6 +547,7 @@ dependencies = [ name = "ime-plugin-api" version = "0.1.0" dependencies = [ + "log", "rkyv", "xous", ] diff --git a/services/gam/src/main.rs b/services/gam/src/main.rs index 49953fcce..15fea1b34 100644 --- a/services/gam/src/main.rs +++ b/services/gam/src/main.rs @@ -141,6 +141,9 @@ fn xmain() -> ! { ime_frontend::set_input_canvas(imef_conn, chatlayout.input).expect("GAM: couldn't set IMEF input canvas"); ime_frontend::set_prediction_canvas(imef_conn, chatlayout.predictive).expect("GAM: couldn't set IMEF prediction canvas"); + // ASSUME: shell is our default application, so set a default predictor of Shell + ime_frontend::set_predictor(imef_conn, xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("GAM: couldn't set IMEF prediction to shell"); + let mut last_time: u64 = ticktimer_server::elapsed_ms(ticktimer_conn).unwrap(); info!("GAM: entering main loop"); loop { diff --git a/services/ime-frontend/src/lib.rs b/services/ime-frontend/src/lib.rs index 8f3c9e5c2..95f187810 100644 --- a/services/ime-frontend/src/lib.rs +++ b/services/ime-frontend/src/lib.rs @@ -12,3 +12,16 @@ pub fn set_prediction_canvas(cid: CID, g: graphics_server::Gid) -> Result<(), xo send_message(cid, api::Opcode::SetPredictionCanvas(g).into())?; Ok(()) } + +pub fn set_predictor(cid: CID, servername: &str) -> Result<(), xous::Error> { + let mut server = xous::String::<256>::new(); + use core::fmt::Write; + write!(server, "{}", servername).expect("IMEF: couldn't write set_predictor server name"); + let ime_op = api::Opcode::SetPredictionServer(server); + + use rkyv::Write as ArchiveWrite; + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&ime_op).expect("IMEF: couldn't archive SetPredictionServer"); + writer.into_inner().lend(cid, pos as u32).expect("IMEF: SetPredicitonServer request failure"); + Ok(()) +} \ No newline at end of file diff --git a/services/ime-frontend/src/main.rs b/services/ime-frontend/src/main.rs index 9ec185583..b29665f82 100644 --- a/services/ime-frontend/src/main.rs +++ b/services/ime-frontend/src/main.rs @@ -8,11 +8,11 @@ use core::convert::TryFrom; use log::{error, info}; -use graphics_server::Gid; +use graphics_server::{Gid, TextView}; use heapless::Vec; use heapless::consts::U32; use core::pin::Pin; -use ime_plugin_api::{PredictionTriggers, PredictionApi}; +use ime_plugin_api::{PredictionTriggers, PredictionPlugin, PredictionApi}; use rkyv::Unarchive; use rkyv::archived_value; @@ -20,14 +20,17 @@ use rkyv::archived_value; struct InputTracker { /// connection for handling graphical update requests pub gam_conn: xous::CID, + + /// input area canvas, as given by the GAM - pub input_canvas: Option, - /// a connection to our current prediction engine - pub pred_conn: xous::CID, + input_canvas: Option, /// prediction display area, as given by the GAM - pub pred_canvas: Option, - /// triggers for predictions - pub pred_triggers: PredictionTriggers, + pred_canvas: Option, + + /// our current prediction engine + predictor: Option, + /// cached copy of the predictor's triggers for predictions. Only valid if predictor is not None + pred_triggers: Option, /// track the progress of our input line line: xous::String::<4096>, @@ -35,45 +38,44 @@ struct InputTracker { charwidths: [u8; 4096], /// what position the insertion cursor is at in the string. 0 is inserting elements into the front of the string insertion: u8, + + predictions: [Option; 4], } -impl InputTracker { - pub fn new(gam_conn: xous::CID, pred_conn: xous::CID, predictor: impl PredictionApi)-> InputTracker { - // a little dangerous: bypassing any explicit API call implementation for this one - /* - let response = xous::send_message(pred_conn, ime_plugin_api::Opcode::GetPredictionTriggers.into()) - .expect("IMEF: InputTracker failed to get predictions from default plugin"); - if let xous::Result::Scalar1(code) = response { - InputTracker { - gam_conn, - input_canvas: None, - pred_conn, - pred_canvas: None, - pred_triggers: code.into(), - line: xous::String::<4096>::new(), - charwidths: [0; 4096], - insertion: 0, - } - } else { - panic!("IMEF: InputTracker::new() failed to get prediction triggers") - }*/ - let pred_triggers = predictor.get_prediction_triggers(pred_conn) - .expect("IMEF: InputTracker failed to get predictions from default plugin"); +impl InputTracker { + pub fn new(gam_conn: xous::CID)-> InputTracker { InputTracker { gam_conn, input_canvas: None, - pred_conn, pred_canvas: None, - pred_triggers, + predictor: None, + pred_triggers: None, line: xous::String::<4096>::new(), charwidths: [0; 4096], insertion: 0, + predictions: [None; 4], } } + pub fn set_predictor(&mut self, predictor: PredictionPlugin) { + self.predictor = Some(predictor); + self.pred_triggers = Some(predictor.get_prediction_triggers() + .expect("IMEF: InputTracker failed to get prediction triggers from plugin")); + } + pub fn set_input_canvas(&mut self, input: Gid) { + self.input_canvas = Some(input); + } + pub fn set_pred_canvas(&mut self, pred: Gid) { + self.pred_canvas = Some(pred); + } + pub fn is_init(&self) -> bool { + self.input_canvas.is_some() && self.pred_canvas.is_some() + } pub fn update(&mut self, newkeys: [char; 4]) { + // just draw a rectangle for the prediction area for now + /* what else do we need: - current string that is being built up @@ -102,14 +104,9 @@ fn xmain() -> ! { let kbd_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_KBD).expect("IMEF: can't connect to KBD"); keyboard::request_events(xous::names::SERVER_NAME_IME_FRONT, kbd_conn).expect("IMEF: couldn't request events from keyboard"); - let default_predictor = ime_plugin_api::StandardPredictionPlugin {}; let mut tracker = InputTracker::new( xous_names::request_connection_blocking(xous::names::SERVER_NAME_GAM).expect("IMEF: can't connect to GAM"), - // set a "default" prediction that is a shell-like history buffer of things previously typed - xous_names::request_connection_blocking(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("IMEF: can't connect to shell prediction engine"), - default_predictor ); - // The first message should be my Gid from the GAM. info!("IMEF: waiting for my canvas Gids"); loop { @@ -129,7 +126,7 @@ fn xmain() -> ! { } else { info!("IMEF: expected canvas Gid, but got other message first {:?}", envelope); } - if tracker.input_canvas.is_some() && tracker.pred_canvas.is_some() { + if tracker.is_init() { break; } } @@ -163,7 +160,7 @@ fn xmain() -> ! { rkyv::Archived::::SetPredictionServer(rkyv_s) => { let s: xous::String<256> = rkyv_s.unarchive(); match xous_names::request_connection(s.as_str().expect("IMEF: SetPrediction received malformed server name")) { - Ok(pc) => tracker.pred_conn = pc, + Ok(pc) => tracker.set_predictor(ime_plugin_api::PredictionPlugin {connection: Some(pc)}), _ => error!("IMEF: can't find predictive engine {}, retaining existing one.", s.as_str().expect("IMEF: SetPrediction received malformed server name")), } }, diff --git a/services/ime-plugin-api/Cargo.toml b/services/ime-plugin-api/Cargo.toml index 72db13a76..90c0daf78 100644 --- a/services/ime-plugin-api/Cargo.toml +++ b/services/ime-plugin-api/Cargo.toml @@ -8,4 +8,5 @@ description = "IME Plugin Common APIs" [dependencies] xous = { path = "../../xous-rs" } rkyv = { version = "0.3.1", default_features = false } +log = "0.4" diff --git a/services/ime-plugin-api/src/lib.rs b/services/ime-plugin-api/src/lib.rs index 3c6c04619..b9fe2bea3 100644 --- a/services/ime-plugin-api/src/lib.rs +++ b/services/ime-plugin-api/src/lib.rs @@ -90,80 +90,105 @@ impl Into for Opcode { } } +pub trait PredictionApi { + fn get_prediction_triggers(&self) -> Result; + fn unpick(&self) -> Result<(), xous::Error>; + fn set_input(&self, s: String<4096>) -> Result<(), xous::Error>; + fn feedback_picked(&self, s: String<4096>) -> Result<(), xous::Error>; + fn get_prediction(&self, index: u32) -> Result, xous::Error>; +} + // provide a convenience version of the API for generic/standard calls #[derive(Debug, Default, Copy, Clone)] -pub struct StandardPredictionPlugin {} -impl PredictionApi for StandardPredictionPlugin {} +pub struct PredictionPlugin { + pub connection: Option, +} -// it's pretty dangerous to not use the default version of the API, because this is an IPC barrier -// and Rust can't check arguments and correctness between separate programs. -// In other words, you should really think twice before overriding these. -pub trait PredictionApi { - fn get_prediction_triggers(&self, cid: CID) -> Result { - let response = xous::send_message(cid, Opcode::GetPredictionTriggers.into())?; - if let xous::Result::Scalar1(code) = response { - Ok(code.into()) - } else { - panic!("get_prediciton_triggers failed") +impl PredictionApi for PredictionPlugin { + fn get_prediction_triggers(&self) -> Result { + match self.connection { + Some(cid) => { + let response = xous::send_message(cid, Opcode::GetPredictionTriggers.into())?; + if let xous::Result::Scalar1(code) = response { + Ok(code.into()) + } else { + Err(xous::Error::InternalError) + } + }, + _ => Err(xous::Error::UseBeforeInit), } } - fn unpick(&self, cid: CID) -> Result<(), xous::Error> { - xous::send_message(cid, Opcode::Unpick.into())?; - Ok(()) + fn unpick(&self) -> Result<(), xous::Error> { + match self.connection { + Some(cid) => { + xous::send_message(cid, Opcode::Unpick.into())?; + Ok(()) + }, + _ => Err(xous::Error::UseBeforeInit) + } } - fn set_input(&self, cid: CID, s: String<4096>) -> Result<(), xous::Error> { + fn set_input(&self, s: String<4096>) -> Result<(), xous::Error> { use rkyv::Write; + match self.connection { + Some(cid) => { + let rkyv_input = Opcode::Input(s); + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&rkyv_input).expect("IME|API: couldn't archive input string"); + let xous_buffer = writer.into_inner(); - let rkyv_input = Opcode::Input(s); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_input).expect("IMES|API: couldn't archive input string"); - let xous_buffer = writer.into_inner(); - - xous_buffer.lend(cid, pos as u32).expect("IMES|API: set_input operation failure"); - - Ok(()) + xous_buffer.lend(cid, pos as u32).expect("IME|API: set_input operation failure"); + Ok(()) + }, + _ => Err(xous::Error::UseBeforeInit), + } } - fn feedback_picked(&self, cid: CID, s: String<4096>) -> Result<(), xous::Error> { + fn feedback_picked(&self, s: String<4096>) -> Result<(), xous::Error> { use rkyv::Write; + match self.connection { + Some(cid) => { + let rkyv_picked = Opcode::Picked(s); + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&rkyv_picked).expect("IME|API: couldn't archive picked string"); + let xous_buffer = writer.into_inner(); - let rkyv_picked = Opcode::Picked(s); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&rkyv_picked).expect("IMES|API: couldn't archive picked string"); - let xous_buffer = writer.into_inner(); - - xous_buffer.lend(cid, pos as u32).expect("IMES|API: feedback_picked operation failure"); - - Ok(()) + xous_buffer.lend(cid, pos as u32).expect("IME|API: feedback_picked operation failure"); + Ok(()) + }, + _ => Err(xous::Error::UseBeforeInit), + } } - fn get_prediction(&self, cid: CID, index: u32) -> Result, xous::Error> { + fn get_prediction(&self, index: u32) -> Result, xous::Error> { use rkyv::Write; use rkyv::Unarchive; + match self.connection { + Some(cid) => { + let prediction = Prediction { + index, + string: xous::String::<4096>::new(), + }; + let pred_op = Opcode::Prediction(prediction); + let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); + let pos = writer.archive(&pred_op).expect("IME|API: couldn't archive prediction request"); + let mut xous_buffer = writer.into_inner(); - let prediction = Prediction { - index, - string: xous::String::<4096>::new(), - }; - let pred_op = Opcode::Prediction(prediction); + xous_buffer.lend_mut(cid, pos as u32).expect("IME|API: prediction fetch operation failure"); - let mut writer = rkyv::ArchiveBuffer::new(xous::XousBuffer::new(4096)); - let pos = writer.archive(&pred_op).expect("IMES|API: couldn't archive prediction request"); - let mut xous_buffer = writer.into_inner(); - - xous_buffer.lend_mut(cid, pos as u32).expect("IMES|API: prediction fetch operation failure"); - - let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; - if let rkyv::Archived::::Prediction(result) = returned { - let pred_r: Prediction = result.unarchive(); - - let retstring: xous::String<4096> = pred_r.string.clone(); - Ok(retstring) - } else { - let r = returned.unarchive(); - Err(xous::Error::InvalidString) + let returned = unsafe { rkyv::archived_value::(xous_buffer.as_ref(), pos)}; + if let rkyv::Archived::::Prediction(result) = returned { + let pred_r: Prediction = result.unarchive(); + let retstring: xous::String<4096> = pred_r.string.clone(); + Ok(retstring) + } else { + let r = returned.unarchive(); + log::error!("IME:API get_prediction returned an invalid result {:?}", r); + Err(xous::Error::InvalidString) + } + }, + _ => Err(xous::Error::UseBeforeInit), } } } diff --git a/services/ime-plugin-shell/src/lib.rs b/services/ime-plugin-shell/src/lib.rs index 2bbd1a844..6de96d98a 100644 --- a/services/ime-plugin-shell/src/lib.rs +++ b/services/ime-plugin-shell/src/lib.rs @@ -1,10 +1,4 @@ #![cfg_attr(target_os = "none", no_std)] +// just inherit all the default from the ime_plugin_api pub use ime_plugin_api::*; - -pub struct PredictionApiImpl { -} - -impl PredictionApi for PredictionApiImpl { - // inherit all the default methods -} \ No newline at end of file diff --git a/services/ime-plugin-shell/src/main.rs b/services/ime-plugin-shell/src/main.rs index 4c7166055..af29fe9d9 100644 --- a/services/ime-plugin-shell/src/main.rs +++ b/services/ime-plugin-shell/src/main.rs @@ -19,11 +19,7 @@ fn xmain() -> ! { info!("IME_SH: my PID is {}", xous::process::id()); let ime_sh_sid = xous_names::register_name(xous::names::SERVER_NAME_IME_PLUGIN_SHELL).expect("IME_SH: can't register server"); - info!("IME_SH: registered with NS -- {:?}", ime_sh_sid); - - let imef_conn = xous_names::request_connection_blocking(xous::names::SERVER_NAME_IME_FRONT).expect("IME_SH: can't connect to IMEF"); - - info!("IME_SH: ready to accept requests"); + if debug1{info!("IME_SH: registered with NS -- {:?}", ime_sh_sid);} let mut history: Queue, U3> = Queue::new(); // this has 2^3 elements = 8 let history_max = 8; @@ -34,6 +30,7 @@ fn xmain() -> ! { trigger_whitespace: false, }; + info!("IME_SH: ready to accept requests"); loop { let envelope = xous::receive_message(ime_sh_sid).unwrap(); if debug1{info!("IME_SH: received message {:?}", envelope);}