src/ui/lib/input_reader/input_interpreter.cc - fuchsia - Git at Google

 // Copyright 2016 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 "src/ui/lib/input_reader/input_interpreter.h"

 #include <fuchsia/hardware/input/c/fidl.h>
 #include <fuchsia/ui/input/cpp/fidl.h>
 #include <lib/fidl/cpp/clone.h>
 #include <sys/types.h>
 #include <sys/uio.h>
 #include <zircon/errors.h>
 #include <zircon/types.h>

 #include <hid-parser/descriptor.h>
 #include <hid-parser/parser.h>
 #include <hid-parser/report.h>
 #include <hid-parser/usages.h>
 #include <trace/event.h>

 #include "src/lib/fxl/arraysize.h"
 #include "src/lib/fxl/logging.h"
 #include "src/lib/fxl/time/time_point.h"
 #include "src/ui/lib/input_reader/device.h"
 #include "src/ui/lib/input_reader/fdio_hid_decoder.h"
 #include "src/ui/lib/input_reader/protocols.h"

 namespace {

 uint64_t CalculateTraceId(uint32_t trace_id, uint32_t report_id) {
   return (static_cast<uint64_t>(report_id) << 32) | (trace_id);
 }

 int64_t InputEventTimestampNow() { return fxl::TimePoint::Now().ToEpochDelta().ToNanoseconds(); }

 fuchsia::ui::input::InputReport CloneReport(const fuchsia::ui::input::InputReport& report) {
   fuchsia::ui::input::InputReport result;
   fidl::Clone(report, &result);
   return result;
 }

 }  // namespace

 namespace ui_input {

 InputInterpreter::InputInterpreter(std::unique_ptr<HidDecoder> hid_decoder,
                                    fuchsia::ui::input::InputDeviceRegistry* registry)
     : registry_(registry), hid_decoder_(std::move(hid_decoder)) {
   FXL_DCHECK(hid_decoder_);
 }

 InputInterpreter::~InputInterpreter() {
   if (hid_descriptor_) {
     hid::FreeDeviceDescriptor(hid_descriptor_);
   }
 }

 void InputInterpreter::DispatchReport(InputDevice* device) {
   device->report->event_time = InputEventTimestampNow();
   device->report->trace_id = TRACE_NONCE();
   TRACE_FLOW_BEGIN("input", "hid_read_to_listener", device->report->trace_id);
   device->input_device->DispatchReport(CloneReport(*device->report));
 }

 bool InputInterpreter::Initialize() {
   if (!hid_decoder_->Init())
     return false;

   if (!ParseProtocol())
     return false;

   hardcoded_.Initialize(protocol_);

   event_ = hid_decoder_->GetEvent();
   if (!event_)
     return false;

   NotifyRegistry();

   for (size_t i = 0; i < devices_.size(); i++) {
     InputDevice& device = devices_[i];
     // If we are a media button then query for an initial report.
     if (device.descriptor.protocol == Protocol::MediaButtons) {
       std::vector<uint8_t> initial_input;
       zx_status_t status = hid_decoder_->GetReport(HidDecoder::ReportType::INPUT,
                                                    device.device->ReportId(), &initial_input);
       if (status != ZX_OK) {
         return false;
       }
       if (device.device->ParseReport(initial_input.data(), initial_input.size(),
                                      device.report.get())) {
         DispatchReport(&device);
       }
     }
   }

   return true;
 }

 void InputInterpreter::NotifyRegistry() {
   hardcoded_.NotifyRegistry(registry_);

   // Register the generic device's descriptors.
   for (size_t i = 0; i < devices_.size(); i++) {
     fuchsia::ui::input::DeviceDescriptor descriptor;
     InputDevice& device = devices_[i];
     if (device.descriptor.has_keyboard) {
       fidl::Clone(device.descriptor.keyboard_descriptor, &descriptor.keyboard);
     }
     if (device.descriptor.has_mouse) {
       fidl::Clone(device.descriptor.mouse_descriptor, &descriptor.mouse);
     }
     if (device.descriptor.has_stylus) {
       fidl::Clone(device.descriptor.stylus_descriptor, &descriptor.stylus);
     }
     if (device.descriptor.has_touchscreen) {
       fidl::Clone(device.descriptor.touchscreen_descriptor, &descriptor.touchscreen);
     }
     if (device.descriptor.has_sensor) {
       fidl::Clone(device.descriptor.sensor_descriptor, &descriptor.sensor);
     }
     if (device.descriptor.has_media_buttons) {
       fidl::Clone(device.descriptor.buttons_descriptor, &descriptor.media_buttons);
     }
     registry_->RegisterDevice(std::move(descriptor), device.input_device.NewRequest());
   }
 }

 bool InputInterpreter::Read(bool discard) {
   TRACE_DURATION("input", "hid_read");
   std::array<uint8_t, fuchsia_hardware_input_MAX_REPORT_DATA> report_data;

   size_t bytes_read = hid_decoder_->Read(report_data.data(), report_data.size());

   if (bytes_read == 0) {
     FXL_LOG(ERROR) << "Failed to read from input: " << bytes_read << " for " << name();
     // TODO(cpu) check whether the device was actually closed or not.
     return false;
   }

   size_t data_index = 0;
   while (data_index < bytes_read) {
     TRACE_FLOW_END("input", "hid_report", CalculateTraceId(trace_id_, reports_read_));
     ++reports_read_;

     uint8_t* report = &report_data[data_index];
     size_t report_size =
         hid::GetReportSizeFromFirstByte(*hid_descriptor_, hid::kReportInput, report[0]);
     if (report_size == 0) {
       FXL_LOG(ERROR) << "input_reader: Unable to get Report Size from Id " << report[0] << " : "
                      << name();
       return false;
     }

     hardcoded_.Read(report, report_size, discard);

     for (auto& device : devices_) {
       if (!device.device->MatchesReportId(report[0])) {
         continue;
       }
       if (device.device->ParseReport(report, report_size, device.report.get()) && !discard) {
         DispatchReport(&device);
       }
     }
     data_index += report_size;
   }

   return true;
 }

 Protocol InputInterpreter::ExtractProtocol(hid::Usage input) {
   using ::hid::usage::Consumer;
   using ::hid::usage::Digitizer;
   using ::hid::usage::GenericDesktop;
   using ::hid::usage::Page;
   using ::hid::usage::Sensor;
   struct {
     hid::Usage usage;
     Protocol protocol;
   } usage_to_protocol[] = {
       {{static_cast<uint16_t>(Page::kConsumer), static_cast<uint32_t>(Consumer::kConsumerControl)},
        Protocol::MediaButtons},
       {{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kTouchScreen)},
        Protocol::Touch},
       {{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kTouchPad)},
        Protocol::Touchpad},
       {{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kStylus)},
        Protocol::Stylus},
       {{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kPen)},
        Protocol::Stylus},
       {{static_cast<uint16_t>(Page::kGenericDesktop),
         static_cast<uint32_t>(GenericDesktop::kMouse)},
        Protocol::Mouse},
       {{static_cast<uint16_t>(Page::kGenericDesktop),
         static_cast<uint32_t>(GenericDesktop::kPointer)},
        Protocol::Pointer},
       {{static_cast<uint16_t>(Page::kGenericDesktop),
         static_cast<uint32_t>(GenericDesktop::kKeyboard)},
        Protocol::Keyboard},
       // Add more sensors here
   };

   if (input.page == Page::kSensor) {
     return Protocol::Sensor;
   }

   for (auto& j : usage_to_protocol) {
     if (input.page == j.usage.page && input.usage == j.usage.usage) {
       return j.protocol;
     }
   }
   return Protocol::Other;
 }

 bool InputInterpreter::ParseHidFeatureReportDescriptor(const hid::ReportDescriptor& report_desc) {
   // Traverse up the nested collections to the Application collection.
   auto collection = report_desc.input_fields[0].col;
   while (collection != nullptr) {
     if (collection->type == hid::CollectionType::kApplication) {
       break;
     }
     collection = collection->parent;
   }

   if (collection == nullptr) {
     FXL_LOG(INFO) << "Can't process HID feature report descriptor for " << name()
                   << "; Needed a valid Collection but didn't get one";
     return false;
   }

   // If we have a touchscreen feature report then we enable multitouch mode.
   if (collection->usage ==
       hid::USAGE(hid::usage::Page::kDigitizer, hid::usage::Digitizer::kTouchScreenConfiguration)) {
     std::vector<uint8_t> feature_report(report_desc.feature_byte_sz);
     if (report_desc.report_id != 0) {
       feature_report[0] = report_desc.report_id;
     }
     for (size_t i = 0; i < report_desc.feature_count; i++) {
       const hid::ReportField& field = report_desc.input_fields[i];
       if (field.attr.usage ==
           hid::USAGE(hid::usage::Page::kDigitizer, hid::usage::Digitizer::kTouchScreenInputMode)) {
         InsertUint(feature_report.data(), feature_report.size(), field.attr,
                    static_cast<uint32_t>(hid::usage::TouchScreenInputMode::kMultipleInput));
       }
     }
     hid_decoder_->Send(HidDecoder::ReportType::FEATURE, report_desc.report_id, feature_report);
   }
   return true;
 }

 bool InputInterpreter::ParseHidInputReportDescriptor(const hid::ReportDescriptor* input_desc) {
   FXL_CHECK(input_desc);

   // Traverse up the nested collections to the Application collection.
   hid::Collection* collection = input_desc->input_fields[0].col;
   while (collection != nullptr) {
     if (collection->type == hid::CollectionType::kApplication) {
       break;
     }
     collection = collection->parent;
   }

   if (collection == nullptr) {
     FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
                   << "; Needed a valid Collection but didn't get one";
     return false;
   }

   InputDevice input_device = {};
   input_device.report = fuchsia::ui::input::InputReport::New();

   // Most modern gamepads report themselves as Joysticks. Madness.
   if (collection->usage.page == hid::usage::Page::kGenericDesktop &&
       collection->usage.usage == hid::usage::GenericDesktop::kJoystick &&
       hardcoded_.ParseGamepadDescriptor(input_desc->input_fields, input_desc->input_count)) {
     protocol_ = Protocol::Gamepad;
     return true;
   } else {
     protocol_ = ExtractProtocol(collection->usage);
     switch (protocol_) {
       case Protocol::LightSensor:
         hardcoded_.ParseAmbientLightDescriptor(input_desc->input_fields, input_desc->input_count);
         return true;
       case Protocol::MediaButtons: {
         FXL_VLOG(2) << "Device " << name() << " has HID media buttons";

         input_device.device = std::make_unique<Buttons>();
         input_device.report->media_buttons = fuchsia::ui::input::MediaButtonsReport::New();
         break;
       }
       case Protocol::Pointer: {
         FXL_VLOG(2) << "Device " << name() << " has HID pointer";

         input_device.device = std::make_unique<Pointer>();
         input_device.report->touchscreen = fuchsia::ui::input::TouchscreenReport::New();
         break;
       }
       case Protocol::Sensor: {
         FXL_VLOG(2) << "Device " << name() << " has HID sensor";

         input_device.device = std::make_unique<Sensor>();
         input_device.report->sensor = fuchsia::ui::input::SensorReport::New();
         break;
       }
       case Protocol::Touchpad: {
         FXL_VLOG(2) << "Device " << name() << " has HID touchpad";

         input_device.device = std::make_unique<Touchpad>();
         input_device.report->mouse = fuchsia::ui::input::MouseReport::New();
         break;
       }
       case Protocol::Touch: {
         FXL_VLOG(2) << "Device " << name() << " has HID touch";

         input_device.device = std::make_unique<TouchScreen>();
         input_device.report->touchscreen = fuchsia::ui::input::TouchscreenReport::New();
         break;
       }
       case Protocol::Mouse: {
         FXL_VLOG(2) << "Device " << name() << " has HID mouse";

         input_device.device = std::make_unique<Mouse>();
         input_device.report->mouse = fuchsia::ui::input::MouseReport::New();
         break;
       }
       case Protocol::Keyboard: {
         FXL_VLOG(2) << "Device " << name() << " has HID keyboard";

         input_device.device = std::make_unique<Keyboard>();
         input_device.report->keyboard = fuchsia::ui::input::KeyboardReport::New();
         break;
       }
       case Protocol::Stylus: {
         FXL_VLOG(2) << "Device " << name() << " has HID stylus";

         input_device.device = std::make_unique<Stylus>();
         input_device.report->stylus = fuchsia::ui::input::StylusReport::New();
         break;
       }
       // Add more protocols here
       default:
         // Not being able to match on a given HID report descriptor is not
         // an error and will happen frequently. We only need to match a single
         // report in the report descriptor to be valid.
         return true;
     }
   }

   if (!input_device.device->ParseReportDescriptor(*input_desc, &input_device.descriptor)) {
     FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
                   << "; Failed to do generic device parsing";
     return false;
   }
   devices_.push_back(std::move(input_device));

   FXL_LOG(INFO) << "hid-parser successful for " << name() << " with usage page "
                 << collection->usage.page << " and usage " << collection->usage.usage;

   return true;
 }

 bool InputInterpreter::ParseProtocol() {
   trace_id_ = hid_decoder_->GetTraceId();

   // Read and parse the hid desccriptor.
   int desc_size;
   const std::vector<uint8_t>& desc = hid_decoder_->ReadReportDescriptor(&desc_size);
   if (desc_size <= 0) {
     return false;
   }
   hid::ParseResult parse_res =
       hid::ParseReportDescriptor(desc.data(), desc.size(), &hid_descriptor_);
   if (parse_res != hid::ParseResult::kParseOk) {
     FXL_LOG(INFO) << "hid-parser: error " << int(parse_res) << " parsing report descriptor for "
                   << name();
     return false;
   }

   // Check the boot mode. For most keyboards and mouses Zircon requests the boot protocol
   // which has a fixed layout. This covers the following two cases:
   HidDecoder::BootMode boot_mode = hid_decoder_->ReadBootMode();
   if (boot_mode == HidDecoder::BootMode::MOUSE) {
     protocol_ = Protocol::BootMouse;
     return true;
   }

   // Check the report descriptor against a hardcoded one. This involves memcmp() of the
   // known hardcoded descriptors.
   Protocol protocol = hardcoded_.MatchProtocol(desc, hid_decoder_.get());
   if (protocol != Protocol::Other) {
     protocol_ = protocol;
     return true;
   }

   // For the rest of devices we use the new way; with the hid-parser
   // library.
   auto count = hid_descriptor_->rep_count;
   if (count == 0) {
     FXL_LOG(ERROR) << "no report descriptors for " << name();
     return false;
   }

   // Parse each input report.
   for (size_t rep = 0; rep < count; rep++) {
     const hid::ReportDescriptor* desc = &hid_descriptor_->report[rep];
     if (desc->input_count != 0) {
       if (!ParseHidInputReportDescriptor(desc)) {
         continue;
       }
     }
     if (desc->feature_count != 0) {
       if (!ParseHidFeatureReportDescriptor(*desc)) {
         return false;
       }
     }
   }

   // If we never parsed a single device correctly then fail.
   if (devices_.size() == 0) {
     FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
                   << "; All parsing attempts failed.";
     return false;
   }

   return true;
 }

 }  // namespace ui_input
	// Copyright 2016 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 "src/ui/lib/input_reader/input_interpreter.h"

	#include <fuchsia/hardware/input/c/fidl.h>
	#include <fuchsia/ui/input/cpp/fidl.h>
	#include <lib/fidl/cpp/clone.h>
	#include <sys/types.h>
	#include <sys/uio.h>
	#include <zircon/errors.h>
	#include <zircon/types.h>

	#include <hid-parser/descriptor.h>
	#include <hid-parser/parser.h>
	#include <hid-parser/report.h>
	#include <hid-parser/usages.h>
	#include <trace/event.h>

	#include "src/lib/fxl/arraysize.h"
	#include "src/lib/fxl/logging.h"
	#include "src/lib/fxl/time/time_point.h"
	#include "src/ui/lib/input_reader/device.h"
	#include "src/ui/lib/input_reader/fdio_hid_decoder.h"
	#include "src/ui/lib/input_reader/protocols.h"

	namespace {

	uint64_t CalculateTraceId(uint32_t trace_id, uint32_t report_id) {
	return (static_cast<uint64_t>(report_id) << 32) \| (trace_id);
	}

	int64_t InputEventTimestampNow() { return fxl::TimePoint::Now().ToEpochDelta().ToNanoseconds(); }

	fuchsia::ui::input::InputReport CloneReport(const fuchsia::ui::input::InputReport& report) {
	fuchsia::ui::input::InputReport result;
	fidl::Clone(report, &result);
	return result;
	}

	} // namespace

	namespace ui_input {

	InputInterpreter::InputInterpreter(std::unique_ptr<HidDecoder> hid_decoder,
	fuchsia::ui::input::InputDeviceRegistry* registry)
	: registry_(registry), hid_decoder_(std::move(hid_decoder)) {
	FXL_DCHECK(hid_decoder_);
	}

	InputInterpreter::~InputInterpreter() {
	if (hid_descriptor_) {
	hid::FreeDeviceDescriptor(hid_descriptor_);
	}
	}

	void InputInterpreter::DispatchReport(InputDevice* device) {
	device->report->event_time = InputEventTimestampNow();
	device->report->trace_id = TRACE_NONCE();
	TRACE_FLOW_BEGIN("input", "hid_read_to_listener", device->report->trace_id);
	device->input_device->DispatchReport(CloneReport(*device->report));
	}

	bool InputInterpreter::Initialize() {
	if (!hid_decoder_->Init())
	return false;

	if (!ParseProtocol())
	return false;

	hardcoded_.Initialize(protocol_);

	event_ = hid_decoder_->GetEvent();
	if (!event_)
	return false;

	NotifyRegistry();

	for (size_t i = 0; i < devices_.size(); i++) {
	InputDevice& device = devices_[i];
	// If we are a media button then query for an initial report.
	if (device.descriptor.protocol == Protocol::MediaButtons) {
	std::vector<uint8_t> initial_input;
	zx_status_t status = hid_decoder_->GetReport(HidDecoder::ReportType::INPUT,
	device.device->ReportId(), &initial_input);
	if (status != ZX_OK) {
	return false;
	}
	if (device.device->ParseReport(initial_input.data(), initial_input.size(),
	device.report.get())) {
	DispatchReport(&device);
	}
	}
	}

	return true;
	}

	void InputInterpreter::NotifyRegistry() {
	hardcoded_.NotifyRegistry(registry_);

	// Register the generic device's descriptors.
	for (size_t i = 0; i < devices_.size(); i++) {
	fuchsia::ui::input::DeviceDescriptor descriptor;
	InputDevice& device = devices_[i];
	if (device.descriptor.has_keyboard) {
	fidl::Clone(device.descriptor.keyboard_descriptor, &descriptor.keyboard);
	}
	if (device.descriptor.has_mouse) {
	fidl::Clone(device.descriptor.mouse_descriptor, &descriptor.mouse);
	}
	if (device.descriptor.has_stylus) {
	fidl::Clone(device.descriptor.stylus_descriptor, &descriptor.stylus);
	}
	if (device.descriptor.has_touchscreen) {
	fidl::Clone(device.descriptor.touchscreen_descriptor, &descriptor.touchscreen);
	}
	if (device.descriptor.has_sensor) {
	fidl::Clone(device.descriptor.sensor_descriptor, &descriptor.sensor);
	}
	if (device.descriptor.has_media_buttons) {
	fidl::Clone(device.descriptor.buttons_descriptor, &descriptor.media_buttons);
	}
	registry_->RegisterDevice(std::move(descriptor), device.input_device.NewRequest());
	}
	}

	bool InputInterpreter::Read(bool discard) {
	TRACE_DURATION("input", "hid_read");
	std::array<uint8_t, fuchsia_hardware_input_MAX_REPORT_DATA> report_data;

	size_t bytes_read = hid_decoder_->Read(report_data.data(), report_data.size());

	if (bytes_read == 0) {
	FXL_LOG(ERROR) << "Failed to read from input: " << bytes_read << " for " << name();
	// TODO(cpu) check whether the device was actually closed or not.
	return false;
	}

	size_t data_index = 0;
	while (data_index < bytes_read) {
	TRACE_FLOW_END("input", "hid_report", CalculateTraceId(trace_id_, reports_read_));
	++reports_read_;

	uint8_t* report = &report_data[data_index];
	size_t report_size =
	hid::GetReportSizeFromFirstByte(*hid_descriptor_, hid::kReportInput, report[0]);
	if (report_size == 0) {
	FXL_LOG(ERROR) << "input_reader: Unable to get Report Size from Id " << report[0] << " : "
	<< name();
	return false;
	}

	hardcoded_.Read(report, report_size, discard);

	for (auto& device : devices_) {
	if (!device.device->MatchesReportId(report[0])) {
	continue;
	}
	if (device.device->ParseReport(report, report_size, device.report.get()) && !discard) {
	DispatchReport(&device);
	}
	}
	data_index += report_size;
	}

	return true;
	}

	Protocol InputInterpreter::ExtractProtocol(hid::Usage input) {
	using ::hid::usage::Consumer;
	using ::hid::usage::Digitizer;
	using ::hid::usage::GenericDesktop;
	using ::hid::usage::Page;
	using ::hid::usage::Sensor;
	struct {
	hid::Usage usage;
	Protocol protocol;
	} usage_to_protocol[] = {
	{{static_cast<uint16_t>(Page::kConsumer), static_cast<uint32_t>(Consumer::kConsumerControl)},
	Protocol::MediaButtons},
	{{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kTouchScreen)},
	Protocol::Touch},
	{{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kTouchPad)},
	Protocol::Touchpad},
	{{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kStylus)},
	Protocol::Stylus},
	{{static_cast<uint16_t>(Page::kDigitizer), static_cast<uint32_t>(Digitizer::kPen)},
	Protocol::Stylus},
	{{static_cast<uint16_t>(Page::kGenericDesktop),
	static_cast<uint32_t>(GenericDesktop::kMouse)},
	Protocol::Mouse},
	{{static_cast<uint16_t>(Page::kGenericDesktop),
	static_cast<uint32_t>(GenericDesktop::kPointer)},
	Protocol::Pointer},
	{{static_cast<uint16_t>(Page::kGenericDesktop),
	static_cast<uint32_t>(GenericDesktop::kKeyboard)},
	Protocol::Keyboard},
	// Add more sensors here
	};

	if (input.page == Page::kSensor) {
	return Protocol::Sensor;
	}

	for (auto& j : usage_to_protocol) {
	if (input.page == j.usage.page && input.usage == j.usage.usage) {
	return j.protocol;
	}
	}
	return Protocol::Other;
	}

	bool InputInterpreter::ParseHidFeatureReportDescriptor(const hid::ReportDescriptor& report_desc) {
	// Traverse up the nested collections to the Application collection.
	auto collection = report_desc.input_fields[0].col;
	while (collection != nullptr) {
	if (collection->type == hid::CollectionType::kApplication) {
	break;
	}
	collection = collection->parent;
	}

	if (collection == nullptr) {
	FXL_LOG(INFO) << "Can't process HID feature report descriptor for " << name()
	<< "; Needed a valid Collection but didn't get one";
	return false;
	}

	// If we have a touchscreen feature report then we enable multitouch mode.
	if (collection->usage ==
	hid::USAGE(hid::usage::Page::kDigitizer, hid::usage::Digitizer::kTouchScreenConfiguration)) {
	std::vector<uint8_t> feature_report(report_desc.feature_byte_sz);
	if (report_desc.report_id != 0) {
	feature_report[0] = report_desc.report_id;
	}
	for (size_t i = 0; i < report_desc.feature_count; i++) {
	const hid::ReportField& field = report_desc.input_fields[i];
	if (field.attr.usage ==
	hid::USAGE(hid::usage::Page::kDigitizer, hid::usage::Digitizer::kTouchScreenInputMode)) {
	InsertUint(feature_report.data(), feature_report.size(), field.attr,
	static_cast<uint32_t>(hid::usage::TouchScreenInputMode::kMultipleInput));
	}
	}
	hid_decoder_->Send(HidDecoder::ReportType::FEATURE, report_desc.report_id, feature_report);
	}
	return true;
	}

	bool InputInterpreter::ParseHidInputReportDescriptor(const hid::ReportDescriptor* input_desc) {
	FXL_CHECK(input_desc);

	// Traverse up the nested collections to the Application collection.
	hid::Collection* collection = input_desc->input_fields[0].col;
	while (collection != nullptr) {
	if (collection->type == hid::CollectionType::kApplication) {
	break;
	}
	collection = collection->parent;
	}

	if (collection == nullptr) {
	FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
	<< "; Needed a valid Collection but didn't get one";
	return false;
	}

	InputDevice input_device = {};
	input_device.report = fuchsia::ui::input::InputReport::New();

	// Most modern gamepads report themselves as Joysticks. Madness.
	if (collection->usage.page == hid::usage::Page::kGenericDesktop &&
	collection->usage.usage == hid::usage::GenericDesktop::kJoystick &&
	hardcoded_.ParseGamepadDescriptor(input_desc->input_fields, input_desc->input_count)) {
	protocol_ = Protocol::Gamepad;
	return true;
	} else {
	protocol_ = ExtractProtocol(collection->usage);
	switch (protocol_) {
	case Protocol::LightSensor:
	hardcoded_.ParseAmbientLightDescriptor(input_desc->input_fields, input_desc->input_count);
	return true;
	case Protocol::MediaButtons: {
	FXL_VLOG(2) << "Device " << name() << " has HID media buttons";

	input_device.device = std::make_unique<Buttons>();
	input_device.report->media_buttons = fuchsia::ui::input::MediaButtonsReport::New();
	break;
	}
	case Protocol::Pointer: {
	FXL_VLOG(2) << "Device " << name() << " has HID pointer";

	input_device.device = std::make_unique<Pointer>();
	input_device.report->touchscreen = fuchsia::ui::input::TouchscreenReport::New();
	break;
	}
	case Protocol::Sensor: {
	FXL_VLOG(2) << "Device " << name() << " has HID sensor";

	input_device.device = std::make_unique<Sensor>();
	input_device.report->sensor = fuchsia::ui::input::SensorReport::New();
	break;
	}
	case Protocol::Touchpad: {
	FXL_VLOG(2) << "Device " << name() << " has HID touchpad";

	input_device.device = std::make_unique<Touchpad>();
	input_device.report->mouse = fuchsia::ui::input::MouseReport::New();
	break;
	}
	case Protocol::Touch: {
	FXL_VLOG(2) << "Device " << name() << " has HID touch";

	input_device.device = std::make_unique<TouchScreen>();
	input_device.report->touchscreen = fuchsia::ui::input::TouchscreenReport::New();
	break;
	}
	case Protocol::Mouse: {
	FXL_VLOG(2) << "Device " << name() << " has HID mouse";

	input_device.device = std::make_unique<Mouse>();
	input_device.report->mouse = fuchsia::ui::input::MouseReport::New();
	break;
	}
	case Protocol::Keyboard: {
	FXL_VLOG(2) << "Device " << name() << " has HID keyboard";

	input_device.device = std::make_unique<Keyboard>();
	input_device.report->keyboard = fuchsia::ui::input::KeyboardReport::New();
	break;
	}
	case Protocol::Stylus: {
	FXL_VLOG(2) << "Device " << name() << " has HID stylus";

	input_device.device = std::make_unique<Stylus>();
	input_device.report->stylus = fuchsia::ui::input::StylusReport::New();
	break;
	}
	// Add more protocols here
	default:
	// Not being able to match on a given HID report descriptor is not
	// an error and will happen frequently. We only need to match a single
	// report in the report descriptor to be valid.
	return true;
	}
	}

	if (!input_device.device->ParseReportDescriptor(*input_desc, &input_device.descriptor)) {
	FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
	<< "; Failed to do generic device parsing";
	return false;
	}
	devices_.push_back(std::move(input_device));

	FXL_LOG(INFO) << "hid-parser successful for " << name() << " with usage page "
	<< collection->usage.page << " and usage " << collection->usage.usage;

	return true;
	}

	bool InputInterpreter::ParseProtocol() {
	trace_id_ = hid_decoder_->GetTraceId();

	// Read and parse the hid desccriptor.
	int desc_size;
	const std::vector<uint8_t>& desc = hid_decoder_->ReadReportDescriptor(&desc_size);
	if (desc_size <= 0) {
	return false;
	}
	hid::ParseResult parse_res =
	hid::ParseReportDescriptor(desc.data(), desc.size(), &hid_descriptor_);
	if (parse_res != hid::ParseResult::kParseOk) {
	FXL_LOG(INFO) << "hid-parser: error " << int(parse_res) << " parsing report descriptor for "
	<< name();
	return false;
	}

	// Check the boot mode. For most keyboards and mouses Zircon requests the boot protocol
	// which has a fixed layout. This covers the following two cases:
	HidDecoder::BootMode boot_mode = hid_decoder_->ReadBootMode();
	if (boot_mode == HidDecoder::BootMode::MOUSE) {
	protocol_ = Protocol::BootMouse;
	return true;
	}

	// Check the report descriptor against a hardcoded one. This involves memcmp() of the
	// known hardcoded descriptors.
	Protocol protocol = hardcoded_.MatchProtocol(desc, hid_decoder_.get());
	if (protocol != Protocol::Other) {
	protocol_ = protocol;
	return true;
	}

	// For the rest of devices we use the new way; with the hid-parser
	// library.
	auto count = hid_descriptor_->rep_count;
	if (count == 0) {
	FXL_LOG(ERROR) << "no report descriptors for " << name();
	return false;
	}

	// Parse each input report.
	for (size_t rep = 0; rep < count; rep++) {
	const hid::ReportDescriptor* desc = &hid_descriptor_->report[rep];
	if (desc->input_count != 0) {
	if (!ParseHidInputReportDescriptor(desc)) {
	continue;
	}
	}
	if (desc->feature_count != 0) {
	if (!ParseHidFeatureReportDescriptor(*desc)) {
	return false;
	}
	}
	}

	// If we never parsed a single device correctly then fail.
	if (devices_.size() == 0) {
	FXL_LOG(INFO) << "Can't process HID report descriptor for " << name()
	<< "; All parsing attempts failed.";
	return false;
	}

	return true;
	}

	} // namespace ui_input