uwb_core: add reconfigure() method at SessionManager am: 799b12460f am: 8abd2843e6

Original change: https://googleplex-android-review.googlesource.com/c/platform/external/uwb/+/17810504

Change-Id: I7ebbaa6f9ff9c6c876853a95066076323e3f9ba1
Signed-off-by: Automerger Merge Worker <android-build-automerger-merge-worker@system.gserviceaccount.com>

2 files changed, 61 insertions, 20 deletions

diff --git a/src/rust/uwb_core/src/session/session_manager.rs b/src/rust/uwb_core/src/session/session_manager.rs
index 3f1bec9..352b2f8 100644
--- a/src/rust/uwb_core/src/session/session_manager.rs
+++ b/src/rust/uwb_core/src/session/session_manager.rs
@@ -72,6 +72,10 @@ impl SessionManager {
         self.send_cmd(SessionCommand::StopRanging { session_id }).await
     }
 
+    async fn reconfigure(&mut self, session_id: SessionId, params: AppConfigParams) -> Result<()> {
+        self.send_cmd(SessionCommand::Reconfigure { session_id, params }).await
+    }
+
     // Send the |cmd| to the SessionManagerActor.
     async fn send_cmd(&self, cmd: SessionCommand) -> Result<()> {
         let (result_sender, result_receiver) = oneshot::channel();
@@ -183,6 +187,16 @@ impl<T: UciManager> SessionManagerActor<T> {
                     }
                 }
             }
+            SessionCommand::Reconfigure { session_id, params } => {
+                match self.active_sessions.get_mut(&session_id) {
+                    None => {
+                        let _ = result_sender.send(Err(Error::UnknownSessionId(session_id)));
+                    }
+                    Some(session) => {
+                        session.reconfigure(params, result_sender);
+                    }
+                }
+            }
         }
     }
 
@@ -218,6 +232,7 @@ enum SessionCommand {
     DeinitSession { session_id: SessionId },
     StartRanging { session_id: SessionId },
     StopRanging { session_id: SessionId },
+    Reconfigure { session_id: SessionId, params: AppConfigParams },
 }
 
 #[cfg(test)]
diff --git a/src/rust/uwb_core/src/session/uwb_session.rs b/src/rust/uwb_core/src/session/uwb_session.rs
index 66b5fd6..def964f 100644
--- a/src/rust/uwb_core/src/session/uwb_session.rs
+++ b/src/rust/uwb_core/src/session/uwb_session.rs
@@ -72,6 +72,14 @@ impl UwbSession {
         let _ = self.cmd_sender.send((Command::StopRanging, result_sender));
     }
 
+    pub fn reconfigure(
+        &mut self,
+        params: AppConfigParams,
+        result_sender: oneshot::Sender<Result<()>>,
+    ) {
+        let _ = self.cmd_sender.send((Command::Reconfigure { params }, result_sender));
+    }
+
     pub fn set_state(&mut self, state: SessionState) {
         let _ = self.state_sender.send(state);
     }
@@ -83,6 +91,7 @@ struct UwbSessionActor<T: UciManager> {
     uci_manager: T,
     session_id: SessionId,
     session_type: SessionType,
+    params: Option<AppConfigParams>,
 }
 
 impl<T: UciManager> UwbSessionActor<T> {
@@ -93,7 +102,7 @@ impl<T: UciManager> UwbSessionActor<T> {
         session_id: SessionId,
         session_type: SessionType,
     ) -> Self {
-        Self { cmd_receiver, state_receiver, uci_manager, session_id, session_type }
+        Self { cmd_receiver, state_receiver, uci_manager, session_id, session_type, params: None }
     }
 
     async fn run(&mut self) {
@@ -111,6 +120,7 @@ impl<T: UciManager> UwbSessionActor<T> {
                                 Command::Deinitialize => self.deinitialize().await,
                                 Command::StartRanging => self.start_ranging().await,
                                 Command::StopRanging => self.stop_ranging().await,
+                                Command::Reconfigure { params } => self.reconfigure(params).await,
                             };
                             let _ = result_sender.send(result);
                         }
@@ -121,31 +131,15 @@ impl<T: UciManager> UwbSessionActor<T> {
     }
 
     async fn initialize(&mut self, params: AppConfigParams) -> Result<()> {
+        debug_assert!(*self.state_receiver.borrow() == SessionState::SessionStateDeinit);
+
         if let Err(e) = self.uci_manager.session_init(self.session_id, self.session_type).await {
             error!("Failed to initialize session: {:?}", e);
             return Err(Error::Uci);
         }
         self.wait_state(SessionState::SessionStateInit).await?;
 
-        let tlvs = params.generate_tlvs();
-        match self.uci_manager.session_set_app_config(self.session_id, tlvs).await {
-            Ok(result) => {
-                for config_status in result.config_status.iter() {
-                    warn!(
-                        "AppConfig {:?} is not applied: {:?}",
-                        config_status.cfg_id, config_status.status
-                    );
-                }
-                if result.status != StatusCode::UciStatusOk {
-                    error!("Failed to set app_config. StatusCode: {:?}", result.status);
-                    return Err(Error::Uci);
-                }
-            }
-            Err(e) => {
-                error!("Failed to set app_config: {:?}", e);
-                return Err(Error::Uci);
-            }
-        }
+        self.reconfigure(params).await?;
         self.wait_state(SessionState::SessionStateIdle).await?;
 
         Ok(())
@@ -205,6 +199,37 @@ impl<T: UciManager> UwbSessionActor<T> {
         }
     }
 
+    async fn reconfigure(&mut self, params: AppConfigParams) -> Result<()> {
+        debug_assert!(*self.state_receiver.borrow() != SessionState::SessionStateDeinit);
+
+        let tlvs = match self.params.as_ref() {
+            Some(prev_params) => params.generate_updated_tlvs(prev_params),
+            None => params.generate_tlvs(),
+        };
+
+        match self.uci_manager.session_set_app_config(self.session_id, tlvs).await {
+            Ok(result) => {
+                for config_status in result.config_status.iter() {
+                    warn!(
+                        "AppConfig {:?} is not applied: {:?}",
+                        config_status.cfg_id, config_status.status
+                    );
+                }
+                if result.status != StatusCode::UciStatusOk {
+                    error!("Failed to set app_config. StatusCode: {:?}", result.status);
+                    return Err(Error::Uci);
+                }
+            }
+            Err(e) => {
+                error!("Failed to set app_config: {:?}", e);
+                return Err(Error::Uci);
+            }
+        }
+
+        self.params = Some(params);
+        Ok(())
+    }
+
     async fn wait_state(&mut self, expected_state: SessionState) -> Result<()> {
         const WAIT_STATE_TIMEOUT_MS: u64 = 1000;
         match timeout(Duration::from_millis(WAIT_STATE_TIMEOUT_MS), self.state_receiver.changed())
@@ -240,4 +265,5 @@ enum Command {
     Deinitialize,
     StartRanging,
     StopRanging,
+    Reconfigure { params: AppConfigParams },
 }