| // Copyright 2018 The Fuchsia Authors. All rights reserved. |
| // Use of this source code is governed by a BSD-style license that can be |
| // found in the LICENSE file. |
| |
| #ifndef SRC_MODULAR_BIN_BASEMGR_BASEMGR_IMPL_H_ |
| #define SRC_MODULAR_BIN_BASEMGR_BASEMGR_IMPL_H_ |
| |
| #include <fuchsia/hardware/power/statecontrol/cpp/fidl.h> |
| #include <fuchsia/modular/cpp/fidl.h> |
| #include <fuchsia/modular/internal/cpp/fidl.h> |
| #include <fuchsia/modular/session/cpp/fidl.h> |
| #include <fuchsia/process/lifecycle/cpp/fidl.h> |
| #include <fuchsia/sys/cpp/fidl.h> |
| #include <fuchsia/ui/lifecycle/cpp/fidl.h> |
| #include <fuchsia/ui/policy/cpp/fidl.h> |
| #include <lib/async/cpp/executor.h> |
| #include <lib/fidl/cpp/binding.h> |
| #include <lib/fit/function.h> |
| #include <lib/fit/promise.h> |
| #include <lib/svc/cpp/service_namespace.h> |
| |
| #include <optional> |
| |
| #include "src/lib/fxl/macros.h" |
| #include "src/modular/bin/basemgr/cobalt/cobalt.h" |
| #include "src/modular/bin/basemgr/presentation_container.h" |
| #include "src/modular/bin/basemgr/session_provider.h" |
| #include "src/modular/lib/async/cpp/future.h" |
| #include "src/modular/lib/modular_config/modular_config_accessor.h" |
| |
| namespace modular { |
| |
| class LauncherImpl; |
| |
| // Basemgr is the parent process of the modular framework, and it is started by |
| // the sysmgr as part of the boot sequence. |
| // |
| // It has several high-level responsibilities: |
| // 1) Initializes and owns the system's root view and presentation. |
| // 2) Manages the lifecycle of sessions, represented as |sessionmgr| processes. |
| class BasemgrImpl : public fuchsia::modular::Lifecycle, |
| public fuchsia::process::lifecycle::Lifecycle, |
| fuchsia::modular::internal::BasemgrDebug, |
| modular::SessionProvider::Delegate { |
| public: |
| using LauncherBinding = |
| fidl::Binding<fuchsia::modular::session::Launcher, std::unique_ptr<LauncherImpl>>; |
| |
| using LauncherBindingSet = |
| fidl::BindingSet<fuchsia::modular::session::Launcher, std::unique_ptr<LauncherImpl>>; |
| |
| enum class State { |
| // normal mode of operation |
| RUNNING, |
| // basemgr is shutting down. |
| SHUTTING_DOWN |
| }; |
| |
| // Creates a BasemgrImpl instance with the given parameters: |
| // |
| // |config_accessor| Contains configuration for starting sessions. |
| // This is normally read from files in basemgr's /config/data directory. |
| // |launcher| Environment service for creating component instances. |
| // |presenter| Service to initialize the presentation. |
| // |on_shutdown| Callback invoked when this basemgr instance is shutdown. |
| explicit BasemgrImpl(modular::ModularConfigAccessor config_accessor, |
| std::shared_ptr<sys::ServiceDirectory> incoming_services, |
| std::shared_ptr<sys::OutgoingDirectory> outgoing_services, |
| fuchsia::sys::LauncherPtr launcher, |
| fuchsia::ui::policy::PresenterPtr presenter, |
| fuchsia::hardware::power::statecontrol::AdminPtr device_administrator, |
| fit::function<void()> on_shutdown); |
| |
| ~BasemgrImpl() override; |
| |
| void Connect(fidl::InterfaceRequest<fuchsia::modular::internal::BasemgrDebug> request); |
| |
| // |fuchsia::modular::Lifecycle| |
| void Terminate() override; |
| |
| // |fuchsia::process::lifecycle::Lifecycle| |
| void Stop() override; |
| |
| // Launches sessionmgr with the given |config|. |
| void LaunchSessionmgr(fuchsia::modular::session::ModularConfig config, |
| fuchsia::sys::ServiceList services_from_session_launcher); |
| |
| State state() const { return state_; } |
| |
| private: |
| using StartSessionResult = fit::result<void, zx_status_t>; |
| |
| // Stops the Scenic component. |
| // |
| // Resolves to an zx_status_t error if Scenic's lifecycle control channel closes for a reason |
| // other than ZX_ERR_PEER_CLOSED. |
| fit::promise<void, zx_status_t> StopScenic(); |
| |
| // Starts the session launcher component, if configured, or starts a session using the |
| // configuration read from |config_accessor_|. |
| void Start(); |
| |
| // Shuts down the session, session launcher component, and Scenic, if any are running. |
| void Shutdown() override; |
| |
| // Starts a new session. |
| // |
| // Requires that |session_provider_| exists but is not running a session. |
| // |
| // Returns |ZX_ERR_BAD_STATE| if basemgr is shutting down, |session_provider_| does not exist, |
| // or a session is already running. |
| StartSessionResult StartSession(); |
| |
| // |BasemgrDebug| |
| void RestartSession(RestartSessionCallback on_restart_complete) override; |
| |
| // |BasemgrDebug| |
| void StartSessionWithRandomId() override; |
| |
| // |SessionProvider::Delegate| |
| void GetPresentation(fidl::InterfaceRequest<fuchsia::ui::policy::Presentation> request) override; |
| |
| // Starts the session launcher component defined in the default basemgr configuration. |
| void StartSessionLauncherComponent(); |
| |
| // Creates a |session_provider_| that uses the given config. If |
| // |services_from_session_launcher| is populated all listed services will be |
| // provided to agent children of sessionmgr. |
| // |
| // |config_accessor| must live for the duration of the session, outliving |session_provider_|. |
| void CreateSessionProvider(const ModularConfigAccessor* config_accessor, |
| fuchsia::sys::ServiceList services_from_session_launcher); |
| |
| // Returns a service list for serving |fuchsia.modular.session.Launcher| to the session |
| // launcher component, served from |session_launcher_component_service_dir_|. |
| fuchsia::sys::ServiceListPtr CreateAndServeSessionLauncherComponentServices(); |
| |
| // Contains initial basemgr and sessionmgr configuration. |
| modular::ModularConfigAccessor config_accessor_; |
| |
| // Contains configuration passed in via |Launcher.LaunchSessionmgr| |
| std::unique_ptr<modular::ModularConfigAccessor> launch_sessionmgr_config_accessor_; |
| |
| // Retained to be used in creating a `SessionProvider`. |
| const std::shared_ptr<sys::ServiceDirectory> component_context_services_; |
| |
| // Used to export protocols like Lifecycle |
| const std::shared_ptr<sys::OutgoingDirectory> outgoing_services_; |
| |
| // Used to launch component instances. |
| fuchsia::sys::LauncherPtr launcher_; |
| // Used to delete isolated storage for legacy sessions with random IDs. |
| // TODO(fxbug.dev/51752): Remove once there are no sessions with random IDs in use |
| fuchsia::sys::EnvironmentPtr base_environment_; |
| // Used to connect the |presentation_container_| to scenic. |
| fuchsia::ui::policy::PresenterPtr presenter_; |
| // Used to trigger device reboot. |
| fuchsia::hardware::power::statecontrol::AdminPtr device_administrator_; |
| fit::function<void()> on_shutdown_; |
| |
| // Holds the presentation service. |
| std::unique_ptr<PresentationContainer> presentation_container_; |
| |
| LauncherBindingSet session_launcher_bindings_; |
| fidl::BindingSet<fuchsia::modular::Lifecycle> lifecycle_bindings_; |
| fidl::BindingSet<fuchsia::modular::internal::BasemgrDebug> basemgr_debug_bindings_; |
| fidl::BindingSet<fuchsia::process::lifecycle::Lifecycle> process_lifecycle_bindings_; |
| |
| fuchsia::ui::lifecycle::LifecycleControllerPtr scenic_lifecycle_controller_; |
| |
| AsyncHolder<SessionProvider> session_provider_; |
| |
| std::unique_ptr<AppClient<fuchsia::modular::Lifecycle>> session_launcher_component_app_; |
| |
| // Service directory from which |fuchsia.modular.session.Launcher| is served to |
| // session launcher components. |
| vfs::PseudoDir session_launcher_component_service_dir_; |
| |
| async::Executor executor_; |
| |
| State state_ = State::RUNNING; |
| |
| FXL_DISALLOW_COPY_AND_ASSIGN(BasemgrImpl); |
| }; |
| |
| } // namespace modular |
| |
| #endif // SRC_MODULAR_BIN_BASEMGR_BASEMGR_IMPL_H_ |