src/ui/tests/conformance_input_tests/focus-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.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 <string>
#include <utility>
#include <vector>

#include <src/lib/fsl/handles/object_info.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";

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 FocusConformanceTest : public ui_conformance_test_base::ConformanceTest {
 public:
  void PresentAndAddPuppetView() {
    // Present view.
    fuv::ViewCreationToken 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);
    }

    // Add puppet view.
    {
      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();

      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.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);

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

  fuv::ViewRef puppet_view_ref_;

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

// This test exercises the focus contract with the scene owner: the view offered to the
// scene owner will have focus transferred to it.
TEST_F(FocusConformanceTest, ReceivesFocusTransfer) {
  // Setup focus listener.
  FocusListener 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)}));
  }

  RunLoopUntil([&focus_listener]() { return focus_listener.focus_chain_updates().size() > 0; });

  // No focus chain when no scene.
  EXPECT_FALSE(focus_listener.focus_chain_updates().back().focus_chain().has_value());

  PresentAndAddPuppetView();

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

// This test ensures that multiple clients can connect to the FocusChainListenerRegistry.
TEST_F(FocusConformanceTest, MultiListener) {
  // Setup focus listener a.
  FocusListener focus_listener_a;
  {
    auto focus_registry = ConnectSyncIntoRealm<fuf::FocusChainListenerRegistry>();
    auto focus_listener_client_end = focus_listener_a.ServeAndGetClientEnd(dispatcher());

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

  RunLoopUntil([&focus_listener_a]() { return focus_listener_a.focus_chain_updates().size() > 0; });

  // No focus chain when no scene.
  EXPECT_FALSE(focus_listener_a.focus_chain_updates().back().focus_chain().has_value());

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

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

  PresentAndAddPuppetView();

  FX_LOGS(INFO) << "focus listener a receives focus transfer";
  RunLoopUntil([&]() { return focus_listener_a.IsViewFocused(puppet_view_ref_); });

  FX_LOGS(INFO) << "focus listener b receives focus transfer";
  RunLoopUntil([&]() { return focus_listener_b.IsViewFocused(puppet_view_ref_); });
}

}  //  namespace ui_conformance_testing