src/ui/tests/integration_input_tests/touch/touch-input-test.cc

// Copyright 2021 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.accessibility.semantics/cpp/fidl.h>
#include <fidl/fuchsia.buildinfo/cpp/fidl.h>
#include <fidl/fuchsia.component/cpp/fidl.h>
#include <fidl/fuchsia.element/cpp/fidl.h>
#include <fidl/fuchsia.fonts/cpp/fidl.h>
#include <fidl/fuchsia.input.injection/cpp/fidl.h>
#include <fidl/fuchsia.intl/cpp/fidl.h>
#include <fidl/fuchsia.kernel/cpp/fidl.h>
#include <fidl/fuchsia.memorypressure/cpp/fidl.h>
#include <fidl/fuchsia.metrics/cpp/fidl.h>
#include <fidl/fuchsia.net.interfaces/cpp/fidl.h>
#include <fidl/fuchsia.posix.socket/cpp/fidl.h>
#include <fidl/fuchsia.process/cpp/fidl.h>
#include <fidl/fuchsia.scheduler/cpp/fidl.h>
#include <fidl/fuchsia.sysmem/cpp/fidl.h>
#include <fidl/fuchsia.tracing.provider/cpp/fidl.h>
#include <fidl/fuchsia.ui.input/cpp/fidl.h>
#include <fidl/fuchsia.ui.pointer/cpp/fidl.h>
#include <fidl/fuchsia.ui.test.input/cpp/fidl.h>
#include <fidl/fuchsia.vulkan.loader/cpp/fidl.h>
#include <lib/async/cpp/task.h>
#include <lib/fidl/cpp/channel.h>
#include <lib/sys/component/cpp/testing/realm_builder.h>
#include <lib/sys/component/cpp/testing/realm_builder_types.h>
#include <lib/syslog/cpp/macros.h>
#include <lib/ui/scenic/cpp/view_token_pair.h>
#include <lib/zx/clock.h>
#include <lib/zx/time.h>
#include <zircon/status.h>
#include <zircon/types.h>
#include <zircon/utc.h>

#include <cstddef>
#include <cstdint>
#include <memory>
#include <utility>
#include <vector>

#include <gtest/gtest.h>
#include <src/lib/timekeeper/clock.h>
#include <src/ui/testing/util/fidl_cpp_helpers.h>
#include <src/ui/testing/util/portable_ui_test.h>

// This test exercises the touch input dispatch path from Input Pipeline to a Scenic client. It
// is a multi-component test, and carefully avoids sleeping or polling for component
// coordination.
// - It runs real Scene Manager and Scenic components.
// - It uses a fake display controller; the physical device is unused.
//
// Components involved
// - This test program
// - Scene Manager
// - Scenic
// - Child view, a Scenic client
//
// Touch dispatch path
// - Test program's injection -> Input Pipeline -> Scenic -> Child view
//
// Setup sequence
// - The test sets up this view hierarchy:
//   - Top level scene, owned by Scene Manager.
//   - Child view, owned by the ui client.
// - The test waits for a Scenic event that verifies the child has UI content in the scene
// graph.
// - The test injects input into Input Pipeline, emulating a display's touch report.
// - Input Pipeline dispatches the touch event to Scenic, which in turn dispatches it to the
// child.
// - The child receives the touch event and reports back to the test over a custom test-only
// FIDL.
// - Test waits for the child to report a touch; when the test receives the report, the test
// quits
//   successfully.
//
// This test uses the realm_builder library to construct the topology of components
// and routes services between them. For v2 components, every test driver component
// sits as a child of test_manager in the topology. Thus, the topology of a test
// driver component such as this one looks like this:
//
//     test_manager
//         |
//   touch-input-test.cml (this component)
//
// With the usage of the realm_builder library, we construct a realm during runtime
// and then extend the topology to look like:
//
//    test_manager
//         |
//   touch-input-test.cml (this component)
//         |
//   <created realm root>
//      /      \
//   scenic  scene_manager
//
// For more information about testing v2 components and realm_builder,
// visit the following links:
//
// Testing: https://fuchsia.dev/fuchsia-src/concepts/testing/v2
// Realm Builder: https://fuchsia.dev/fuchsia-src/development/components/v2/realm_builder

namespace {

// Types imported for the realm_builder library.
using component_testing::ChildRef;
using component_testing::LocalComponentImpl;
using component_testing::ParentRef;
using component_testing::Protocol;
using component_testing::Route;

// Alias for Component child name as provided to Realm Builder.
using ChildName = std::string;

// Max timeout in failure cases.
// Set this as low as you can that still works across all test platforms.
constexpr zx::duration kTimeout = zx::min(5);

// Maximum distance between two physical pixel coordinates so that they are considered equal.
constexpr double kEpsilon = 0.5f;

// Number of move events to generate for swipe gestures.
constexpr auto kMoveEventCount = 5;

// The dimensions of the fake display used in tests. Used in calculating the expected distance
// between any two tap events present in the response to a swipe event.
// Note: These values are currently hard coded in the fake display and should be changed
// accordingly.
// TODO(https://fxbug.dev/42062819): Remove the dependency of the tests on these hard coded
// values.
constexpr auto kDisplayWidth = 1280;
constexpr auto kDisplayHeight = 800;

using time_utc = timekeeper::time_utc;

constexpr auto kMockResponseListener = "response_listener";

void ExpectLocationAndPhase(
    const fuchsia_ui_test_input::TouchInputListenerReportTouchInputRequest& e, double expected_x,
    double expected_y, fuchsia_ui_pointer::EventPhase expected_phase) {
  auto pixel_scale = e.device_pixel_ratio().has_value() ? e.device_pixel_ratio().value() : 1;
  auto actual_x = pixel_scale * e.local_x().value();
  auto actual_y = pixel_scale * e.local_y().value();
  EXPECT_NEAR(expected_x, actual_x, kEpsilon);
  EXPECT_NEAR(expected_y, actual_y, kEpsilon);
  EXPECT_EQ(expected_phase, e.phase());
}

std::vector<float> ConfigsToTest() {
  std::vector<float> configs;
  // TODO: https://fxbug.dev/42082519 - Test for DPR=2.0, too.
  configs.push_back(2.f);
  return configs;
}

template <typename T>
std::vector<std::tuple<T>> AsTuples(const std::vector<T>& v) {
  std::vector<std::tuple<T>> result;
  for (const auto& elt : v) {
    result.push_back(elt);
  }

  return result;
}

enum class TapLocation { kTopLeft, kTopRight };

enum class SwipeGesture {
  UP = 1,
  DOWN,
  LEFT,
  RIGHT,
};

struct ExpectedSwipeEvent {
  double x = 0, y = 0;
  fuchsia_ui_pointer::EventPhase phase;
};

struct InjectSwipeParams {
  SwipeGesture direction = SwipeGesture::UP;
  int begin_x = 0, begin_y = 0;
  std::vector<ExpectedSwipeEvent> expected_events;
};

// Checks whether all the coordinates in |expected_events| are contained in |actual_events|.
void AssertSwipeEvents(
    const std::vector<fuchsia_ui_test_input::TouchInputListenerReportTouchInputRequest>&
        actual_events,
    const std::vector<ExpectedSwipeEvent>& expected_events) {
  FX_DCHECK(actual_events.size() == expected_events.size());

  for (size_t i = 0; i < actual_events.size(); i++) {
    const auto& actual_x = actual_events[i].local_x().value();
    const auto& actual_y = actual_events[i].local_y().value();

    const auto& [expected_x, expected_y, expected_phase] = expected_events[i];

    EXPECT_NEAR(actual_x, expected_x, kEpsilon);
    EXPECT_NEAR(actual_y, expected_y, kEpsilon);
    EXPECT_EQ(actual_events[i].phase(), expected_phase);
  }
}

InjectSwipeParams GetLeftSwipeParams() {
  std::vector<ExpectedSwipeEvent> expected_events;
  auto tap_distance = static_cast<double>(kDisplayWidth) / static_cast<double>(kMoveEventCount);

  // As the child view is rotated by 90 degrees, a swipe in the middle of the display from the
  // right edge to the left edge should appear as a swipe in the middle of the screen from the
  // top edge to the the bottom edge.
  for (double i = 0; i <= static_cast<double>(kMoveEventCount); i++) {
    expected_events.push_back({
        .x = static_cast<double>(kDisplayHeight) / 2,
        .y = i * tap_distance,
        .phase = fuchsia_ui_pointer::EventPhase::kChange,
    });
  }

  expected_events[0].phase = fuchsia_ui_pointer::EventPhase::kAdd;
  expected_events.push_back({
      .x = expected_events.back().x,
      .y = expected_events.back().y,
      .phase = fuchsia_ui_pointer::EventPhase::kRemove,
  });

  return {.direction = SwipeGesture::LEFT,
          .begin_x = kDisplayWidth,
          .begin_y = kDisplayHeight / 2,
          .expected_events = std::move(expected_events)};
}

InjectSwipeParams GetRightSwipeParams() {
  std::vector<ExpectedSwipeEvent> expected_events;
  auto tap_distance = static_cast<double>(kDisplayWidth) / static_cast<double>(kMoveEventCount);

  // As the child view is rotated by 90 degrees, a swipe in the middle of the display from
  // the left edge to the right edge should appear as a swipe in the middle of the screen from
  // the bottom edge to the top edge.
  for (double i = static_cast<double>(kMoveEventCount); i >= 0; i--) {
    expected_events.push_back({
        .x = static_cast<double>(kDisplayHeight) / 2,
        .y = i * tap_distance,
        .phase = fuchsia_ui_pointer::EventPhase::kChange,
    });
  }

  expected_events[0].phase = fuchsia_ui_pointer::EventPhase::kAdd;
  expected_events.push_back({
      .x = expected_events.back().x,
      .y = expected_events.back().y,
      .phase = fuchsia_ui_pointer::EventPhase::kRemove,
  });

  return {.direction = SwipeGesture::RIGHT,
          .begin_x = 0,
          .begin_y = kDisplayHeight / 2,
          .expected_events = std::move(expected_events)};
}

InjectSwipeParams GetUpwardSwipeParams() {
  std::vector<ExpectedSwipeEvent> expected_events;
  auto tap_distance = static_cast<double>(kDisplayHeight) / static_cast<double>(kMoveEventCount);

  // As the child view is rotated by 90 degrees, a swipe in the middle of the display from the
  // bottom edge to the top edge should appear as a swipe in the middle of the screen from the
  // right edge to the left edge.
  for (double i = static_cast<double>(kMoveEventCount); i >= 0; i--) {
    expected_events.push_back({
        .x = i * tap_distance,
        .y = static_cast<double>(kDisplayWidth) / 2,
        .phase = fuchsia_ui_pointer::EventPhase::kChange,
    });
  }

  expected_events[0].phase = fuchsia_ui_pointer::EventPhase::kAdd;
  expected_events.push_back({
      .x = expected_events.back().x,
      .y = expected_events.back().y,
      .phase = fuchsia_ui_pointer::EventPhase::kRemove,
  });

  return {.direction = SwipeGesture::UP,
          .begin_x = kDisplayWidth / 2,
          .begin_y = kDisplayHeight,
          .expected_events = std::move(expected_events)};
}

InjectSwipeParams GetDownwardSwipeParams() {
  std::vector<ExpectedSwipeEvent> expected_events;
  auto tap_distance = static_cast<double>(kDisplayHeight) / static_cast<double>(kMoveEventCount);

  // As the child view is rotated by 90 degrees, a swipe in the middle of the display from the
  // top edge to the bottom edge should appear as a swipe in the middle of the screen from the
  // left edge to the right edge.
  for (double i = 0; i <= static_cast<double>(kMoveEventCount); i++) {
    expected_events.push_back({
        .x = i * tap_distance,
        .y = static_cast<double>(kDisplayWidth) / 2,
        .phase = fuchsia_ui_pointer::EventPhase::kChange,
    });
  }

  expected_events[0].phase = fuchsia_ui_pointer::EventPhase::kAdd;
  expected_events.push_back({
      .x = expected_events.back().x,
      .y = expected_events.back().y,
      .phase = fuchsia_ui_pointer::EventPhase::kRemove,
  });

  return {.direction = SwipeGesture::DOWN,
          .begin_x = kDisplayWidth / 2,
          .begin_y = 0,
          .expected_events = std::move(expected_events)};
}

class ResponseState {
 public:
  const std::vector<fuchsia_ui_test_input::TouchInputListenerReportTouchInputRequest>&
  events_received() {
    return events_received_;
  }
  bool ready_to_inject() const { return ready_to_inject_; }

 private:
  friend class ResponseListenerServer;
  std::vector<fuchsia_ui_test_input::TouchInputListenerReportTouchInputRequest> events_received_;
  bool ready_to_inject_ = false;
};

// This component implements the test.touch.ResponseListener protocol
// and the interface for a RealmBuilder LocalComponentImpl. A LocalComponentImpl
// is a component that is implemented here in the test, as opposed to elsewhere
// in the system. When it's inserted to the realm, it will act like a proper
// component. This is accomplished, in part, because the realm_builder
// library creates the necessary plumbing. It creates a manifest for the component
// and routes all capabilities to and from it.
class ResponseListenerServer : public fidl::Server<fuchsia_ui_test_input::TouchInputListener>,
                               public fidl::Server<fuchsia_ui_test_input::TestAppStatusListener>,
                               public LocalComponentImpl {
 public:
  explicit ResponseListenerServer(async_dispatcher_t* dispatcher,
                                  std::weak_ptr<ResponseState> state)
      : dispatcher_(dispatcher), state_(std::move(state)) {}

  // |fuchsia_ui_test_input::TouchInputListener|
  void ReportTouchInput(ReportTouchInputRequest& request,
                        ReportTouchInputCompleter::Sync& completer) override {
    if (auto s = state_.lock()) {
      s->events_received_.push_back(std::move(request));
    }
  }

  // |fuchsia_ui_test_input::TestAppStatusListener|
  void ReportStatus(ReportStatusRequest& req, ReportStatusCompleter::Sync& completer) override {
    if (req.status() == fuchsia_ui_test_input::TestAppStatus::kHandlersRegistered) {
      if (auto s = state_.lock()) {
        s->ready_to_inject_ = true;
      }
    }

    completer.Reply();
  }

  // |fuchsia_ui_test_input::TestAppStatusListener|
  void handle_unknown_method(
      fidl::UnknownMethodMetadata<fuchsia_ui_test_input::TestAppStatusListener> metadata,
      fidl::UnknownMethodCompleter::Sync& completer) override {
    FX_LOGS(WARNING) << "TestAppStatusListener Received an unknown method with ordinal "
                     << metadata.method_ordinal;
  }

  // |LocalComponentImpl::Start|
  // When the component framework requests for this component to start, this
  // method will be invoked by the realm_builder library.
  void OnStart() override {
    // When this component starts, add a binding to the test.touch.ResponseListener
    // protocol to this component's outgoing directory.
    outgoing()->AddProtocol<fuchsia_ui_test_input::TouchInputListener>(
        touch_input_listener_bindings_.CreateHandler(this, dispatcher_,
                                                     fidl::kIgnoreBindingClosure));
    outgoing()->AddProtocol<fuchsia_ui_test_input::TestAppStatusListener>(
        app_status_listener_bindings_.CreateHandler(this, dispatcher_,
                                                    fidl::kIgnoreBindingClosure));
  }

 private:
  async_dispatcher_t* dispatcher_ = nullptr;
  fidl::ServerBindingGroup<fuchsia_ui_test_input::TouchInputListener>
      touch_input_listener_bindings_;
  fidl::ServerBindingGroup<fuchsia_ui_test_input::TestAppStatusListener>
      app_status_listener_bindings_;
  std::weak_ptr<ResponseState> state_;
};

template <typename... Ts>
class TouchInputBase : public ui_testing::PortableUITest,
                       public testing::WithParamInterface<std::tuple<float, Ts...>> {
 protected:
  ~TouchInputBase() override {
    FX_CHECK(touch_injection_request_count() > 0) << "injection expected but didn't happen.";
  }

  std::string GetTestUIStackUrl() override { return "#meta/test-ui-stack.cm"; }

  void SetUp() override {
    ui_testing::PortableUITest::SetUp();

    // Post a "just in case" quit task, if the test hangs.
    async::PostDelayedTask(
        dispatcher(),
        [] { FX_LOGS(FATAL) << "\n\n>> Test did not complete in time, terminating.  <<\n\n"; },
        kTimeout);

    // Register input injection device.
    FX_LOGS(INFO) << "Registering input injection device";
    RegisterTouchScreen();

    // Wait until eager client view is rendering to proceed with the test.
    FX_LOGS(INFO) << "Wait for view presentation";
    WaitForViewPresentation();

    FX_LOGS(INFO) << "Wait for test app status: kHandlersRegistered";
    RunLoopUntil([&]() { return response_state()->ready_to_inject(); });
    FX_LOGS(INFO) << "test app status: kHandlersRegistered";
  }

  bool LastEventReceivedMatchesPhase(fuchsia_ui_pointer::EventPhase phase,
                                     const std::string& component_name) {
    const auto& events_received = response_state_->events_received();
    if (events_received.empty()) {
      return false;
    }

    const auto& last_event = events_received.back();
    const auto actual_phase = last_event.phase().value();
    auto actual_component_name = last_event.component_name().value();

    FX_LOGS(INFO) << "Expecting event for component " << component_name << " at phase ("
                  << static_cast<uint32_t>(phase) << ")";
    FX_LOGS(INFO) << "Received event for component " << actual_component_name << " at phaase ("
                  << static_cast<uint32_t>(actual_phase) << ")";

    return phase == actual_phase && actual_component_name == component_name;
  }

  void InjectInput(TapLocation tap_location) {
    // The /config/data/display_rotation (90) specifies how many degrees to rotate the
    // presentation child view, counter-clockwise, in a right-handed coordinate system. Thus,
    // the user observes the child view to rotate *clockwise* by that amount (90).
    //
    // Hence, a tap in the center of the display's top-right quadrant is observed by the child
    // view as a tap in the center of its top-left quadrant.
    auto touch = std::make_unique<fuchsia_ui_input::TouchscreenReport>();
    switch (tap_location) {
      case TapLocation::kTopLeft:
        // center of top right quadrant -> ends up as center of top left quadrant
        InjectTap(/* x = */ 3 * display_width() / 4, /* y = */ display_height() / 4);
        break;
      case TapLocation::kTopRight:
        // center of bottom right quadrant -> ends up as center of top right quadrant
        InjectTap(/* x = */ 3 * display_width() / 4, /* y = */ 3 * display_height() / 4);
        break;
      default:
        FX_NOTREACHED();
    }
  }

  // Inject directly into Input Pipeline, using fuchsia.input.injection FIDLs. A swipe gesture is
  // mimicked by injecting |swipe_length| touch events across the length of the display, with a
  // delay of 10 msec. For the fake display used in this test, and swipe_length=N, this results in
  // events separated by 50 pixels.
  void InjectEdgeToEdgeSwipe(SwipeGesture direction, int begin_x, int begin_y) {
    int x_dir = 0, y_dir = 0;
    switch (direction) {
      case SwipeGesture::UP:
        y_dir = -1;
        break;
      case SwipeGesture::DOWN:
        y_dir = 1;
        break;
      case SwipeGesture::LEFT:
        x_dir = -1;
        break;
      case SwipeGesture::RIGHT:
        x_dir = 1;
        break;
      default:
        FX_NOTREACHED();
    }

    fuchsia_ui_test_input::TouchScreenSimulateSwipeRequest swipe_request;
    swipe_request.start_location() = {begin_x, begin_y};
    swipe_request.end_location() = {static_cast<int32_t>(begin_x + (x_dir * display_width())),
                                    static_cast<int32_t>(begin_y + (y_dir * display_height()))};
    // Generate move events 50 pixels apart.
    swipe_request.move_event_count(kMoveEventCount);

    InjectSwipe(/* start_x = */ begin_x, /* start_y = */ begin_y,
                /* end_x = */ begin_x + (x_dir * display_width()),
                /* end_y = */ begin_y + (y_dir * display_height()),
                /* move_event_count = */ kMoveEventCount);
  }
  uint32_t display_rotation() override { return 90; }

  // TODO: https://fxbug.dev/42082519 - Test for DPR=2.0, too.
  float device_pixel_ratio() override { return 1.f; }

  std::shared_ptr<ResponseState> response_state() const { return response_state_; }

 private:
  void ExtendRealm() override {
    // Key part of service setup: have this test component vend the
    // |ResponseListener| service in the constructed realm.
    realm_builder().AddLocalChild(kMockResponseListener, [d = dispatcher(), s = response_state_]() {
      return std::make_unique<ResponseListenerServer>(d, s);
    });
  }

  std::shared_ptr<ResponseState> response_state_ = std::make_shared<ResponseState>();
};

template <typename... Ts>
class CppInputTestBase : public TouchInputBase<Ts...> {
 protected:
  static constexpr auto kCppFlatlandClient = "touch-flatland-client";

 private:
  std::vector<std::pair<ChildName, std::string>> GetEagerTestComponents() override {
    return {std::make_pair(kCppFlatlandClient, kCppFlatlandClientUrl)};
  }

  std::vector<Route> GetTestRoutes() override {
    return {
        {.capabilities =
             {Protocol{fidl::DiscoverableProtocolName<fuchsia_ui_test_input::TouchInputListener>},
              Protocol{
                  fidl::DiscoverableProtocolName<fuchsia_ui_test_input::TestAppStatusListener>}},
         .source = ChildRef{kMockResponseListener},
         .targets = {ChildRef{kCppFlatlandClient}}},
        {.capabilities =
             {Protocol{fidl::DiscoverableProtocolName<fuchsia_element::GraphicalPresenter>},
              Protocol{fidl::DiscoverableProtocolName<fuchsia_ui_composition::Flatland>},
              Protocol{fidl::DiscoverableProtocolName<fuchsia_ui_composition::Allocator>}},
         .source = ui_testing::PortableUITest::kTestUIStackRef,
         .targets = {ChildRef{kCppFlatlandClient}}},
    };
  }

  static constexpr auto kCppFlatlandClientUrl = "#meta/touch-flatland-client.cm";
};

class CppInputTest : public CppInputTestBase<> {};
INSTANTIATE_TEST_SUITE_P(CppInputTestParametized, CppInputTest,
                         testing::ValuesIn(AsTuples(ConfigsToTest())));

TEST_P(CppInputTest, CppClientTap) {
  InjectInput(TapLocation::kTopLeft);
  RunLoopUntil([this] {
    return LastEventReceivedMatchesPhase(fuchsia_ui_pointer::EventPhase::kRemove,
                                         kCppFlatlandClient);
  });

  const auto& events_received = this->response_state()->events_received();
  ASSERT_EQ(events_received.size(), 2u);
  ExpectLocationAndPhase(events_received[0], static_cast<float>(display_height()) / 4.f,
                         static_cast<float>(display_width()) / 4.f,
                         fuchsia_ui_pointer::EventPhase::kAdd);
  ExpectLocationAndPhase(events_received[1], static_cast<float>(display_height()) / 4.f,
                         static_cast<float>(display_width()) / 4.f,
                         fuchsia_ui_pointer::EventPhase::kRemove);
}

class CppSwipeTest : public CppInputTestBase<InjectSwipeParams> {};
INSTANTIATE_TEST_SUITE_P(
    CppSwipeTestParameterized, CppSwipeTest,
    testing::Combine(testing::ValuesIn(ConfigsToTest()),
                     testing::Values(GetRightSwipeParams(), GetDownwardSwipeParams(),
                                     GetLeftSwipeParams(), GetUpwardSwipeParams())));

TEST_P(CppSwipeTest, CppClientSwipeTest) {
  const auto& [direction, begin_x, begin_y, expected_events] = std::get<1>(GetParam());

  // Inject a swipe on the display. As the child view is rotated by 90 degrees, the direction of
  // the swipe also gets rotated by 90 degrees.
  InjectEdgeToEdgeSwipe(direction, begin_x, begin_y);

  //  Client sends a response for 1 Down, 1 Up and |swipe_length| Move PointerEventPhase events.
  RunLoopUntil([this] {
    FX_LOGS(INFO) << "Events received = " << response_state()->events_received().size();
    FX_LOGS(INFO) << "Events expected = " << kMoveEventCount + 2;
    return response_state()->events_received().size() >= static_cast<uint32_t>(kMoveEventCount + 2);
  });

  const auto& actual_events = response_state()->events_received();
  ASSERT_EQ(actual_events.size(), expected_events.size());
  AssertSwipeEvents(actual_events, expected_events);
}

}  // namespace