blob: 726da831515cc04b810c72d015590495ea25d1d6 [file] [log] [blame]
// Copyright 2016 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.
#include "peridot/bin/sessionmgr/story_runner/module_controller_impl.h"
#include <fuchsia/ui/app/cpp/fidl.h>
#include <lib/async/cpp/task.h>
#include <lib/async/default.h>
#include <lib/fidl/cpp/interface_handle.h>
#include <lib/fidl/cpp/interface_ptr.h>
#include <lib/fidl/cpp/interface_request.h>
#include <src/lib/fxl/logging.h>
#include <src/lib/fxl/time/time_delta.h>
#include "peridot/bin/sessionmgr/story_runner/story_controller_impl.h"
#include "peridot/lib/common/teardown.h"
#include "peridot/lib/fidl/clone.h"
namespace modular {
constexpr char kAppStoragePath[] = "/data/APP_DATA";
namespace {
// A stopgap solution to map a module's url to a directory name where the
// module's /data is mapped. We need three properties here - (1) two module urls
// that are the same get mapped to the same hash, (2) two modules urls that are
// different don't get the same name (with very high probability) and (3) the
// name is visually inspectable.
std::string HashModuleUrl(const std::string& module_url) {
std::size_t found = module_url.find_last_of('/');
auto last_part =
found == module_url.length() - 1 ? "" : module_url.substr(found + 1);
return std::to_string(std::hash<std::string>{}(module_url)) + last_part;
}; // namespace
StoryControllerImpl* const story_controller_impl,
fuchsia::sys::Launcher* const launcher,
fuchsia::modular::AppConfig module_config,
const fuchsia::modular::ModuleData* const module_data,
fuchsia::sys::ServiceListPtr service_list,
fuchsia::ui::views::ViewToken view_token)
: story_controller_impl_(story_controller_impl),
launcher, CloneStruct(module_config),
std::string(kAppStoragePath) + HashModuleUrl(module_config.url),
module_data_(module_data) {
app_client_.SetAppErrorHandler([this] { OnAppConnectionError(); });
fuchsia::ui::app::ViewProviderPtr view_provider;;
nullptr /* incoming_services */,
nullptr /* outgoing_services */);
ModuleControllerImpl::~ModuleControllerImpl() {}
void ModuleControllerImpl::Connect(
fidl::InterfaceRequest<fuchsia::modular::ModuleController> request) {
module_controller_bindings_.AddBinding(this, std::move(request));
// Notify of initial state on connection.
// If the ComponentController connection closes, it means the module cannot be
// started. We indicate this by the ERROR state.
void ModuleControllerImpl::OnAppConnectionError() {
void ModuleControllerImpl::SetState(
const fuchsia::modular::ModuleState new_state) {
if (state_ == new_state) {
state_ = new_state;
void ModuleControllerImpl::Teardown(fit::function<void()> done) {
if (teardown_done_callbacks_.size() != 1) {
// Not the first request, Stop() in progress.
fit::function<void()> cont = [this] {
// We take ownership of *this from |story_controller_impl_| so that
// teardown happens in StoryControllerImpl but *this is still alive when we
// call |teardown_done_callbacks_|. One or more of the callbacks may be a
// result callback for fuchsia::modular::ModuleController::Stop() and since
// *this owns the fidl::Binding for the channel on which the result message
// will be sent, it must be alive when the message is posted.
// TODO(thatguy,mesch): This point is reachable from two distinct
// code-paths: originating from ModuleControllerImpl::Stop() or
// StoryControllerImpl::Stop(). It is not clear whether ReleaseModule()
// must be called *before* these done callbacks are called, or whether we
// can move this call below the loop and have ReleaseModule also delete
// *this.
for (auto& done : teardown_done_callbacks_) {
// |this| must be deleted after the callbacks so that the |done()| calls
// above can be dispatched while the bindings still exist in case they are
// FIDL method callbacks.
// The destructor of |this| deletes |app_client_|, which will kill the
// related application if it's still running.
delete this;
// At this point, it's no longer an error if the module closes its
// connection, or the application exits.
// Tear down the module application through the normal procedure with timeout.
app_client_.Teardown(kBasicTimeout, std::move(cont));
void ModuleControllerImpl::Focus() {
void ModuleControllerImpl::Defocus() {
void ModuleControllerImpl::Stop(StopCallback done) {
void ModuleControllerImpl::NotifyStateChange() {
for (auto& binding : module_controller_bindings_.bindings()) {
} // namespace modular