engine/content_handler/direct_input.cc

// Copyright 2017 The Chromium 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 "flutter/content_handler/direct_input.h"

#include <dirent.h>
#include <fcntl.h>
#include <hid/acer12.h>
#include <hid/usages.h>
#include <magenta/device/device.h>
#include <magenta/device/input.h>
#include <sys/types.h>
#include <sys/uio.h>
#include <unistd.h>

#include <algorithm>
#include <string>
#include <utility>
#include <vector>

#include "lib/fidl/cpp/waiter/default.h"
#include "lib/ftl/time/time_point.h"

namespace flutter_runner {

static constexpr char kDevInput[] = "/dev/class/input";

DirectInput::DirectInput(DirectInputCallback callback)
    : callback_(callback), valid_(false), last_wait_(0) {
  FTL_DCHECK(callback_ != nullptr);

  // Setup the touch file descriptor.

  touch_fd_ = GetTouchFileDescriptor();

  if (!touch_fd_.is_valid()) {
    FTL_DLOG(INFO) << "Could not get the touch file descriptor on the Acer.";
    return;
  }

  // Get device event handle.

  mx_handle_t input_event = 0;
  ssize_t ret = mxio_ioctl(touch_fd_.get(), IOCTL_DEVICE_GET_EVENT_HANDLE,
                           nullptr, 0, &input_event, sizeof(input_event));

  if (ret < 0) {
    FTL_DLOG(INFO) << "Could not get device event handle.";
    return;
  }

  input_event_.reset(input_event);

  // Prepare buffer that we read into from the touch file descriptor.

  size_t max_report_len = 0;
  ret = mxio_ioctl(touch_fd_.get(), IOCTL_INPUT_GET_MAX_REPORTSIZE, nullptr, 0,
                   &max_report_len, sizeof(max_report_len));
  if (ret < 0) {
    FTL_DLOG(INFO)
        << "Could not read the max report size on the touch file descriptor";
    return;
  }

  read_buffer_.resize(max_report_len);

  valid_ = true;
}

DirectInput::~DirectInput() {
  CancelWaitForReadAvailability();
}

bool DirectInput::IsValid() const {
  return valid_;
}

void DirectInput::WaitForReadAvailability() {
  CancelWaitForReadAvailability();

  FidlAsyncWaitCallback callback = [](mx_status_t result, mx_signals_t pending,
                                      void* baton) {
    if (result != NO_ERROR) {
      FTL_DLOG(INFO) << "Error while waiting on read availablility.";
      return;
    }

    if (!(pending & DEVICE_SIGNAL_READABLE)) {
      FTL_DLOG(INFO) << "Wait callback fired but not read pending.";
      return;
    }

    reinterpret_cast<DirectInput*>(baton)->OnReadAvailable();
  };

  last_wait_ = fidl::GetDefaultAsyncWaiter()->AsyncWait(
      input_event_.get(), DEVICE_SIGNAL_READABLE, MX_TIME_INFINITE, callback,
      this);
}

void DirectInput::CancelWaitForReadAvailability() {
  if (last_wait_ == 0) {
    return;
  }

  fidl::GetDefaultAsyncWaiter()->CancelWait(last_wait_);
  last_wait_ = 0;
}

void DirectInput::OnReadAvailable() {
  last_wait_ = 0;
  PerformRead();
  WaitForReadAvailability();
}

void DirectInput::PerformRead() {
  ssize_t ret =
      ::read(touch_fd_.get(), read_buffer_.data(), read_buffer_.size());

  if (ret < 0) {
    return;
  }

  if (read_buffer_[0] != ACER12_RPT_ID_TOUCH) {
    return;
  }

  acer12_touch_t* report =
      reinterpret_cast<acer12_touch_t*>(read_buffer_.data());

  size_t fingers_count = std::min<size_t>(5, report->contact_count);

  int64_t timestamp = ftl::TimePoint::Now().ToEpochDelta().ToMilliseconds();

  if (fingers_count == 0) {
    return;
  }

  blink::PointerDataPacket packet(fingers_count);

  for (uint8_t i = 0; i < fingers_count; i++) {
    const acer12_finger& finger = report->fingers[i];

    int64_t touch_identifier = acer12_finger_id_contact(finger.finger_id);

    blink::PointerData pointer_data;
    pointer_data.Clear();

    pointer_data.time_stamp = timestamp;
    pointer_data.kind = blink::PointerData::DeviceKind::kTouch;
    pointer_data.device = touch_identifier;

    pointer_data.physical_x = ((static_cast<float>(finger.x) / ACER12_X_MAX) *
                               viewport_metrics_.physical_width);
    pointer_data.physical_y = ((static_cast<float>(finger.y) / ACER12_Y_MAX) *
                               viewport_metrics_.physical_height);

    bool down = !!acer12_finger_id_tswitch(finger.finger_id);

    if (down) {
      auto insertion_result = touch_ids_.insert(touch_identifier);
      // If we could add the touch indentifier to the set of tracked touches, it
      // means that we were not already tracking it before. That means it is
      // kDown. In not, it is a kMove of a previous report.
      pointer_data.change = insertion_result.second
                                ? blink::PointerData::Change::kDown
                                : blink::PointerData::Change::kMove;
    } else {
      touch_ids_.erase(touch_identifier);
      pointer_data.change = blink::PointerData::Change::kUp;
    }

    packet.SetPointerData(i, pointer_data);
  }

  callback_(packet);
}

ftl::UniqueFD DirectInput::GetTouchFileDescriptor() {
  DIR* dir = ::opendir(kDevInput);

  if (!dir) {
    return {};
  }

  std::string device_dir = kDevInput;

  device_dir += "/";

  struct dirent* dir_entry = nullptr;

  while ((dir_entry = readdir(dir)) != nullptr) {
    std::string device_path = device_dir + dir_entry->d_name;

    ftl::UniqueFD fd(::open(device_path.c_str(), O_RDONLY));

    if (!fd.is_valid()) {
      continue;
    }

    size_t report_desc_len = 0;

    ssize_t ret =
        mxio_ioctl(fd.get(), IOCTL_INPUT_GET_REPORT_DESC_SIZE, nullptr, 0,
                   &report_desc_len, sizeof(report_desc_len));

    if (ret < 0) {
      continue;
    }

    if (report_desc_len != ACER12_RPT_DESC_LEN) {
      continue;
    }

    std::vector<uint8_t> report_desc(report_desc_len);

    ret = mxio_ioctl(fd.get(), IOCTL_INPUT_GET_REPORT_DESC, nullptr, 0,
                     report_desc.data(), report_desc.size());

    if (ret < 0) {
      continue;
    }

    if (!memcmp(report_desc.data(), acer12_touch_report_desc,
                ACER12_RPT_DESC_LEN)) {
      ::closedir(dir);
      return fd;
    }
  }

  ::closedir(dir);
  return {};
}

void DirectInput::SetViewportMetrics(blink::ViewportMetrics metrics) {
  viewport_metrics_ = metrics;
}

}  // namespace flutter_runner