Logout without Exit

avam-client/src/app.rs

@@ -27,7 +27,7 @@ impl App {
         let mut tray_icon = TrayIcon::new(load_icon(), crate::PROJECT_NAME);
 
         let login = MenuItem::new("Login", true, None);
-        let forget = MenuItem::new("Logout and Exit", false, None);
+        let forget = MenuItem::new("Logout", false, None);
         let quit = MenuItem::new("Exit", true, None);
 
         let mut items = HashMap::new();
@@ -49,17 +49,19 @@ impl App {
             Ok(())
         })?;
 
-        tray_icon.add_seperator()?;
-
         let c = config.clone();
         let s = sender.clone();
         let forget_id = tray_icon.add_menu_item(&forget, move |_| {
             c.set_token(None)?;
-            s.send(Event::Quit)?;
+            c.set_open_browser(false)?;
+
+            let _ = s.send(Event::Ready { config: c.clone() });
 
             Ok(())
         })?;
 
+        tray_icon.add_seperator()?;
+
         let s = sender.clone();
         tray_icon.add_menu_item(&quit, move |_| {
             s.send(Event::Quit)?;
@@ -91,9 +93,14 @@ impl ApplicationHandler for App {
 
         if let Ok(event) = self.receiver.try_recv() {
             match event {
-                Event::Quit => {
+                Event::Ready { .. } => {
-                    println!("Shutting down EventLoop");
+                    self.tray_icon
-                    event_loop.exit()
+                        .set_text(self.items.get("login").unwrap(), "Login")
+                        .unwrap();
+
+                    self.tray_icon
+                        .set_enabled(self.items.get("forget").unwrap(), false)
+                        .unwrap();
                 }
                 Event::TokenReceived { .. } => {
                     self.tray_icon
@@ -104,6 +111,10 @@ impl ApplicationHandler for App {
                         .set_enabled(self.items.get("forget").unwrap(), true)
                         .unwrap();
                 }
+                Event::Quit => {
+                    println!("Shutting down EventLoop");
+                    event_loop.exit()
+                }
                 _ => {}
             }
         }

avam-client/src/config.rs

@@ -11,7 +11,7 @@ use crate::{
     models::{CodeChallengeMethod, CodeVerifier},
 };
 
-#[derive(Default, Debug, Clone, Serialize, Deserialize)]
+#[derive(Debug, Clone, Serialize, Deserialize)]
 pub struct Config {
     #[serde(with = "arc_rwlock_serde")]
     token: Arc<RwLock<Option<String>>>,
@@ -19,6 +19,19 @@ pub struct Config {
     code_verifier: Arc<RwLock<Option<CodeVerifier>>>,
     #[serde(skip)]
     code_challenge_method: Arc<RwLock<Option<CodeChallengeMethod>>>,
+    #[serde(skip)]
+    open_browser: Arc<RwLock<bool>>,
+}
+
+impl Default for Config {
+    fn default() -> Self {
+        Self {
+            token: Default::default(),
+            code_verifier: Default::default(),
+            code_challenge_method: Default::default(),
+            open_browser: Arc::new(RwLock::new(true)),
+        }
+    }
 }
 
 impl PartialEq for Config {
@@ -77,6 +90,17 @@ impl Config {
     }
 }
 
+impl Config {
+    pub fn open_browser(&self) -> bool {
+        *self.open_browser.read().unwrap()
+    }
+
+    pub fn set_open_browser(&self, value: bool) -> Result<(), ConfigError> {
+        *self.open_browser.write().unwrap() = value;
+        Ok(())
+    }
+}
+
 impl Config {
     pub(crate) fn new() -> Result<Self, ConfigError> {
         let config = config::Config::builder()

avam-client/src/state_machine.rs

@@ -13,6 +13,7 @@ pub enum State {
         config: Config,
     },
     Authenticate {
+        open_browser: bool,
         code_verifier: CodeVerifier,
         code_challenge_method: CodeChallengeMethod,
     },
@@ -29,6 +30,7 @@ pub enum Event {
         config: Config,
     },
     StartAuthenticate {
+        open_browser: bool,
         code_verifier: CodeVerifier,
         code_challenge_method: CodeChallengeMethod,
     }, // should not be string
@@ -46,15 +48,17 @@ impl State {
     pub async fn next(self, event: Event) -> State {
         match (self, event) {
             // (Current State, SomeEvent) => NextState
-            (State::Init, Event::Ready { config }) => State::AppStart { config },
+            (_, Event::Ready { config }) => State::AppStart { config },
             (
                 State::AppStart { .. },
                 Event::StartAuthenticate {
-                    code_verifier: code_challenge,
+                    open_browser,
+                    code_verifier,
                     code_challenge_method,
                 },
             ) => Self::Authenticate {
-                code_verifier: code_challenge,
+                open_browser,
+                code_verifier,
                 code_challenge_method,
             }, // Goto Authenticate
 
@@ -85,6 +89,7 @@ impl State {
                         token: token.to_string(),
                     })?;
                 } else {
+                    let open_browser = config.open_browser();
                     let code_verifier = CodeVerifier::new();
                     let code_challenge_method = CodeChallengeMethod::Sha256;
 
@@ -92,6 +97,7 @@ impl State {
                     config.set_code_challenge_method(Some(code_challenge_method.clone()))?;
 
                     signal.send(Event::StartAuthenticate {
+                        open_browser,
                         code_verifier,
                         code_challenge_method,
                     })?;
@@ -99,10 +105,13 @@ impl State {
                 Ok(())
             }
             State::Authenticate {
+                open_browser,
                 code_verifier,
                 code_challenge_method,
             } => {
-                oauth::open_browser(code_verifier.clone(), code_challenge_method.clone())?;
+                if *open_browser {
+                    oauth::open_browser(code_verifier.clone(), code_challenge_method.clone())?;
+                }
 
                 Ok(())
             }