[Cleanup] Remove "LifecycleManagement" contracts and processors from Ripple

core/main/src/bootstrap/start_app_manager_step.rs

@@ -18,7 +18,6 @@
 use ripple_sdk::async_trait::async_trait;
 use ripple_sdk::{framework::bootstrap::Bootstep, tokio, utils::error::RippleError};
 
-use crate::processor::lifecycle_management_processor::LifecycleManagementProcessor;
 use crate::{
     service::apps::delegated_launcher_handler::DelegatedLauncherHandler,
     state::bootstrap_state::BootstrapState,
@@ -34,12 +33,6 @@ impl Bootstep<BootstrapState> for StartAppManagerStep {
     }
 
     async fn setup(&self, state: BootstrapState) -> Result<(), RippleError> {
-        state
-            .platform_state
-            .get_client()
-            .add_request_processor(LifecycleManagementProcessor::new(
-                state.platform_state.get_client(),
-            ));
         let mut app_manager =
             DelegatedLauncherHandler::new(state.channels_state, state.platform_state);
         tokio::spawn(async move {

core/main/src/processor/mod.rs

@@ -19,7 +19,6 @@ pub mod app_events_processor;
 pub mod authorized_info_processor;
 pub mod config_processor;
 pub mod keyboard_processor;
-pub mod lifecycle_management_processor;
 pub mod metrics_processor;
 pub mod pin_processor;
 pub mod rpc_gateway_processor;

core/main/src/service/apps/delegated_launcher_handler.rs

@@ -1508,37 +1508,29 @@ impl DelegatedLauncherHandler {
         &mut self,
         event: LifecycleManagementEventRequest,
     ) -> Result<AppManagerResponse, AppError> {
-        if self.platform_state.has_internal_launcher() {
-            if let Err(e) = self.platform_state.get_client().send_event(event) {
-                error!("send event error {:?}", e);
-                return Err(AppError::OsError);
+        let event_name;
+        let value;
+        match event {
+            LifecycleManagementEventRequest::Launch(req) => {
+                event_name = LCM_EVENT_ON_REQUEST_LAUNCH;
+                value = serde_json::to_value(req).unwrap();
             }
-        } else {
-            let event_name;
-            let value;
-            match event {
-                LifecycleManagementEventRequest::Launch(req) => {
-                    event_name = LCM_EVENT_ON_REQUEST_LAUNCH;
-                    value = serde_json::to_value(req).unwrap();
-                }
-                LifecycleManagementEventRequest::Ready(req) => {
-                    event_name = LCM_EVENT_ON_REQUEST_READY;
-                    value = serde_json::to_value(req).unwrap();
-                }
-                LifecycleManagementEventRequest::Close(req) => {
-                    event_name = LCM_EVENT_ON_REQUEST_CLOSE;
-                    value = serde_json::to_value(req).unwrap();
-                }
-                LifecycleManagementEventRequest::Finished(req) => {
-                    event_name = LCM_EVENT_ON_REQUEST_FINISHED;
-                    value = serde_json::to_value(req).unwrap();
-                }
-                _ => return Err(AppError::OsError),
+            LifecycleManagementEventRequest::Ready(req) => {
+                event_name = LCM_EVENT_ON_REQUEST_READY;
+                value = serde_json::to_value(req).unwrap();
             }
-
-            AppEvents::emit(&self.platform_state, event_name, &value).await;
+            LifecycleManagementEventRequest::Close(req) => {
+                event_name = LCM_EVENT_ON_REQUEST_CLOSE;
+                value = serde_json::to_value(req).unwrap();
+            }
+            LifecycleManagementEventRequest::Finished(req) => {
+                event_name = LCM_EVENT_ON_REQUEST_FINISHED;
+                value = serde_json::to_value(req).unwrap();
+            }
+            _ => return Err(AppError::OsError),
         }
 
+        AppEvents::emit(&self.platform_state, event_name, &value).await;
         Ok(AppManagerResponse::None)
     }
 

core/main/src/service/apps/provider_broker.rs

@@ -21,9 +21,6 @@ use ripple_sdk::{
         firebolt::{
             fb_capabilities::{CapEvent, FireboltCap},
             fb_general::ListenRequest,
-            fb_lifecycle_management::{
-                LifecycleManagementEventRequest, LifecycleManagementProviderEvent,
-            },
             fb_openrpc::FireboltOpenRpcMethod,
             provider::{
                 FocusRequest, GenericProviderError, ProviderRequest, ProviderRequestPayload,
@@ -330,16 +327,6 @@ impl ProviderBroker {
         match active_sessions.remove(&resp.correlation_id) {
             Some(session) => {
                 oneshot_send_and_log(session.caller.tx, resp.result, "ProviderResponse");
-                if session.focused {
-                    let app_id = session.provider.provider.app_id;
-                    let event = LifecycleManagementEventRequest::Provide(
-                        LifecycleManagementProviderEvent::Remove(app_id),
-                    );
-                    let client = pst.clone().get_client();
-                    if let Err(e) = client.send_event(event) {
-                        error!("send event error {:?}", e);
-                    }
-                }
             }
             None => {
                 error!("Ignored provider response because there was no active session waiting")
@@ -420,16 +407,6 @@ impl ProviderBroker {
         let mut active_sessions = pst.provider_broker_state.active_sessions.write().unwrap();
         if let Some(session) = active_sessions.get_mut(&request.correlation_id) {
             session.focused = true;
-            if pst.has_internal_launcher() {
-                let app_id = session.provider.provider.app_id.clone();
-                let event = LifecycleManagementEventRequest::Provide(
-                    LifecycleManagementProviderEvent::Add(app_id),
-                );
-                let client = pst.clone().get_client();
-                if let Err(e) = client.send_event(event) {
-                    error!("send event error {:?}", e);
-                }
-            }
         } else {
             warn!("Focus: No active session for request");
         }

core/sdk/src/api/apps.rs

@@ -23,7 +23,7 @@ use tokio::sync::oneshot;
 use uuid::Uuid;
 
 use crate::{
-    extn::extn_client_message::{ExtnEvent, ExtnPayload, ExtnPayloadProvider, ExtnResponse},
+    extn::extn_client_message::{ExtnEvent, ExtnPayload, ExtnPayloadProvider},
     framework::ripple_contract::RippleContract,
     utils::{channel_utils::oneshot_send_and_log, error::RippleError},
 };
@@ -100,42 +100,6 @@ pub struct AppLaunchInfo {
 
 pub type AppResponse = Result<AppManagerResponse, AppError>;
 
-impl ExtnPayloadProvider for AppResponse {
-    fn get_extn_payload(&self) -> ExtnPayload {
-        let response = if self.is_ok() {
-            if let Ok(resp) = self {
-                ExtnResponse::Value(serde_json::to_value(resp.clone()).unwrap())
-            } else {
-                ExtnResponse::None(())
-            }
-        } else {
-            ExtnResponse::Error(RippleError::ProcessorError)
-        };
-
-        ExtnPayload::Response(response)
-    }
-
-    fn get_from_payload(payload: ExtnPayload) -> Option<Self> {
-        if let ExtnPayload::Response(resp) = payload {
-            match resp {
-                ExtnResponse::Value(v) => {
-                    if let Ok(v) = serde_json::from_value(v) {
-                        return Some(Ok(v));
-                    }
-                }
-                ExtnResponse::Error(_) => return Some(Err(AppError::General)),
-                _ => {}
-            }
-        }
-
-        None
-    }
-
-    fn contract() -> RippleContract {
-        RippleContract::LifecycleManagement
-    }
-}
-
 #[derive(Debug, Clone)]
 pub struct AppRequest {
     pub method: AppMethod,
@@ -379,13 +343,6 @@ mod tests {
         assert_eq!(result.unwrap_err(), RippleError::SenderMissing);
     }
 
-    #[test]
-    fn test_extn_payload_provider_for_app_response() {
-        let app_response: AppResponse = Ok(AppManagerResponse::State(LifecycleState::Initializing));
-        let contract_type: RippleContract = RippleContract::LifecycleManagement;
-        test_extn_payload_provider(app_response, contract_type);
-    }
-
     #[test]
     fn test_extn_payload_provider_for_app_event_request() {
         let app_event_request = AppEventRequest::Emit(AppEvent {