garnet/examples/ui/tile/tile_view.cc

// Copyright 2015 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 "garnet/examples/ui/tile/tile_view.h"

#include <fuchsia/math/cpp/fidl.h>
#include <lib/async/default.h>
#include <lib/fdio/directory.h>
#include <lib/fdio/fd.h>
#include <lib/fdio/fdio.h>
#include <lib/fidl/cpp/optional.h>
#include <lib/svc/cpp/services.h>
#include <lib/ui/base_view/cpp/embedded_view_utils.h>
#include <lib/ui/scenic/cpp/view_token_pair.h>
#include <src/lib/fxl/logging.h>
#include <src/lib/fxl/strings/split_string.h>

namespace examples {

TileView::TileView(scenic::ViewContext context, TileParams params)
    : BaseView(std::move(context), "Tile"),
      vfs_(async_get_default_dispatcher()),
      services_dir_(fbl::AdoptRef(new fs::PseudoDir())),
      params_(std::move(params)),
      container_node_(session()) {
  root_node().AddChild(container_node_);
  CreateNestedEnvironment();
  ConnectViews();
}

void TileView::PresentView(
    fuchsia::ui::views::ViewHolderToken view_holder_token,
    fidl::InterfaceRequest<fuchsia::ui::policy::Presentation> presentation) {
  AddChildView("tile_view child(Presented view)", std::move(view_holder_token),
               nullptr);
}

void TileView::ConnectViews() {
  for (const auto& url : params_.view_urls) {
    component::Services services;
    fuchsia::sys::ComponentControllerPtr controller;

    fuchsia::sys::LaunchInfo launch_info;

    // Pass arguments to children, if there are any.
    std::vector<std::string> split_url = fxl::SplitStringCopy(
        url, " ", fxl::kTrimWhitespace, fxl::kSplitWantNonEmpty);
    FXL_CHECK(split_url.size() >= 1);
    launch_info.url = split_url[0];
    launch_info.directory_request = services.NewRequest();

    if (split_url.size() > 1) {
      launch_info.arguments = fidl::VectorPtr<std::string>::New(0);
      for (auto it = split_url.begin() + 1; it != split_url.end(); it++) {
        launch_info.arguments.push_back(*it);
      }
    }

    // |env_launcher_| launches the component with our nested environment.
    env_launcher_->CreateComponent(std::move(launch_info),
                                   controller.NewRequest());

    // Create a View from the launched component.
    auto [view_token, view_holder_token] = scenic::ViewTokenPair::New();

    auto view_provider =
        services.ConnectToService<fuchsia::ui::app::ViewProvider>();
    view_provider->CreateView(std::move(view_token.value), nullptr, nullptr);

    // Add the view.
    AddChildView("tile_view child(" + split_url[0] + ")",
                 std::move(view_holder_token), std::move(controller));
  }
}

zx::channel TileView::OpenAsDirectory() {
  zx::channel h1, h2;
  if (zx::channel::create(0, &h1, &h2) != ZX_OK)
    return zx::channel();
  if (vfs_.ServeDirectory(services_dir_, std::move(h1)) != ZX_OK)
    return zx::channel();
  return h2;
}

void TileView::CreateNestedEnvironment() {
  // Add a binding for the presenter service
  auto service = fbl::AdoptRef(new fs::Service([this](zx::channel channel) {
    presenter_bindings_.AddBinding(
        this, fidl::InterfaceRequest<fuchsia::ui::policy::Presenter>(
                  std::move(channel)));
    return ZX_OK;
  }));
  services_dir_->AddEntry(fuchsia::ui::policy::Presenter::Name_, service);

  fuchsia::sys::ServiceListPtr service_list(new fuchsia::sys::ServiceList);
  service_list->names.push_back(fuchsia::ui::policy::Presenter::Name_);
  service_list->host_directory = OpenAsDirectory();
  startup_context()->environment()->CreateNestedEnvironment(
      env_.NewRequest(), env_controller_.NewRequest(), "tile",
      std::move(service_list), {.inherit_parent_services = true});
  env_->GetLauncher(env_launcher_.NewRequest());
}

void TileView::OnChildAttached(uint32_t view_holder_id) {
  auto it = views_.find(view_holder_id);
  FXL_DCHECK(it != views_.end());
}

void TileView::OnChildUnavailable(uint32_t view_holder_id) {
  FXL_LOG(ERROR) << "View died unexpectedly: view_holder_id=" << view_holder_id;
  RemoveChildView(view_holder_id);
}

void TileView::OnScenicEvent(fuchsia::ui::scenic::Event event) {
  switch (event.Which()) {
    case ::fuchsia::ui::scenic::Event::Tag::kGfx:
      switch (event.gfx().Which()) {
        case ::fuchsia::ui::gfx::Event::Tag::kViewConnected: {
          auto& evt = event.gfx().view_connected();
          OnChildAttached(evt.view_holder_id);
          break;
        }
        case ::fuchsia::ui::gfx::Event::Tag::kViewDisconnected: {
          auto& evt = event.gfx().view_disconnected();
          OnChildUnavailable(evt.view_holder_id);
          break;
        }
        default:
          break;
      }
    default:
      break;
  }
}

void TileView::AddChildView(
    std::string label, fuchsia::ui::views::ViewHolderToken view_holder_token,
    fuchsia::sys::ComponentControllerPtr controller) {
  auto view_data = std::make_unique<ViewData>(
      label, std::move(view_holder_token), std::move(controller), session());

  container_node_.AddChild(view_data->host_node);

  view_data->host_node.AddPart(view_data->clip_shape_node);
  view_data->host_node.SetClip(0, true);
  view_data->host_node.Attach(view_data->view_holder);

  views_.emplace(view_data->view_holder.id(), std::move(view_data));

  InvalidateScene();
}

void TileView::RemoveChildView(uint32_t view_holder_id) {
  auto it = views_.find(view_holder_id);
  FXL_DCHECK(it != views_.end());

  it->second->host_node.Detach();
  views_.erase(it);

  InvalidateScene();
}

void TileView::OnSceneInvalidated(
    fuchsia::images::PresentationInfo presentation_info) {
  if (!has_logical_size() || views_.empty())
    return;

  // Layout all children in a row.
  const bool vertical =
      (params_.orientation_mode == TileParams::OrientationMode::kVertical);

  uint32_t index = 0;
  uint32_t space = vertical ? logical_size().y : logical_size().x;
  uint32_t base = space / views_.size();
  uint32_t excess = space % views_.size();
  uint32_t offset = 0;
  for (auto it = views_.begin(); it != views_.end(); ++it, ++index) {
    ViewData* view_data = it->second.get();

    // Distribute any excess width among the leading children.
    uint32_t extent = base;
    if (excess) {
      extent++;
      excess--;
    }

    fuchsia::math::RectF layout_bounds;
    if (vertical) {
      layout_bounds.x = 0;
      layout_bounds.y = offset;
      layout_bounds.width = logical_size().x;
      layout_bounds.height = extent;
    } else {
      layout_bounds.x = offset;
      layout_bounds.y = 0;
      layout_bounds.width = extent;
      layout_bounds.height = logical_size().y;
    }
    offset += extent;

    if (view_data->width != layout_bounds.width ||
        view_data->height != layout_bounds.height) {
      view_data->width = layout_bounds.width;
      view_data->height = layout_bounds.height;
      view_data->view_holder.SetViewProperties(0, 0, 0, view_data->width,
                                               view_data->height, 1000.f, 0, 0,
                                               0, 0, 0, 0);
    }

    view_data->host_node.SetTranslation(layout_bounds.x, layout_bounds.y, 0u);

    // Clip
    scenic::Rectangle shape(session(),            // session
                            layout_bounds.width,  // width
                            layout_bounds.height  // height
    );
    view_data->clip_shape_node.SetShape(shape);
    view_data->clip_shape_node.SetTranslation(layout_bounds.width * 0.5f,
                                              layout_bounds.height * 0.5f, 0.f);
  }
}

TileView::ViewData::ViewData(
    std::string label, fuchsia::ui::views::ViewHolderToken view_holder_token,
    fuchsia::sys::ComponentControllerPtr controller, scenic::Session* session)
    : controller(std::move(controller)),
      host_node(session),
      clip_shape_node(session),
      view_holder(session, std::move(view_holder_token), label) {}

}  // namespace examples