src/ui/tests/conformance_input_tests/key-validator.cc

// Copyright 2024 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 <fidl/fuchsia.ui.display.singleton/cpp/fidl.h>
#include <fidl/fuchsia.ui.focus/cpp/fidl.h>
#include <fidl/fuchsia.ui.input3/cpp/fidl.h>
#include <fidl/fuchsia.ui.test.conformance/cpp/fidl.h>
#include <fidl/fuchsia.ui.test.input/cpp/fidl.h>
#include <fidl/fuchsia.ui.test.scene/cpp/fidl.h>
#include <fidl/fuchsia.ui.views/cpp/fidl.h>
#include <lib/component/incoming/cpp/protocol.h>
#include <lib/fidl/cpp/channel.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/ui/scenic/cpp/view_creation_tokens.h>
#include <lib/ui/scenic/cpp/view_ref_pair.h>

#include <optional>
#include <string>
#include <utility>
#include <vector>

#include <src/lib/fsl/handles/object_info.h>
#include <src/ui/testing/util/fidl_cpp_helpers.h>
#include <src/ui/tests/conformance_input_tests/conformance-test-base.h>
#include <zxtest/zxtest.h>

namespace ui_conformance_testing {

const std::string PUPPET_UNDER_TEST_FACTORY_SERVICE = "/svc/puppet-under-test-factory-service";
const std::string AUXILIARY_PUPPET_FACTORY_SERVICE = "/svc/auxiliary-puppet-factory-service";

namespace futi = fuchsia_ui_test_input;
namespace futc = fuchsia_ui_test_conformance;
namespace fui = fuchsia_ui_input3;
namespace fuv = fuchsia_ui_views;
namespace fuf = fuchsia_ui_focus;

class FocusListener : public fidl::Server<fuf::FocusChainListener> {
 public:
  // |fuchsia_ui_focus::FocusChainListener|
  void OnFocusChange(OnFocusChangeRequest& request,
                     OnFocusChangeCompleter::Sync& completer) override {
    focus_chain_updates_.push_back(std::move(request.focus_chain()));
    completer.Reply();
  }

  fidl::ClientEnd<fuf::FocusChainListener> ServeAndGetClientEnd(async_dispatcher_t* dispatcher) {
    auto [client_end, server_end] = fidl::Endpoints<fuf::FocusChainListener>::Create();
    binding_.AddBinding(dispatcher, std::move(server_end), this, fidl::kIgnoreBindingClosure);
    return std::move(client_end);
  }

  bool IsViewFocused(const fuv::ViewRef& view_ref) const {
    if (focus_chain_updates_.empty()) {
      return false;
    }

    const auto& last_focus_chain = focus_chain_updates_.back();

    if (!last_focus_chain.focus_chain().has_value()) {
      return false;
    }

    if (last_focus_chain.focus_chain()->empty()) {
      return false;
    }

    // the new focus view store at the last slot.
    return fsl::GetKoid(last_focus_chain.focus_chain()->back().reference().get()) ==
           fsl::GetKoid(view_ref.reference().get());
  }

  const std::vector<fuf::FocusChain>& focus_chain_updates() const { return focus_chain_updates_; }

 private:
  fidl::ServerBindingGroup<fuf::FocusChainListener> binding_;
  std::vector<fuf::FocusChain> focus_chain_updates_;
};

class KeyListener : public fidl::Server<futi::KeyboardInputListener> {
 public:
  // |fuchsia_ui_test_input::KeyboardInputListener|
  void ReportTextInput(ReportTextInputRequest& request,
                       ReportTextInputCompleter::Sync& completer) override {
    events_received_.push_back(std::move(request));
  }

  // |fuchsia_ui_test_input::KeyboardInputListener|
  void ReportReady(ReportReadyCompleter::Sync& completer) override {
    // Puppet factory create view already wait for keyboard ready.
  }

  fidl::ClientEnd<futi::KeyboardInputListener> ServeAndGetClientEnd(
      async_dispatcher_t* dispatcher) {
    auto [client_end, server_end] = fidl::Endpoints<futi::KeyboardInputListener>::Create();
    binding_.AddBinding(dispatcher, std::move(server_end), this, fidl::kIgnoreBindingClosure);
    return std::move(client_end);
  }

  const std::vector<futi::KeyboardInputListenerReportTextInputRequest>& events_received() {
    return events_received_;
  }

  void clear_events() { events_received_.clear(); }

 private:
  fidl::ServerBindingGroup<futi::KeyboardInputListener> binding_;
  std::vector<futi::KeyboardInputListenerReportTextInputRequest> events_received_;
};

// Holds resources associated with a single puppet instance.
struct KeyPuppet {
  fidl::SyncClient<futc::Puppet> client;
  KeyListener key_listener;
};

class KeyConformanceTest : public ui_conformance_test_base::ConformanceTest {
 public:
  ~KeyConformanceTest() override = default;

  void SetUp() override {
    ui_conformance_test_base::ConformanceTest::SetUp();

    // Register fake keyboard.
    {
      FX_LOGS(INFO) << "Connecting to input registry";
      auto input_registry = ConnectSyncIntoRealm<futi::Registry>();

      FX_LOGS(INFO) << "Registering fake keyboard";
      auto [client_end, server_end] = fidl::Endpoints<futi::Keyboard>::Create();

      futi::RegistryRegisterKeyboardAndGetDeviceInfoRequest request;
      request.device(std::move(server_end));
      auto res = input_registry->RegisterKeyboardAndGetDeviceInfo(std::move(request));
      ZX_ASSERT_OK(res);
      fake_keyboard_device_id_ = res->device_id().value();

      fake_keyboard_ = fidl::SyncClient(std::move(client_end));
    }

    // Get display dimensions.
    {
      FX_LOGS(INFO) << "Reading display dimensions";
      auto display_info = ConnectSyncIntoRealm<fuchsia_ui_display_singleton::Info>();

      auto res = display_info->GetMetrics();
      ZX_ASSERT_OK(res);

      display_width_ = res.value().info().extent_in_px()->width();
      display_height_ = res.value().info().extent_in_px()->height();

      FX_LOGS(INFO) << "Received display dimensions (" << display_width_ << ", " << display_height_
                    << ")";
    }

    // Get root view token.
    {
      FX_LOGS(INFO) << "Creating root view token";

      auto controller = ConnectSyncIntoRealm<fuchsia_ui_test_scene::Controller>();

      fuchsia_ui_test_scene::ControllerPresentClientViewRequest req;
      auto [view_token, viewport_token] = scenic::cpp::ViewCreationTokenPair::New();
      req.viewport_creation_token(std::move(viewport_token));
      ZX_ASSERT_OK(controller->PresentClientView(std::move(req)));
      root_view_token_ = std::move(view_token);
    }

    // Setup focus listener.
    {
      auto focus_registry = ConnectSyncIntoRealm<fuf::FocusChainListenerRegistry>();
      auto focus_listener_client_end = focus_listener_.ServeAndGetClientEnd(dispatcher());

      ZX_ASSERT_OK(focus_registry->Register({std::move(focus_listener_client_end)}));
    }
  }

  void SimulateKeyEvent(std::string str) {
    FX_LOGS(INFO) << "Requesting key event";
    futi::KeyboardSimulateUsAsciiTextEntryRequest request;
    request.text(std::move(str));

    ZX_ASSERT_OK(fake_keyboard_->SimulateUsAsciiTextEntry(request));
    FX_LOGS(INFO) << "Key event injected";
  }

  void ExpectEvent(const futi::KeyboardInputListenerReportTextInputRequest& event,
                   std::optional<std::string> text,
                   std::optional<fui::NonPrintableKey> non_printable) const {
    ASSERT_EQ(text, event.text());
    ASSERT_EQ(non_printable, event.non_printable());
    ASSERT_EQ(fake_keyboard_device_id_, event.device_id());
  }

 protected:
  int32_t display_width_as_int() const { return static_cast<int32_t>(display_width_); }
  int32_t display_height_as_int() const { return static_cast<int32_t>(display_height_); }

  fidl::SyncClient<futi::Keyboard> fake_keyboard_;
  fuv::ViewCreationToken root_view_token_;
  FocusListener focus_listener_;
  uint32_t display_width_ = 0;
  uint32_t display_height_ = 0;
  uint32_t fake_keyboard_device_id_ = 0;
};

class SingleViewKeyConformanceTest : public KeyConformanceTest {
 public:
  ~SingleViewKeyConformanceTest() override = default;

  void SetUp() override {
    KeyConformanceTest::SetUp();

    {
      FX_LOGS(INFO) << "Create puppet under test";
      auto puppet_factory_connect =
          component::Connect<futc::PuppetFactory>(PUPPET_UNDER_TEST_FACTORY_SERVICE);
      ZX_ASSERT_OK(puppet_factory_connect);

      puppet_factory_ = fidl::SyncClient(std::move(puppet_factory_connect.value()));

      auto flatland = ConnectIntoRealm<fuchsia_ui_composition::Flatland>();
      auto keyboard = ConnectIntoRealm<fui::Keyboard>();
      auto [puppet_client_end, puppet_server_end] = fidl::Endpoints<futc::Puppet>::Create();
      auto key_listener_client_end = puppet_.key_listener.ServeAndGetClientEnd(dispatcher());
      puppet_.client = fidl::SyncClient(std::move(puppet_client_end));

      futc::PuppetCreationArgs creation_args;
      creation_args.server_end(std::move(puppet_server_end));
      creation_args.view_token(std::move(root_view_token_));
      creation_args.flatland_client(std::move(flatland));
      creation_args.keyboard_client(std::move(keyboard));
      creation_args.keyboard_listener(std::move(key_listener_client_end));
      creation_args.device_pixel_ratio(DevicePixelRatio());

      auto res = puppet_factory_->Create(std::move(creation_args));
      ZX_ASSERT_OK(res);
      ASSERT_EQ(res.value().result(), futc::Result::kSuccess);

      auto puppet_view_ref = std::move(res.value().view_ref().value());

      FX_LOGS(INFO) << "wait for focus";
      RunLoopUntil([&]() { return focus_listener_.IsViewFocused(puppet_view_ref); });
    }
  }

 protected:
  KeyPuppet puppet_;

 private:
  fidl::SyncClient<futc::PuppetFactory> puppet_factory_;
};

TEST_F(SingleViewKeyConformanceTest, SimpleKeyPress) {
  SimulateKeyEvent("Hello\nWorld!");
  FX_LOGS(INFO) << "Wait for puppet to report key events";
  RunLoopUntil([&]() { return puppet_.key_listener.events_received().size() >= 15; });

  ASSERT_EQ(puppet_.key_listener.events_received().size(), 15u);

  const auto& events = puppet_.key_listener.events_received();
  ExpectEvent(events[0], std::nullopt, fui::NonPrintableKey::kShift);
  // view reports value from key meaning so it is Shifted h (H).
  ExpectEvent(events[1], "H", std::nullopt);
  ExpectEvent(events[2], "e", std::nullopt);
  ExpectEvent(events[3], "l", std::nullopt);
  ExpectEvent(events[4], "l", std::nullopt);
  ExpectEvent(events[5], "o", std::nullopt);
  ExpectEvent(events[6], std::nullopt, fui::NonPrintableKey::kEnter);
  ExpectEvent(events[7], std::nullopt, fui::NonPrintableKey::kShift);
  ExpectEvent(events[8], "W", std::nullopt);
  ExpectEvent(events[9], "o", std::nullopt);
  ExpectEvent(events[10], "r", std::nullopt);
  ExpectEvent(events[11], "l", std::nullopt);
  ExpectEvent(events[12], "d", std::nullopt);
  ExpectEvent(events[13], std::nullopt, fui::NonPrintableKey::kShift);
  ExpectEvent(events[14], "!", std::nullopt);
}

class EmbeddedViewKeyConformanceTest : public KeyConformanceTest {
 public:
  ~EmbeddedViewKeyConformanceTest() override = default;

  void SetUp() override {
    KeyConformanceTest::SetUp();

    {
      FX_LOGS(INFO) << "Create parent puppet";

      auto puppet_factory_connect =
          component::Connect<futc::PuppetFactory>(AUXILIARY_PUPPET_FACTORY_SERVICE);
      ZX_ASSERT_OK(puppet_factory_connect);

      parent_puppet_factory_ = fidl::SyncClient(std::move(puppet_factory_connect.value()));

      auto flatland = ConnectIntoRealm<fuchsia_ui_composition::Flatland>();
      auto keyboard = ConnectIntoRealm<fui::Keyboard>();
      auto [puppet_client_end, puppet_server_end] = fidl::Endpoints<futc::Puppet>::Create();
      auto key_listener_client_end = parent_puppet_.key_listener.ServeAndGetClientEnd(dispatcher());
      auto [focuser_client_end, focuser_server_end] = fidl::Endpoints<fuv::Focuser>::Create();
      parent_focuser_ = fidl::SyncClient(std::move(focuser_client_end));
      parent_puppet_.client = fidl::SyncClient(std::move(puppet_client_end));

      futc::PuppetCreationArgs creation_args;
      creation_args.server_end(std::move(puppet_server_end));
      creation_args.view_token(std::move(root_view_token_));
      creation_args.flatland_client(std::move(flatland));
      creation_args.keyboard_client(std::move(keyboard));
      creation_args.keyboard_listener(std::move(key_listener_client_end));
      creation_args.device_pixel_ratio(DevicePixelRatio());
      creation_args.focuser(std::move(focuser_server_end));

      auto res = parent_puppet_factory_->Create(std::move(creation_args));
      ZX_ASSERT_OK(res);
      ASSERT_EQ(res.value().result(), futc::Result::kSuccess);

      parent_view_ref_ = std::move(res.value().view_ref().value());
    }

    // Create child viewport.
    fuv::ViewCreationToken view_creation_token;
    {
      FX_LOGS(INFO) << "Creating child viewport";
      const uint64_t kChildViewportId = 1u;

      futc::ContentBounds bounds;
      bounds.size() = {display_width_ / 2, display_height_ / 2};
      bounds.origin() = {display_width_as_int() / 2, display_height_as_int() / 2};
      futc::EmbeddedViewProperties properties({
          .bounds = std::move(bounds),
      });
      futc::PuppetEmbedRemoteViewRequest embed_remote_view_request({
          .id = kChildViewportId,
          .properties = std::move(properties),
      });
      auto res = parent_puppet_.client->EmbedRemoteView(embed_remote_view_request);
      ZX_ASSERT_OK(res);
      view_creation_token = std::move(res->view_creation_token()->value());
    }

    // Create child view.
    {
      FX_LOGS(INFO) << "Creating child puppet";
      auto puppet_factory_connect =
          component::Connect<futc::PuppetFactory>(PUPPET_UNDER_TEST_FACTORY_SERVICE);
      ZX_ASSERT_OK(puppet_factory_connect);

      child_puppet_factory_ = fidl::SyncClient(std::move(puppet_factory_connect.value()));

      auto flatland = ConnectIntoRealm<fuchsia_ui_composition::Flatland>();
      auto keyboard = ConnectIntoRealm<fui::Keyboard>();
      auto [puppet_client_end, puppet_server_end] = fidl::Endpoints<futc::Puppet>::Create();
      auto key_listener_client_end = child_puppet_.key_listener.ServeAndGetClientEnd(dispatcher());
      child_puppet_.client = fidl::SyncClient(std::move(puppet_client_end));

      futc::PuppetCreationArgs creation_args;
      creation_args.server_end(std::move(puppet_server_end));
      creation_args.view_token(std::move(view_creation_token));
      creation_args.flatland_client(std::move(flatland));
      creation_args.keyboard_client(std::move(keyboard));
      creation_args.keyboard_listener(std::move(key_listener_client_end));
      creation_args.device_pixel_ratio(DevicePixelRatio());

      auto res = child_puppet_factory_->Create(std::move(creation_args));
      ZX_ASSERT_OK(res);
      ASSERT_EQ(res.value().result(), futc::Result::kSuccess);

      child_view_ref_ = std::move(res.value().view_ref().value());
    }
  }

 protected:
  KeyPuppet parent_puppet_;
  fidl::SyncClient<fuv::Focuser> parent_focuser_;
  fuv::ViewRef parent_view_ref_;

  KeyPuppet child_puppet_;
  fuv::ViewRef child_view_ref_;

 private:
  fidl::SyncClient<futc::PuppetFactory> parent_puppet_factory_;
  fidl::SyncClient<futc::PuppetFactory> child_puppet_factory_;
};

TEST_F(EmbeddedViewKeyConformanceTest, KeyToFocusedView) {
  // Default is focus on parent view.
  {
    FX_LOGS(INFO) << "wait for focus to parent";
    RunLoopUntil([&]() { return focus_listener_.IsViewFocused(parent_view_ref_); });

    // Inject key events, and expect parent view receives events.
    SimulateKeyEvent("a");
    FX_LOGS(INFO) << "Wait for parent puppet to report key events";
    RunLoopUntil([&]() { return parent_puppet_.key_listener.events_received().size() >= 1; });

    ASSERT_EQ(parent_puppet_.key_listener.events_received().size(), 1u);

    const auto& events = parent_puppet_.key_listener.events_received();
    ExpectEvent(events[0], "a", std::nullopt);
    EXPECT_TRUE(child_puppet_.key_listener.events_received().empty());
    parent_puppet_.key_listener.clear_events();
  }

  // Focus on child view.
  {
    auto child_view_ref = scenic::cpp::CloneViewRef(child_view_ref_);

    ZX_ASSERT_OK(parent_focuser_->RequestFocus({std::move(child_view_ref)}));

    FX_LOGS(INFO) << "wait for focus to child";
    RunLoopUntil([&]() { return focus_listener_.IsViewFocused(child_view_ref_); });

    // Inject key events, and expect child view receives events.
    SimulateKeyEvent("b");

    FX_LOGS(INFO) << "Wait for child puppet to report key events";
    RunLoopUntil([&]() { return child_puppet_.key_listener.events_received().size() >= 1; });

    ASSERT_EQ(child_puppet_.key_listener.events_received().size(), 1u);

    const auto& events = child_puppet_.key_listener.events_received();
    ExpectEvent(events[0], "b", std::nullopt);
    EXPECT_TRUE(parent_puppet_.key_listener.events_received().empty());
    child_puppet_.key_listener.clear_events();
  }

  // Focus back to parent view.
  {
    auto parent_view_ref = scenic::cpp::CloneViewRef(parent_view_ref_);

    ZX_ASSERT_OK(parent_focuser_->RequestFocus({std::move(parent_view_ref)}));

    FX_LOGS(INFO) << "wait for focus to parent";
    RunLoopUntil([&]() { return focus_listener_.IsViewFocused(parent_view_ref_); });

    // Inject key events, and expect parent view receives events.
    SimulateKeyEvent("c");
    FX_LOGS(INFO) << "Wait for parent puppet to report key events";
    RunLoopUntil([&]() { return parent_puppet_.key_listener.events_received().size() >= 1; });

    ASSERT_EQ(parent_puppet_.key_listener.events_received().size(), 1u);

    const auto& events = parent_puppet_.key_listener.events_received();
    ExpectEvent(events[0], "c", std::nullopt);
    EXPECT_TRUE(child_puppet_.key_listener.events_received().empty());
    parent_puppet_.key_listener.clear_events();
  }
}

}  //  namespace ui_conformance_testing