diff --git a/Cargo.lock b/Cargo.lock index 13dad3927..33aa60674 100644 --- a/Cargo.lock +++ b/Cargo.lock @@ -2240,10 +2240,11 @@ dependencies = [ [[package]] name = "mtxcli" -version = "0.6.0" +version = "0.7.0" dependencies = [ "codec", "com", + "com_rs-ref", "content-plugin-api", "gam", "graphics-server", @@ -2252,11 +2253,13 @@ dependencies = [ "llio", "locales", "log", + "net", "num-derive", "num-traits", "pddb", "percent-encoding", "serde", + "status", "trng", "ureq", "xous 0.9.31 (registry+https://github.com/rust-lang/crates.io-index)", diff --git a/apps/mtxcli/Cargo.toml b/apps/mtxcli/Cargo.toml index 2e8342b1c..cb39858a0 100644 --- a/apps/mtxcli/Cargo.toml +++ b/apps/mtxcli/Cargo.toml @@ -1,6 +1,6 @@ [package] name = "mtxcli" -version = "0.6.0" +version = "0.7.0" authors = ["bunnie "] edition = "2018" description = "Matrix chat" @@ -8,29 +8,31 @@ description = "Matrix chat" # Dependency versions enforced by Cargo.lock. [dependencies] log = "0.4.14" -num-derive = {version = "0.3.3", default-features = false} -num-traits = {version = "0.2.14", default-features = false} +num-derive = { version = "0.3.3", default-features = false} +num-traits = { version = "0.2.14", default-features = false} xous = "0.9.31" xous-ipc = "0.9.31" log-server = { package = "xous-api-log", version = "0.1.26" } ticktimer-server = { package = "xous-api-ticktimer", version = "0.9.26" } xous-names = { package = "xous-api-names", version = "0.9.28" } -gam = {path = "../../services/gam" } -graphics-server = {path = "../../services/graphics-server" } -trng = {path = "../../services/trng"} -locales = {path = "../../locales"} -ime-plugin-api = {path = "../../services/ime-plugin-api"} -ime-plugin-shell = {path = "../../services/ime-plugin-shell"} -content-plugin-api = {path = "../../services/content-plugin-api"} # all content canvas providers must provide this API -com = {path = "../../services/com"} -llio = {path = "../../services/llio"} -codec = {path = "../../services/codec"} +gam = { path = "../../services/gam" } +graphics-server = { path = "../../services/graphics-server" } +trng = { path = "../../services/trng"} +locales = { path = "../../locales"} +ime-plugin-api = { path = "../../services/ime-plugin-api"} +ime-plugin-shell = { path = "../../services/ime-plugin-shell"} +content-plugin-api = { path = "../../services/content-plugin-api"} # all content canvas providers must provide this API +codec = { path = "../../services/codec"} +com = { path = "../../services/com"} +com_rs-ref = { path = "../../imports/com_rs-ref"} +llio = { path = "../../services/llio"} +net = { path = "../../services/net" } +pddb = { path = "../../services/pddb" } +status = { path = "../../services/status" } # new dependencies for mtxcli percent-encoding = "2.2" serde = { version = "1.0", features = [ "derive" ] } ureq = { version = "2.5", features = ["json"] } -# Xous APIs -pddb = {path = "../../services/pddb" } [features] default = [] diff --git a/apps/mtxcli/locales/i18n.json b/apps/mtxcli/locales/i18n.json index 5f9b384cc..fb0eb3f57 100644 --- a/apps/mtxcli/locales/i18n.json +++ b/apps/mtxcli/locales/i18n.json @@ -48,6 +48,13 @@ "ja": "available mtxcli commands: *EN*", "zh": "available mtxcli commands: *EN*" }, + "mtxcli.initialized": { + "en": "MTXCLI ready", + "en-tts": "MTXCLI ready", + "fr": "MTXCLI prêt", + "ja": "MTXCLI ready *EN*", + "zh": "MTXCLI ready *EN*" + }, "mtxcli.logged.in": { "en": "logged in", "en-tts": "logged in", @@ -97,6 +104,13 @@ "ja": "migration completed *EN*", "zh": "migration completed *EN*" }, + "mtxcli.migrations.complete": { + "en": "migrations complete", + "en-tts": "migrations complete", + "fr": "tous les migrations terminées", + "ja": "migrations complete *EN*", + "zh": "migrations complete *EN*" + }, "mtxcli.not.connected": { "en": "not connected", "en-tts": "not conntected", @@ -111,6 +125,13 @@ "ja": "WARNING: pddb not mounted *EN*", "zh": "WARNING: pddb not mounted *EN*" }, + "mtxcli.please.login": { + "en": "please /login", + "en-tts": "please /login", + "fr": "Veuillez /login", + "ja": "please /login *EN*", + "zh": "please /login *EN*" + }, "mtxcli.please.set.password": { "en": "please /set password my-password", "en-tts": "please /set password my-password", @@ -188,6 +209,13 @@ "ja": "/unset key *EN*", "zh": "/unset key *EN*" }, + "mtxcli.wifi.connected": { + "en": "WiFi connected", + "en-tts": "WiFi connected", + "fr": "WiFi connecté", + "ja": "WiFi connected *EN*", + "zh": "WiFi connected *EN*" + }, "mtxcli.wifi.warning": { "en": "WARNING: WiFi not connected", "en-tts": "WARNING: WiFi not connected", diff --git a/apps/mtxcli/src/cmds.rs b/apps/mtxcli/src/cmds.rs index f50f28ced..fc2a91b06 100644 --- a/apps/mtxcli/src/cmds.rs +++ b/apps/mtxcli/src/cmds.rs @@ -1,7 +1,6 @@ use xous::{MessageEnvelope, Message,StringBuffer}; use xous_ipc::String as XousString; use core::fmt::Write; -use locales::t; use std::collections::HashMap; use std::fs::File; @@ -15,7 +14,6 @@ mod url; mod web; const DATE_2023: u64 = 1672538401; // for clock_not_set() -const APP: &str = "mtxcli"; /// PDDB Dict for mtxcli keys const MTXCLI_DICT: &str = "mtxcli"; @@ -36,11 +34,32 @@ const HTTPS: &str = "https://"; const SERVER_MATRIX: &str = "https://matrix.org"; const EMPTY: &str = ""; -const MTX_TIMEOUT: i32 = 300; // ms +const SENTINEL: char = '‡'; +const MTX_LONG_TIMEOUT: i32 = 60000; // ms pub const CLOCK_NOT_SET_ID: usize = 1; pub const PDDB_NOT_MOUNTED_ID: usize = 2; pub const WIFI_NOT_CONNECTED_ID: usize = 3; +pub const MTXCLI_INITIALIZED_ID: usize = 4; +pub const WIFI_CONNECTED_ID: usize = 5; +pub const SET_USER_ID: usize = 6; +pub const SET_PASSWORD_ID: usize = 7; +pub const LOGGED_IN_ID: usize = 8; +pub const LOGIN_FAILED_ID: usize = 9; +pub const SET_ROOM_ID: usize = 10; +pub const ROOMID_FAILED_ID: usize = 11; +pub const FILTER_FAILED_ID: usize = 12; +pub const SET_SERVER_ID: usize = 13; +pub const LOGGING_IN_ID: usize = 14; +pub const LOGGED_OUT_ID: usize = 15; +pub const NOT_CONNECTED_ID: usize = 16; +pub const FAILED_TO_SEND_ID: usize = 17; +pub const PLEASE_LOGIN_ID: usize = 18; + +#[cfg(not(target_os = "xous"))] +pub const HOSTED_MODE: bool = true; +#[cfg(target_os = "xous")] +pub const HOSTED_MODE: bool = false; /// Returns a version string which is more likely to string compare /// correctly vs. another version. FFI please see @@ -54,7 +73,7 @@ fn get_version(ticktimer: &ticktimer_server::Ticktimer) -> String { log::info!("version={}=", version); version } else { - log::error!("ERROR, couldn't find version from xous_version: {}", + log::info!("ERROR, couldn't find version from xous_version: {}", xous_version); xous_version } @@ -102,6 +121,7 @@ pub struct CommonEnv { async_msg_callback_id: u32, async_msg_conn: u32, trng: Trng, + netmgr: net::NetManager, xns: xous_names::XousNames, user: String, username: String, @@ -114,21 +134,26 @@ pub struct CommonEnv { first_line: bool, version: String, initialized: bool, + wifi_connected: bool, + listening: bool, } impl CommonEnv { pub fn new() -> CommonEnv { - let xns = xous_names::XousNames::new().unwrap(); let ticktimer = ticktimer_server::Ticktimer::new() .expect("Couldn't connect to Ticktimer"); let cb_registrations = HashMap::new(); let async_msg_callback_id: u32 = 0; let async_msg_conn: u32 = 0; + let netmgr = net::NetManager::new(); + let xns = xous_names::XousNames::new().unwrap(); + let trng = Trng::new(&xns).unwrap(); let common = CommonEnv { ticktimer, cb_registrations, async_msg_callback_id, async_msg_conn, - trng: Trng::new(&xns).unwrap(), + trng, + netmgr, xns, user: EMPTY.to_string(), username: EMPTY.to_string(), @@ -141,6 +166,8 @@ impl CommonEnv { first_line: true, version: EMPTY.to_string(), initialized: false, + wifi_connected: false, + listening: false, }; common } @@ -176,8 +203,6 @@ impl CommonEnv { .expect("unable to create string message"); str_buf.send(self.async_msg_conn, self.async_msg_callback_id) .expect("unable to send string message"); - // let msg = str_buf.create_memory_message(self.async_msg_callback_id); - // xous::send_message(self.async_msg_conn, msg).unwrap(); } pub fn gen_txn_id(&mut self) -> String { @@ -198,7 +223,7 @@ impl CommonEnv { let mut keypath = PathBuf::new(); keypath.push(MTXCLI_DICT); if std::fs::metadata(&keypath).is_ok() { // keypath exists - log::info!("dict '{}' exists", MTXCLI_DICT); + // log::info!("dict '{}' exists", MTXCLI_DICT); } else { log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT); std::fs::create_dir_all(&keypath)?; @@ -227,14 +252,14 @@ impl CommonEnv { true }, Err(e) => { - log::error!("error setting key {}: {:?}", key, e); + log::info!("error setting key {}: {:?}", key, e); false } } } pub fn set_user(&mut self, value: &str) { - log::debug!("# USER_KEY set '{}' = '{}'", USER_KEY, value); + log::info!("# USER_KEY set '{}' = '{}'", USER_KEY, value); let i = match value.find('@') { Some(index) => { index + 1 }, None => { 0 }, @@ -251,26 +276,22 @@ impl CommonEnv { self.server = SERVER_MATRIX.to_string(); } self.user = value.to_string(); - log::debug!("# user = '{}' username = '{}' server = '{}'", self.user, self.username, self.server); + log::info!("# user = '{}' username = '{}' server = '{}'", self.user, self.username, self.server); self.set_debug(USERNAME_KEY, &self.username.clone()); self.set_debug(SERVER_KEY, &self.server.clone()); self.unset_debug(TOKEN_KEY); - self.token = EMPTY.to_string(); } pub fn set_password(&mut self) { - log::debug!("# PASSWORD_KEY set '{}' => clearing TOKEN_KEY", PASSWORD_KEY); + log::info!("# PASSWORD_KEY set '{}' => clearing TOKEN_KEY", PASSWORD_KEY); self.unset_debug(TOKEN_KEY); } pub fn set_room(&mut self) { - log::debug!("# ROOM_KEY set '{}' => clearing ROOM_ID_KEY, SINCE_KEY, FILTER_KEY", ROOM_KEY); + log::info!("# ROOM_KEY set '{}' => clearing ROOM_ID_KEY, SINCE_KEY, FILTER_KEY", ROOM_KEY); self.unset_debug(ROOM_ID_KEY); - self.room_id = EMPTY.to_string(); self.unset_debug(SINCE_KEY); - self.since = EMPTY.to_string(); self.unset_debug(FILTER_KEY); - self.filter = EMPTY.to_string(); } pub fn unset(&mut self, key: &str) -> Result<(), Error> { @@ -282,17 +303,12 @@ impl CommonEnv { let mut keypath = PathBuf::new(); keypath.push(MTXCLI_DICT); if std::fs::metadata(&keypath).is_ok() { // keypath exists - log::info!("dict '{}' exists", MTXCLI_DICT); + // log::info!("dict '{}' exists", MTXCLI_DICT); } else { log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT); std::fs::create_dir_all(&keypath)?; } keypath.push(key); - // NOTE: the std:fs::metadata call may return Ok() even when - // the file does not exist. - // As a workaround WE COULD set the variable to the empty string - // log::info!("dict:key = '{}:{}' set to empty string (not deleting it)", MTXCLI_DICT, key); - // File::create(keypath)?.write_all(EMPTY.as_bytes())?; if std::fs::metadata(&keypath).is_ok() { // keypath exists log::info!("dict:key = '{}:{}' exists.. deleting it", MTXCLI_DICT, key); std::fs::remove_file(keypath)?; @@ -317,7 +333,7 @@ impl CommonEnv { true }, Err(e) => { - log::error!("error unsetting key {}: {:?}", key, e); + log::info!("error unsetting key {}: {:?}", key, e); false } } @@ -330,7 +346,7 @@ impl CommonEnv { let mut keypath = PathBuf::new(); keypath.push(MTXCLI_DICT); if std::fs::metadata(&keypath).is_ok() { // keypath exists - log::info!("dict '{}' exists", MTXCLI_DICT); + // log::info!("dict '{}' exists", MTXCLI_DICT); } else { log::info!("dict '{}' does NOT exist.. creating it", MTXCLI_DICT); std::fs::create_dir_all(&keypath)?; @@ -356,55 +372,40 @@ impl CommonEnv { value.to_string() } Err(e) => { - log::error!("error getting key {}: {:?}", key, e); + log::info!("error getting key {}: {:?}", key, e); default.to_string() } } } - pub fn prompt(&mut self, ret: &mut XousString::<1024>, text: &str) { - if self.first_line { - write!(ret, "{}> {}", APP, text).unwrap(); - self.first_line = false; - } else { - write!(ret, "\n{}> {}", APP, text).unwrap(); - } - } - - pub fn user_says(&mut self, ret: &mut XousString::<1024>, text: &str) { + pub fn user_says(&mut self, text: &str) { if ! self.logged_in { - if ! self.login(ret) { + if ! self.login() { return; } } if self.room_id.len() == 0 { - if ! self.get_room_id(ret) { + if ! self.get_room_id() { return; } } if self.filter.len() == 0 { - if ! self.get_filter(ret) { + if ! self.get_filter() { return; } } - self.read_messages(ret); - // The following is not required, because we will get what - // the user said when we read_messages the second time - // write!(ret, "{}> {}", self.username, text).unwrap(); - let txn_id = self.gen_txn_id(); log::info!("txn_id = {}", txn_id); if web::send_message(&self.server, &self.room_id, &text, &txn_id, &self.token) { log::info!("SENT: {}", text); - self.read_messages(ret); // update since to include what user said } else { log::info!("FAILED TO SEND"); - write!(ret, "{}", t!("mtxcli.send.failed", xous::LANG)).unwrap(); + self.scalar_async_msg(FAILED_TO_SEND_ID); } } - pub fn login(&mut self, ret: &mut XousString::<1024>) -> bool { - self.prompt(ret, t!("mtxcli.logging.in", xous::LANG)); + pub fn login(&mut self) -> bool { + self.scalar_async_msg(LOGGING_IN_ID); self.token = self.get_default(TOKEN_KEY, EMPTY); self.logged_in = false; if self.token.len() > 0 { @@ -415,47 +416,48 @@ impl CommonEnv { if ! self.logged_in { if web::get_login_type(&self.server) { let user = self.get_default(USER_KEY, USER_KEY); + if user.len() == 0 { + self.scalar_async_msg(SET_USER_ID); + } let password = self.get_default(PASSWORD_KEY, EMPTY); if password.len() == 0 { - self.prompt(ret, t!("mtxcli.please.set.user", xous::LANG)); - self.prompt(ret, t!("mtxcli.please.set.password", xous::LANG)); + self.scalar_async_msg(SET_PASSWORD_ID); } else { if let Some(new_token) = web::authenticate_user(&self.server, &user, &password) { self.set_debug(TOKEN_KEY, &new_token); - self.token = new_token; self.logged_in = true; } else { - log::error!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD); + log::info!("Error: cannnot login with type: {}", web::MTX_LOGIN_PASSWORD); } } } } if self.logged_in { - self.prompt(ret, t!("mtxcli.logged.in", xous::LANG)); + self.scalar_async_msg(LOGGED_IN_ID); } else { - self.prompt(ret, t!("mtxcli.login.failed", xous::LANG)); + self.scalar_async_msg(LOGIN_FAILED_ID); } self.logged_in } - pub fn logout(&mut self, ret: &mut XousString::<1024>) { + pub fn logout(&mut self) { self.unset_debug(TOKEN_KEY); - self.prompt(ret, t!("mtxcli.logged.out", xous::LANG)); + self.scalar_async_msg(LOGGED_OUT_ID); self.logged_in = false; } // assume logged in, token is valid - pub fn get_room_id(&mut self, ret: &mut XousString::<1024>) -> bool { + pub fn get_room_id(&mut self) -> bool { if self.room_id.len() > 0 { true } else { let room = self.get_default(ROOM_KEY, EMPTY); let server = self.get_default(SERVER_KEY, EMPTY); if room.len() == 0 { - self.prompt(ret, t!("mtxcli.please.set.room", xous::LANG)); + self.scalar_async_msg(SET_ROOM_ID); false } else if server.len() == 0 { - self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG)); + self.scalar_async_msg(SET_SERVER_ID); false } else { let mut room_server = String::new(); @@ -473,16 +475,15 @@ impl CommonEnv { }, }; if i >= server.len() { - self.prompt(ret, t!("mtxcli.please.set.server", xous::LANG)); + self.scalar_async_msg(SET_SERVER_ID); false } else { room_server.push_str(&server[i..]); if let Some(new_room_id) = web::get_room_id(&self.server, &room_server, &self.token) { self.set_debug(ROOM_ID_KEY, &new_room_id); - self.room_id = new_room_id; true } else { - self.prompt(ret, t!("mtxcli.roomid.failed", xous::LANG)); + self.scalar_async_msg(ROOMID_FAILED_ID); false } } @@ -491,46 +492,79 @@ impl CommonEnv { } // assume logged in, token is valid, room_id is valid, user is valid - pub fn get_filter(&mut self, ret: &mut XousString::<1024>) -> bool { + pub fn get_filter(&mut self) -> bool { if self.filter.len() > 0 { true } else { if let Some(new_filter) = web::get_filter(&self.user, &self.server, &self.room_id, &self.token) { self.set_debug(FILTER_KEY, &new_filter); - self.filter = new_filter; true } else { - self.prompt(ret, t!("mtxcli.filter.failed", xous::LANG)); + self.scalar_async_msg(FILTER_FAILED_ID); false } } } - // assume logged in, token is valid, room_id is valid, user is valid, - // and filter is valid - pub fn read_messages(&mut self, ret: &mut XousString::<1024>) -> bool { - if let Some((since, messages)) = web::client_sync(&self.server, &self.filter, - &self.since, MTX_TIMEOUT, - &self.room_id, &self.token) { - self.set_debug(SINCE_KEY, &since); - self.since = since; - if messages.len() > 0 { - if self.first_line { - write!(ret, "{}", messages).unwrap(); - self.first_line = false; - } else { - write!(ret, "\n{}", messages).unwrap(); + pub fn listen(&mut self) { + if self.listening { + log::info!("Already listening"); + return; + } + if ! self.logged_in { + log::info!("Not logged in"); + return; + } + if self.room_id.len() == 0 { + if ! self.get_room_id() { + return; + } + } + if self.filter.len() == 0 { + if ! self.get_filter() { + return; + } + } + self.listening = true; + log::info!("Started listening"); + std::thread::spawn({ + let server = self.server.clone(); + let filter = self.filter.clone(); + let since = self.since.clone(); + let room_id = self.room_id.clone(); + let token = self.token.clone(); + let async_msg_conn = self.async_msg_conn.clone(); + let async_msg_callback_id = self.async_msg_callback_id.clone(); + move || { + // log::info!("client_sync for {} ms...", MTX_LONG_TIMEOUT); + let mut response = String::new(); + response.push(SENTINEL); + if let Some((since, messages)) = web::client_sync(&server, &filter, &since, MTX_LONG_TIMEOUT, &room_id, &token) { + response.push_str(&since); + response.push(SENTINEL); + response.push_str(&messages); + response.push(SENTINEL); } - true - } else { - false + let str_buf = StringBuffer::from_str(&response) + .expect("unable to create string message"); + str_buf.send(async_msg_conn, async_msg_callback_id) + .expect("unable to send string message"); } - } else { - false - } + }); } + pub fn listen_over(&mut self, since: &str) { + self.listening = false; + log::info!("Stopped listening"); + if since.len() > 0 { + self.set_debug(SINCE_KEY, since); + // don't re-start listening if there was an error + if self.logged_in && (HOSTED_MODE || self.wifi_connected) { + self.listen(); + } + } + } } /* @@ -603,36 +637,61 @@ impl CmdEnv { &mut self.unset_cmd, ]; + let prev_wifi_connected = self.common_env.wifi_connected; + self.common_env.wifi_connected = false; + if let Some(conf) = self.common_env.netmgr.get_ipv4_config() { + if conf.dhcp == com_rs_ref::DhcpState::Bound { + self.common_env.wifi_connected = true; + } + } + if self.common_env.wifi_connected != prev_wifi_connected { + if self.common_env.wifi_connected { + self.common_env.scalar_async_msg(WIFI_CONNECTED_ID); + } else { + self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID); + } + } + if let Some(cmdline) = maybe_cmdline { - // Initialization (must wait until PDDB is mounted and llio can - // report accurate time). Here we wait to check for initialization - // once the user has typed something if ! self.common_env.initialized { log::info!("initializing"); + log::info!("WiFi connected: {}", self.common_env.wifi_connected); if clock_not_set() { self.common_env.scalar_async_msg(CLOCK_NOT_SET_ID); + } + if ! self.common_env.wifi_connected && ! prev_wifi_connected { + self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ID); + } + let pddb = pddb::PddbMountPoller::new(); + if ! pddb.is_mounted_nonblocking() { + self.common_env.scalar_async_msg(PDDB_NOT_MOUNTED_ID); } else { - let pddb = pddb::PddbMountPoller::new(); - if ! pddb.is_mounted_nonblocking() { - self.common_env.scalar_async_msg(PDDB_NOT_MOUNTED_ID); - } else { - // FUTURE: Check if Wifi is connected - // if not then - // self.common_env.scalar_async_msg(WIFI_NOT_CONNECTED_ ID); - self.common_env.user = self.common_env.get_default(USER_KEY, EMPTY); - self.common_env.username = self.common_env.get_default(USERNAME_KEY, USERNAME_KEY); - self.common_env.server = self.common_env.get_default(SERVER_KEY, SERVER_MATRIX); - self.common_env.room_id = self.common_env.get_default(ROOM_ID_KEY, EMPTY); - self.common_env.filter = self.common_env.get_default(FILTER_KEY, EMPTY); - self.common_env.since = self.common_env.get_default(SINCE_KEY, EMPTY); - self.common_env.version = get_version(&self.common_env.ticktimer); - + log::info!("PDDB is mounted"); + self.common_env.user = self.common_env.get_default(USER_KEY, EMPTY); + self.common_env.username = self.common_env.get_default(USERNAME_KEY, USERNAME_KEY); + self.common_env.server = self.common_env.get_default(SERVER_KEY, SERVER_MATRIX); + self.common_env.room_id = self.common_env.get_default(ROOM_ID_KEY, EMPTY); + self.common_env.filter = self.common_env.get_default(FILTER_KEY, EMPTY); + self.common_env.since = self.common_env.get_default(SINCE_KEY, EMPTY); + self.common_env.version = get_version(&self.common_env.ticktimer); + if self.common_env.logged_in || self.common_env.login() { run_migrations(&mut self.common_env); self.common_env.initialized = true; + log::info!("initialized"); + self.common_env.scalar_async_msg(MTXCLI_INITIALIZED_ID); + } else { + self.common_env.scalar_async_msg(PLEASE_LOGIN_ID); } } } + if ! self.common_env.listening && + self.common_env.logged_in && + (HOSTED_MODE || self.common_env.wifi_connected) && + self.common_env.initialized { + self.common_env.listen(); + } + let maybe_verb = tokenize(cmdline); let mut cmd_ret: Result>, xous::Error> = Ok(None); @@ -674,16 +733,13 @@ impl CmdEnv { let mut text = String::from(verb); text.push_str(" "); text.push_str(cmdline.to_str()); - self.common_env.user_says(&mut ret, &text); - Ok(Some(ret)) + self.common_env.user_says(&text); + // only for sync case Ok(Some(ret)) + Ok(None) } } else { log::info!("NO INPUT"); - if self.common_env.read_messages(&mut ret) { - Ok(Some(ret)) - } else { - Ok(None) - } + Ok(None) } } else if let Some(callback) = maybe_callback { let mut cmd_ret: Result>, xous::Error> = Ok(None); @@ -716,6 +772,7 @@ impl CmdEnv { } } + /// extract the first token, as delimited by spaces /// modifies the incoming line by removing the token and returning the remainder /// returns the found token @@ -756,7 +813,7 @@ pub(crate) fn heap_usage() -> usize { usage } _ => { - log::error!("Couldn't measure heap usage"); + log::info!("Couldn't measure heap usage"); 0 }, } @@ -769,8 +826,10 @@ pub fn clock_not_set() -> bool { .expect("Time went backwards"); let seconds: u64 = since_the_epoch.as_secs(); if seconds < DATE_2023 { + log::info!("clock NOT set, seconds since epoch: {}", seconds); true } else { + log::info!("clock set, seconds since epoch: {}", seconds); false } } diff --git a/apps/mtxcli/src/cmds/help.rs b/apps/mtxcli/src/cmds/help.rs index 248ac5b29..1c8b364a6 100644 --- a/apps/mtxcli/src/cmds/help.rs +++ b/apps/mtxcli/src/cmds/help.rs @@ -1,6 +1,6 @@ -use crate::{ShellCmdApi,CommonEnv, - cmds::{CLOCK_NOT_SET_ID,PDDB_NOT_MOUNTED_ID,WIFI_NOT_CONNECTED_ID}}; -use xous::{MessageEnvelope, Message,StringBuffer}; +use crate::{ShellCmdApi, CommonEnv}; +use crate::cmds::*; +use xous::{MessageEnvelope, Message, StringBuffer}; use xous_ipc::String as XousString; use core::fmt::Write; use locales::t; @@ -74,7 +74,7 @@ impl<'a> ShellCmdApi<'a> for Help { } // NOTE: the help callback is used to process async messages - fn callback(&mut self, msg: &MessageEnvelope, _env: &mut CommonEnv) -> Result>, xous::Error> { + fn callback(&mut self, msg: &MessageEnvelope, env: &mut CommonEnv) -> Result>, xous::Error> { match &msg.body { Message::Scalar(xous::ScalarMessage{id: _, arg1: _, arg2: _, arg3: _, arg4: async_msg_id}) => { @@ -89,6 +89,51 @@ impl<'a> ShellCmdApi<'a> for Help { WIFI_NOT_CONNECTED_ID => { t!("mtxcli.wifi.warning", xous::LANG) }, + MTXCLI_INITIALIZED_ID => { + t!("mtxcli.initialized", xous::LANG) + }, + WIFI_CONNECTED_ID => { + t!("mtxcli.wifi.connected", xous::LANG) + }, + SET_USER_ID => { + t!("mtxcli.please.set.user", xous::LANG) + }, + SET_PASSWORD_ID => { + t!("mtxcli.please.set.password", xous::LANG) + }, + LOGGED_IN_ID => { + t!("mtxcli.logged.in", xous::LANG) + }, + LOGIN_FAILED_ID => { + t!("mtxcli.login.failed", xous::LANG) + }, + SET_ROOM_ID => { + t!("mtxcli.please.set.room", xous::LANG) + }, + ROOMID_FAILED_ID => { + t!("mtxcli.roomid.failed", xous::LANG) + }, + FILTER_FAILED_ID => { + t!("mtxcli.filter.failed", xous::LANG) + }, + SET_SERVER_ID => { + t!("mtxcli.please.set.server", xous::LANG) + }, + LOGGING_IN_ID => { + t!("mtxcli.logging.in", xous::LANG) + }, + LOGGED_OUT_ID => { + t!("mtxcli.logged.out", xous::LANG) + }, + NOT_CONNECTED_ID => { + t!("mtxcli.not.connected", xous::LANG) + }, + FAILED_TO_SEND_ID => { + t!("mtxcli.send.failed", xous::LANG) + }, + PLEASE_LOGIN_ID => { + t!("mtxcli.please.login", xous::LANG) + }, _ => { "unknown async_msg_id" }, @@ -100,10 +145,27 @@ impl<'a> ShellCmdApi<'a> for Help { Message::Move(mm) => { let str_buf = unsafe { StringBuffer::from_memory_message(mm) }; let msg = str_buf.to_str(); - let mut ret = XousString::<1024>::new(); - write!(ret, "{}", msg).unwrap(); // log::info!("async message \"{}\"", msg); - return Ok(Some(ret)); + let mut ret = XousString::<1024>::new(); + if msg.starts_with(SENTINEL) { + let msgv: Vec<&str> = msg.split(SENTINEL).collect(); + if msgv.len() == 4 { + env.listen_over(msgv[1]); + if msgv[2].len() > 0 { + write!(ret, "{}", msgv[2]).unwrap(); + return Ok(Some(ret)); + } else { + return Ok(None); + } + } else { + log::info!("client_sync had an error"); + env.listen_over(msgv[0]); + return Ok(None); + } + } else { + write!(ret, "{}", msg).unwrap(); + return Ok(Some(ret)); + } }, _ => { log::error!("received unknown callback type: {:?}", msg) diff --git a/apps/mtxcli/src/cmds/login.rs b/apps/mtxcli/src/cmds/login.rs index 4ae0f32e3..ac6685b13 100644 --- a/apps/mtxcli/src/cmds/login.rs +++ b/apps/mtxcli/src/cmds/login.rs @@ -15,8 +15,7 @@ impl<'a> ShellCmdApi<'a> for Login { cmd_api!(login); fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result>, xous::Error> { - let mut ret = XousString::<1024>::new(); - env.login(&mut ret); - Ok(Some(ret)) + env.login(); + Ok(None) } } diff --git a/apps/mtxcli/src/cmds/logout.rs b/apps/mtxcli/src/cmds/logout.rs index af1fc7e5d..914d588da 100644 --- a/apps/mtxcli/src/cmds/logout.rs +++ b/apps/mtxcli/src/cmds/logout.rs @@ -15,8 +15,7 @@ impl<'a> ShellCmdApi<'a> for Logout { cmd_api!(logout); fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result>, xous::Error> { - let mut ret = XousString::<1024>::new(); - env.logout(&mut ret); - Ok(Some(ret)) + env.logout(); + Ok(None) } } diff --git a/apps/mtxcli/src/cmds/migrations.rs b/apps/mtxcli/src/cmds/migrations.rs index 1b610a92e..b61f4180b 100644 --- a/apps/mtxcli/src/cmds/migrations.rs +++ b/apps/mtxcli/src/cmds/migrations.rs @@ -71,5 +71,8 @@ pub fn run_migrations(common: &mut CommonEnv) { } common.set(VERSION_KEY, &common.version.clone()) .expect("cannot set _version"); + let migrations_complete = t!("mtxcli.migrations.complete", xous::LANG); + log::info!("{}", migrations_complete); + common.send_async_msg(&migrations_complete); } } diff --git a/apps/mtxcli/src/cmds/status.rs b/apps/mtxcli/src/cmds/status.rs index 05990973d..93379fae2 100644 --- a/apps/mtxcli/src/cmds/status.rs +++ b/apps/mtxcli/src/cmds/status.rs @@ -1,6 +1,6 @@ use crate::{ShellCmdApi,CommonEnv}; +use crate::cmds::*; use xous_ipc::String as XousString; -use locales::t; #[derive(Debug)] pub struct Status { @@ -16,15 +16,11 @@ impl<'a> ShellCmdApi<'a> for Status { cmd_api!(status); fn process(&mut self, _args: XousString::<1024>, env: &mut CommonEnv) -> Result>, xous::Error> { - let mut ret = XousString::<1024>::new(); - let mut text = String::new(); - text.push_str("status: "); if env.logged_in { - text.push_str(t!("mtxcli.logged.in", xous::LANG)); + env.scalar_async_msg(LOGGED_IN_ID); } else { - text.push_str(t!("mtxcli.not.connected", xous::LANG)); + env.scalar_async_msg(NOT_CONNECTED_ID); } - env.prompt(&mut ret, &text); - Ok(Some(ret)) + Ok(None) } } diff --git a/apps/mtxcli/src/cmds/web.rs b/apps/mtxcli/src/cmds/web.rs index 258c09212..6cad891b8 100644 --- a/apps/mtxcli/src/cmds/web.rs +++ b/apps/mtxcli/src/cmds/web.rs @@ -30,7 +30,7 @@ fn serialize(object: &T) -> Option { Some(value) }, Err(e) => { - log::error!("ERROR in serialize: {:?}", e); + log::info!("ERROR in serialize: {:?}", e); None } } @@ -42,7 +42,7 @@ pub fn handle_response(maybe_response: Result) -> Op if let Ok(body) = response.into_json() { Some(body) } else { - log::error!("Error: could not convert response into JSON"); + log::info!("Error: could not convert response into JSON"); None } }, @@ -50,11 +50,11 @@ pub fn handle_response(maybe_response: Result) -> Op /* the server returned an unexpected status code (such as 400, 500 etc) */ let err_body = response.into_string().unwrap(); - log::error!("ERROR code {} err_body = {}", code, err_body); + log::info!("ERROR code {} err_body = {}", code, err_body); None } Err(e) => { - log::error!("ERROR in handle_response: {:?}", e); + log::info!("ERROR in handle_response: {:?}", e); None } } @@ -107,10 +107,10 @@ pub fn whoami(server: &str, token: &str) -> bool { if let Some(value) = handle_response(get_json_auth(&url, token)) { if let Value::Object(body) = value { if let Some(Value::String(device_id)) = body.get("device_id") { - log::debug!("device_id = {}", device_id); + log::info!("device_id = {}", device_id); } if let Some(Value::String(user_id)) = body.get("user_id") { - log::debug!("user_id = {}", user_id); + log::info!("user_id = {}", user_id); } } true @@ -192,21 +192,21 @@ pub fn get_room_id(server: &str, room_server: &str, token: &str) -> Option, room_id: &str) -> String { - log::debug!("heap usage: {}", crate::cmds::heap_usage()); + log::info!("heap usage: {}", crate::cmds::heap_usage()); let mut messages = String::new(); if let Some(Value::Object(rooms)) = body.get("rooms") { if let Some(Value::Object(join)) = rooms.get("join") { @@ -378,7 +378,7 @@ fn get_messages(body: Map, room_id: &str) -> String { pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32, room_id: &str, token: &str) -> Option<(String, String)> { - log::debug!("heap usage: {}", crate::cmds::heap_usage()); + log::info!("heap usage: {}", crate::cmds::heap_usage()); let mut url = String::from(server); url.push_str("/_matrix/client/r0/sync?filter="); url.push_str(filter); @@ -388,17 +388,17 @@ pub fn client_sync(server: &str, filter: &str, since: &str, timeout: i32, url.push_str("&since="); url.push_str(since); } - log::debug!("client_sync = {}", url); + log::info!("client_sync = {}", url); if let Some(value) = handle_response(get_json_auth(&url, token)) { if let Value::Object(body) = value { if let Some(Value::String(next_batch)) = body.get("next_batch") { Some((next_batch.to_string(), get_messages(body, room_id))) } else { - log::error!("invalid response for client_sync"); + log::info!("invalid response for client_sync"); None } } else { - log::error!("Error for client_sync: deserialization"); + log::info!("Error for client_sync: deserialization"); None } } else { @@ -424,29 +424,29 @@ impl MessageRequest { } pub fn send_message(server: &str, room_id: &str, text: &str, txn_id: &str, token: &str) -> bool { - log::debug!("heap usage: {}", crate::cmds::heap_usage()); + log::info!("heap usage: {}", crate::cmds::heap_usage()); let room_id_encoded = url::encode(room_id); let mut url = String::from(server); url.push_str("/_matrix/client/r0/rooms/"); url.push_str(&room_id_encoded); url.push_str("/send/m.room.message/"); url.push_str(txn_id); - log::debug!("send_message = {}", url); + log::info!("send_message = {}", url); let message_request = MessageRequest::new(text); if let Some(request_body) = serialize(&message_request) { if let Some(value) = handle_response(put_string_auth(&url, &request_body, token)) { if let Value::Object(_body) = value { true } else { - log::error!("invalid response for send_message"); + log::info!("invalid response for send_message"); false } } else { - log::error!("Error for send_message"); + log::info!("Error for send_message"); false } } else { - log::error!("Error unable to serialize request for send_message"); + log::info!("Error unable to serialize request for send_message"); false } }