| // Copyright 2020 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 "input-reports-reader.h" |
| |
| #include <ddk/debug.h> |
| #include <ddk/trace/event.h> |
| #include <fbl/auto_lock.h> |
| |
| namespace hid_input_report_dev { |
| |
| std::unique_ptr<InputReportsReader> InputReportsReader::Create(InputReportBase* base, |
| uint32_t reader_id, |
| async_dispatcher_t* dispatcher, |
| zx::channel req) { |
| // Invoked when the channel is closed or on any binding-related error. |
| fidl::OnUnboundFn<llcpp::fuchsia::input::report::InputReportsReader::Interface> unbound_fn( |
| [](llcpp::fuchsia::input::report::InputReportsReader::Interface* dev, fidl::UnbindInfo info, |
| zx::channel) { |
| auto* device = static_cast<InputReportsReader*>(dev); |
| |
| { |
| fbl::AutoLock lock(&device->readers_lock_); |
| // Any pending LLCPP completer must be either replied to or closed before we destroy it. |
| if (device->waiting_read_) { |
| device->waiting_read_->Close(ZX_ERR_PEER_CLOSED); |
| device->waiting_read_.reset(); |
| } |
| } |
| // This frees the InputReportsReader class. |
| device->base_->RemoveReaderFromList(device); |
| }); |
| |
| auto reader = std::make_unique<InputReportsReader>(base, reader_id); |
| auto binding = fidl::BindServer( |
| dispatcher, std::move(req), |
| static_cast<llcpp::fuchsia::input::report::InputReportsReader::Interface*>(reader.get()), |
| std::move(unbound_fn)); |
| fbl::AutoLock lock(&reader->readers_lock_); |
| if (binding.is_error()) { |
| zxlogf(ERROR, "InputReportsReader::Create: Failed to BindServer %d\n", binding.error()); |
| return nullptr; |
| } |
| |
| reader->binding_.emplace(std::move(binding.value())); |
| return reader; |
| } |
| |
| void InputReportsReader::ReadInputReports(ReadInputReportsCompleter::Sync& completer) { |
| fbl::AutoLock lock(&readers_lock_); |
| |
| if (waiting_read_) { |
| completer.ReplyError(ZX_ERR_ALREADY_BOUND); |
| return; |
| } |
| |
| waiting_read_ = completer.ToAsync(); |
| SendReportsToWaitingRead(); |
| } |
| |
| void InputReportsReader::SendReportsToWaitingRead() { |
| if (reports_data_.empty()) { |
| return; |
| } |
| |
| std::array<fuchsia_input_report::InputReport, fuchsia_input_report::MAX_DEVICE_REPORT_COUNT> |
| reports; |
| size_t num_reports = 0; |
| |
| TRACE_DURATION("input", "InputReportInstance GetReports", "instance_id", reader_id_); |
| while (!reports_data_.empty()) { |
| TRACE_FLOW_STEP("input", "input_report", reports_data_.front().trace_id()); |
| reports[num_reports++] = std::move(reports_data_.front()); |
| reports_data_.pop(); |
| } |
| |
| fidl::Result result = |
| waiting_read_->ReplySuccess(fidl::VectorView<fuchsia_input_report::InputReport>( |
| fidl::unowned_ptr(reports.data()), num_reports)); |
| if (result.status() != ZX_OK) { |
| zxlogf(ERROR, "SendReport: Failed to send reports (%s): %s\n", result.status_string(), |
| result.error()); |
| } |
| waiting_read_.reset(); |
| |
| // We have sent the reports so reset the allocator. |
| report_allocator_.inner_allocator().reset(); |
| } |
| |
| void InputReportsReader::ReceiveReport(const uint8_t* report, size_t report_size, zx_time_t time, |
| hid_input_report::Device* device) { |
| fbl::AutoLock lock(&readers_lock_); |
| |
| auto report_builder = fuchsia_input_report::InputReport::Builder( |
| report_allocator_.make<fuchsia_input_report::InputReport::Frame>()); |
| |
| if (device->ParseInputReport(report, report_size, &report_allocator_, &report_builder) != |
| hid_input_report::ParseResult::kOk) { |
| zxlogf(ERROR, "ReceiveReport: Device failed to parse report correctly\n"); |
| return; |
| } |
| |
| report_builder.set_event_time(report_allocator_.make<zx_time_t>(time)); |
| report_builder.set_trace_id(report_allocator_.make<uint64_t>(TRACE_NONCE())); |
| |
| // If we are full, pop the oldest report. |
| if (reports_data_.full()) { |
| reports_data_.pop(); |
| } |
| |
| reports_data_.push(report_builder.build()); |
| TRACE_FLOW_BEGIN("input", "input_report", reports_data_.back().trace_id()); |
| |
| if (waiting_read_) { |
| SendReportsToWaitingRead(); |
| } |
| } |
| |
| } // namespace hid_input_report_dev |