src/embedder/flatland_view_provider.h

// Copyright 2022 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_EMBEDDER_FLATLAND_VIEW_PROVIDER_H_
#define SRC_EMBEDDER_FLATLAND_VIEW_PROVIDER_H_

#include <fuchsia/ui/app/cpp/fidl.h>
#include <lib/syslog/global.h>
#include <lib/ui/scenic/cpp/view_identity.h>
#include <lib/ui/scenic/cpp/view_ref_pair.h>

#include <memory>

#include "logging.h"
#include "src/embedder/engine/embedder.h"
#include "src/embedder/flatland_connection.h"
#include "src/embedder/flatland_ids.h"
#include "src/embedder/logging.h"

namespace embedder {

/// Implements ViewProvider by using Flatland to create a view.
class FlatlandViewProvider final : public fuchsia::ui::app::ViewProvider {
 public:
  using PixelRatioCallback = std::function<void(float)>;

  FlatlandViewProvider(FlatlandConnection* flatland_connection, scenic::ViewRefPair view_ref_pair,
                       fuchsia::ui::composition::ViewBoundProtocols flatland_view_protocols)
      : flatland_connection_(flatland_connection),
        flatland_view_protocols_(std::move(flatland_view_protocols)) {
    view_identity_ = {.view_ref = std::move(view_ref_pair.view_ref),
                      .view_ref_control = std::move(view_ref_pair.control_ref)};
    pixel_ratio_callback_ = [](float) {};
  }
  ~FlatlandViewProvider() override {}

  FlatlandViewProvider(const FlatlandViewProvider&) = delete;
  FlatlandViewProvider& operator=(const FlatlandViewProvider&) = delete;

  void CreateView(zx::eventpair token,
                  fidl::InterfaceRequest<fuchsia::sys::ServiceProvider> incoming_services,
                  fidl::InterfaceHandle<fuchsia::sys::ServiceProvider> outgoing_services) override {
    FX_LOG(ERROR, kLogTag, "ViewProvider::CreateView not implemented.");
  }

  void CreateViewWithViewRef(zx::eventpair view_token,
                             fuchsia::ui::views::ViewRefControl control_ref,
                             fuchsia::ui::views::ViewRef view_ref) override {
    FX_LOG(ERROR, kLogTag, "ViewProvider::CreateViewWithViewRef not implemented.");
  }

  void CreateView2(fuchsia::ui::app::CreateView2Args view_args) override {
    auto* flatland = flatland_connection_->flatland();
    flatland->CreateView2(
        std::move(*view_args.mutable_view_creation_token()), std::move(view_identity_),
        std::move(flatland_view_protocols_) /* protocols */, parent_viewport_watcher_.NewRequest());

    flatland->CreateTransform({kRootTransformId});
    flatland->SetRootTransform({kRootTransformId});

    parent_viewport_watcher_->GetLayout(fit::bind_member(this, &FlatlandViewProvider::OnGetLayout));
  }

  void OnGetLayout(fuchsia::ui::composition::LayoutInfo info) {
    if (info.has_device_pixel_ratio()) {
      pixel_ratio_callback_(info.device_pixel_ratio().x);
    }
    parent_viewport_watcher_->GetLayout(fit::bind_member(this, &FlatlandViewProvider::OnGetLayout));
  }

  void SetPixelRatioCallback(PixelRatioCallback callback) { pixel_ratio_callback_ = callback; }

 private:
  FlatlandConnection* flatland_connection_ = nullptr;
  fuchsia::ui::composition::ViewBoundProtocols flatland_view_protocols_;
  fuchsia::ui::views::ViewIdentityOnCreation view_identity_;
  fuchsia::ui::composition::ParentViewportWatcherPtr parent_viewport_watcher_;
  PixelRatioCallback pixel_ratio_callback_;
};

}  // namespace embedder

#endif  // SRC_EMBEDDER_FLATLAND_VIEW_PROVIDER_H_