mirror of
https://github.com/chatmail/core.git
synced 2026-04-20 15:06:30 +03:00
Connectivity view (instead of spamming the user with error_network when sth fails) (#2319)
See https://support.delta.chat/t/discussion-how-to-show-error-states/1363/10 <!-- comment --> It turns out that it's pretty easy to distinguish between lots of states (currently Error/NotConnected, Connecting…, Getting new messages… and Connected). What's not that easy is distinguishing between an actual error and no network, because if the server just doesn't respond, it could mean that we don't have network or that we are trying ipv6, but only ipv4 works. **WRT debouncing:** Sending of EVENT_CONNECTIVITY_CHANGED is not debounced, but emitted every time one of the 3 threads (Inbox, Mvbox and Sentbox) has a network error, starts fetching data, or is done fetching data. This means that it is emitted: - 9 times when dc_maybe_network() is called or we get network connection - 12 times when we lose network connection Some measurements: dc_get_connectivity() takes a little more than 1ms (in my measurements back in March), dc_get_connectivity_html() takes 10-20ms. This means that it's no immmediate problem to call them very often, might increase battery drain though. For the UI it may be a lot of work to update the title everytime; at least Android is smart enough to update the title only once. Possible problems (we don't have to worry about them now I think): - Due to the scan_folders feature, if the user has lots of folders, the state could be "Connecting..." for quite a long time, generally DC seemed a little unresponsive to me because it took so long for "Connecting..." to go away. Telegram has a state "Updating..." that sometimes comes after "Connecting...". To be done in other PRs: - Better handle the case that the password was changed on the server and authenticating fails, see https://github.com/deltachat/deltachat-core-rust/issues/1923 and https://github.com/deltachat/deltachat-core-rust/issues/1768 - maybe event debouncing (except for "Connected" connectivity events) fix https://github.com/deltachat/deltachat-android/issues/1760
This commit is contained in:
Hocuri
GitHub
349
src/scheduler/connectivity.rs
Normal file
349
src/scheduler/connectivity.rs
Normal file
@@ -0,0 +1,349 @@
|
||||
use core::fmt;
|
||||
use std::{ops::Deref, sync::Arc};
|
||||
|
||||
use async_std::sync::{Mutex, RwLockReadGuard};
|
||||
|
||||
use crate::events::EventType;
|
||||
use crate::{config::Config, scheduler::Scheduler};
|
||||
use crate::{context::Context, log::LogExt};
|
||||
|
||||
#[derive(Debug, Clone, Copy, PartialEq, Eq, EnumProperty, PartialOrd, Ord)]
|
||||
pub enum Connectivity {
|
||||
NotConnected = 1000,
|
||||
Connecting = 2000,
|
||||
/// Fetching or sending messages
|
||||
Working = 3000,
|
||||
Connected = 4000,
|
||||
}
|
||||
|
||||
// The order of the connectivities is important: worse connectivities (i.e. those at
|
||||
// the top) take priority. This means that e.g. if any folder has an error - usually
|
||||
// because there is no internet connection - the connectivity for the whole
|
||||
// account will be `Notconnected`.
|
||||
#[derive(Debug, Clone, PartialEq, Eq, EnumProperty)]
|
||||
enum DetailedConnectivity {
|
||||
Error(String),
|
||||
Uninitialized,
|
||||
Connecting,
|
||||
Working,
|
||||
InterruptingIdle,
|
||||
Connected,
|
||||
|
||||
/// The folder was configured not to be watched or configured_*_folder is not set
|
||||
NotConfigured,
|
||||
}
|
||||
|
||||
impl Default for DetailedConnectivity {
|
||||
fn default() -> Self {
|
||||
DetailedConnectivity::Uninitialized
|
||||
}
|
||||
}
|
||||
|
||||
impl DetailedConnectivity {
|
||||
fn to_basic(&self) -> Option<Connectivity> {
|
||||
match self {
|
||||
DetailedConnectivity::Error(_) => Some(Connectivity::NotConnected),
|
||||
DetailedConnectivity::Uninitialized => Some(Connectivity::NotConnected),
|
||||
DetailedConnectivity::Connecting => Some(Connectivity::Connecting),
|
||||
DetailedConnectivity::Working => Some(Connectivity::Working),
|
||||
DetailedConnectivity::InterruptingIdle => Some(Connectivity::Connected),
|
||||
DetailedConnectivity::Connected => Some(Connectivity::Connected),
|
||||
|
||||
// Just don't return a connectivity, probably the folder is configured not to be
|
||||
// watched or there is e.g. no "Sent" folder, so we are not interested in it
|
||||
DetailedConnectivity::NotConfigured => None,
|
||||
}
|
||||
}
|
||||
|
||||
fn to_string_imap(&self, _context: &Context) -> String {
|
||||
match self {
|
||||
DetailedConnectivity::Error(e) => format!("🔴 Error: {}", e),
|
||||
DetailedConnectivity::Uninitialized => "🔴 Not started".to_string(),
|
||||
DetailedConnectivity::Connecting => "🟡 Connecting…".to_string(),
|
||||
DetailedConnectivity::Working => "⬇️ Getting new messages…".to_string(),
|
||||
DetailedConnectivity::InterruptingIdle | DetailedConnectivity::Connected => {
|
||||
"🟢 Connected".to_string()
|
||||
}
|
||||
DetailedConnectivity::NotConfigured => "🔴 Not configured".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn to_string_smtp(&self, _context: &Context) -> String {
|
||||
match self {
|
||||
DetailedConnectivity::Error(e) => format!("🔴 Error: {}", e),
|
||||
DetailedConnectivity::Uninitialized => {
|
||||
"(You did not try to send a message recently)".to_string()
|
||||
}
|
||||
DetailedConnectivity::Connecting => "🟡 Connecting…".to_string(),
|
||||
DetailedConnectivity::Working => "⬆️ Sending…".to_string(),
|
||||
|
||||
// We don't know any more than that the last message was sent successfully;
|
||||
// since sending the last message, connectivity could have changed, which we don't notice
|
||||
// until another message is sent
|
||||
DetailedConnectivity::InterruptingIdle | DetailedConnectivity::Connected => {
|
||||
"🟢 Your last message was sent successfully".to_string()
|
||||
}
|
||||
DetailedConnectivity::NotConfigured => "🔴 Not configured".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
fn all_work_done(&self) -> bool {
|
||||
match self {
|
||||
DetailedConnectivity::Error(_) => true,
|
||||
DetailedConnectivity::Uninitialized => false,
|
||||
DetailedConnectivity::Connecting => false,
|
||||
DetailedConnectivity::Working => false,
|
||||
DetailedConnectivity::InterruptingIdle => false,
|
||||
DetailedConnectivity::Connected => true,
|
||||
DetailedConnectivity::NotConfigured => true,
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#[derive(Clone, Default)]
|
||||
pub(crate) struct ConnectivityStore(Arc<Mutex<DetailedConnectivity>>);
|
||||
|
||||
impl ConnectivityStore {
|
||||
async fn set(&self, context: &Context, v: DetailedConnectivity) {
|
||||
{
|
||||
*self.0.lock().await = v;
|
||||
}
|
||||
context.emit_event(EventType::ConnectivityChanged);
|
||||
}
|
||||
|
||||
pub(crate) async fn set_err(&self, context: &Context, e: impl ToString) {
|
||||
self.set(context, DetailedConnectivity::Error(e.to_string()))
|
||||
.await;
|
||||
}
|
||||
pub(crate) async fn set_connecting(&self, context: &Context) {
|
||||
self.set(context, DetailedConnectivity::Connecting).await;
|
||||
}
|
||||
pub(crate) async fn set_working(&self, context: &Context) {
|
||||
self.set(context, DetailedConnectivity::Working).await;
|
||||
}
|
||||
pub(crate) async fn set_connected(&self, context: &Context) {
|
||||
self.set(context, DetailedConnectivity::Connected).await;
|
||||
}
|
||||
pub(crate) async fn set_not_configured(&self, context: &Context) {
|
||||
self.set(context, DetailedConnectivity::NotConfigured).await;
|
||||
}
|
||||
|
||||
async fn get_detailed(&self) -> DetailedConnectivity {
|
||||
self.0.lock().await.deref().clone()
|
||||
}
|
||||
async fn get_basic(&self) -> Option<Connectivity> {
|
||||
self.0.lock().await.to_basic()
|
||||
}
|
||||
async fn get_all_work_done(&self) -> bool {
|
||||
self.0.lock().await.all_work_done()
|
||||
}
|
||||
}
|
||||
|
||||
/// Set all folder states to InterruptingIdle in case they were `Connected` before.
|
||||
/// Called during `dc_maybe_network()` to make sure that `dc_accounts_all_work_done()`
|
||||
/// returns false immediately after `dc_maybe_network()`.
|
||||
pub(crate) async fn idle_interrupted(scheduler: RwLockReadGuard<'_, Scheduler>) {
|
||||
let [inbox, mvbox, sentbox] = match &*scheduler {
|
||||
Scheduler::Running {
|
||||
inbox,
|
||||
mvbox,
|
||||
sentbox,
|
||||
..
|
||||
} => [
|
||||
inbox.state.connectivity.clone(),
|
||||
mvbox.state.connectivity.clone(),
|
||||
sentbox.state.connectivity.clone(),
|
||||
],
|
||||
Scheduler::Stopped => return,
|
||||
};
|
||||
drop(scheduler);
|
||||
|
||||
let mut connectivity_lock = inbox.0.lock().await;
|
||||
// For the inbox, we also have to set the connectivity to InterruptingIdle if it was
|
||||
// NotConfigured before: If all folders are NotConfigured, dc_get_connectivity()
|
||||
// returns Connected. But after dc_maybe_network(), dc_get_connectivity() must not
|
||||
// return Connected until DC is completely done with fetching folders; this also
|
||||
// includes scan_folders() which happens on the inbox thread.
|
||||
if *connectivity_lock == DetailedConnectivity::Connected
|
||||
|| *connectivity_lock == DetailedConnectivity::NotConfigured
|
||||
{
|
||||
*connectivity_lock = DetailedConnectivity::InterruptingIdle;
|
||||
}
|
||||
drop(connectivity_lock);
|
||||
|
||||
for state in &[&mvbox, &sentbox] {
|
||||
let mut connectivity_lock = state.0.lock().await;
|
||||
if *connectivity_lock == DetailedConnectivity::Connected {
|
||||
*connectivity_lock = DetailedConnectivity::InterruptingIdle;
|
||||
}
|
||||
}
|
||||
// No need to send ConnectivityChanged, the user-facing connectivity doesn't change because
|
||||
// of what we do here.
|
||||
}
|
||||
|
||||
impl fmt::Debug for ConnectivityStore {
|
||||
fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
|
||||
if let Some(guard) = self.0.try_lock() {
|
||||
write!(f, "ConnectivityStore {:?}", &*guard)
|
||||
} else {
|
||||
write!(f, "ConnectivityStore [LOCKED]")
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
impl Context {
|
||||
/// Get the current connectivity, i.e. whether the device is connected to the IMAP server.
|
||||
/// One of:
|
||||
/// - DC_CONNECTIVITY_NOT_CONNECTED (1000-1999): Show e.g. the string "Not connected" or a red dot
|
||||
/// - DC_CONNECTIVITY_CONNECTING (2000-2999): Show e.g. the string "Connecting…" or a yellow dot
|
||||
/// - DC_CONNECTIVITY_WORKING (3000-3999): Show e.g. the string "Getting new messages" or a spinning wheel
|
||||
/// - DC_CONNECTIVITY_CONNECTED (>=4000): Show e.g. the string "Connected" or a green dot
|
||||
///
|
||||
/// We don't use exact values but ranges here so that we can split up
|
||||
/// states into multiple states in the future.
|
||||
///
|
||||
/// Meant as a rough overview that can be shown
|
||||
/// e.g. in the title of the main screen.
|
||||
///
|
||||
/// If the connectivity changes, a DC_EVENT_CONNECTIVITY_CHANGED will be emitted.
|
||||
pub async fn get_connectivity(&self) -> Connectivity {
|
||||
let lock = self.scheduler.read().await;
|
||||
let stores: Vec<_> = match &*lock {
|
||||
Scheduler::Running {
|
||||
inbox,
|
||||
mvbox,
|
||||
sentbox,
|
||||
..
|
||||
} => [&inbox.state, &mvbox.state, &sentbox.state]
|
||||
.iter()
|
||||
.map(|state| state.connectivity.clone())
|
||||
.collect(),
|
||||
Scheduler::Stopped => return Connectivity::NotConnected,
|
||||
};
|
||||
drop(lock);
|
||||
|
||||
let mut connectivities = Vec::new();
|
||||
for s in stores {
|
||||
if let Some(connectivity) = s.get_basic().await {
|
||||
connectivities.push(connectivity);
|
||||
}
|
||||
}
|
||||
connectivities
|
||||
.into_iter()
|
||||
.min()
|
||||
.unwrap_or(Connectivity::Connected)
|
||||
}
|
||||
|
||||
/// Get an overview of the current connectivity, and possibly more statistics.
|
||||
/// Meant to give the user more insight about the current status than
|
||||
/// the basic connectivity info returned by dc_get_connectivity(); show this
|
||||
/// e.g., if the user taps on said basic connectivity info.
|
||||
///
|
||||
/// If this page changes, a DC_EVENT_CONNECTIVITY_CHANGED will be emitted.
|
||||
///
|
||||
/// This comes as an HTML from the core so that we can easily improve it
|
||||
/// and the improvement instantly reaches all UIs.
|
||||
pub async fn get_connectivity_html(&self) -> String {
|
||||
let mut ret =
|
||||
"<!DOCTYPE html>\n<html><head><meta http-equiv=\"Content-Type\" content=\"text/html; charset=utf-8\" /></head><body>\n".to_string();
|
||||
|
||||
let lock = self.scheduler.read().await;
|
||||
let (folders_states, smtp) = match &*lock {
|
||||
Scheduler::Running {
|
||||
inbox,
|
||||
mvbox,
|
||||
sentbox,
|
||||
smtp,
|
||||
..
|
||||
} => (
|
||||
[
|
||||
(
|
||||
Config::ConfiguredInboxFolder,
|
||||
Config::InboxWatch,
|
||||
inbox.state.connectivity.clone(),
|
||||
),
|
||||
(
|
||||
Config::ConfiguredMvboxFolder,
|
||||
Config::MvboxWatch,
|
||||
mvbox.state.connectivity.clone(),
|
||||
),
|
||||
(
|
||||
Config::ConfiguredSentboxFolder,
|
||||
Config::SentboxWatch,
|
||||
sentbox.state.connectivity.clone(),
|
||||
),
|
||||
],
|
||||
smtp.state.connectivity.clone(),
|
||||
),
|
||||
Scheduler::Stopped => {
|
||||
ret += "Not started</body></html>\n";
|
||||
return ret;
|
||||
}
|
||||
};
|
||||
drop(lock);
|
||||
|
||||
ret += "<div><h3>Incoming messages:</h3><ul>";
|
||||
for (folder, watch, state) in &folders_states {
|
||||
let w = self.get_config(*watch).await.ok_or_log(self);
|
||||
|
||||
let mut folder_added = false;
|
||||
if w.flatten() == Some("1".to_string()) {
|
||||
let f = self.get_config(*folder).await.ok_or_log(self).flatten();
|
||||
|
||||
if let Some(foldername) = f {
|
||||
ret += "<li><b>"";
|
||||
ret += &foldername;
|
||||
ret += "":</b> ";
|
||||
ret += &state.get_detailed().await.to_string_imap(self);
|
||||
ret += "</li>";
|
||||
|
||||
folder_added = true;
|
||||
}
|
||||
}
|
||||
|
||||
if !folder_added && folder == &Config::ConfiguredInboxFolder {
|
||||
let detailed = &state.get_detailed().await;
|
||||
if let DetailedConnectivity::Error(_) = detailed {
|
||||
// On the inbox thread, we also do some other things like scan_folders and run jobs
|
||||
// so, maybe, the inbox is not watched, but something else went wrong
|
||||
ret += "<li>";
|
||||
ret += &detailed.to_string_imap(self);
|
||||
ret += "</li>";
|
||||
}
|
||||
}
|
||||
}
|
||||
ret += "</ul></div>";
|
||||
|
||||
ret += "<h3>Outgoing messages:</h3><ul style=\"list-style-type: none;\"><li>";
|
||||
ret += &smtp.get_detailed().await.to_string_smtp(self);
|
||||
ret += "</li></ul>";
|
||||
|
||||
ret += "</body></html>\n";
|
||||
ret
|
||||
}
|
||||
|
||||
pub async fn all_work_done(&self) -> bool {
|
||||
let lock = self.scheduler.read().await;
|
||||
let stores: Vec<_> = match &*lock {
|
||||
Scheduler::Running {
|
||||
inbox,
|
||||
mvbox,
|
||||
sentbox,
|
||||
smtp,
|
||||
..
|
||||
} => [&inbox.state, &mvbox.state, &sentbox.state, &smtp.state]
|
||||
.iter()
|
||||
.map(|state| state.connectivity.clone())
|
||||
.collect(),
|
||||
Scheduler::Stopped => return false,
|
||||
};
|
||||
drop(lock);
|
||||
|
||||
for s in &stores {
|
||||
if !s.get_all_work_done().await {
|
||||
return false;
|
||||
}
|
||||
}
|
||||
true
|
||||
}
|
||||
}
|
||||
Reference in New Issue
Block a user