You can not select more than 25 topics Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
Kaleidoscope/testing/HIDState.cpp

173 lines
4.8 KiB

/* -*- mode: c++ -*-
* Copyright (C) 2020 Eric Paniagua (epaniagua@google.com)
*
* This program is free software: you can redistribute it and/or modify it under
* the terms of the GNU General Public License as published by the Free Software
* Foundation, version 3.
*
* This program is distributed in the hope that it will be useful, but WITHOUT
* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
* FOR A PARTICULAR PURPOSE. See the GNU General Public License for more
* details.
*
* You should have received a copy of the GNU General Public License along with
* this program. If not, see <http://www.gnu.org/licenses/>.
*/
#include "testing/HIDState.h"
#include "HID-Settings.h"
#include "testing/fix-macros.h"
// TODO(epan): Add proper logging.
#include <iostream>
#define LOG(x) std::cout
namespace kaleidoscope {
namespace testing {
const std::vector<AbsoluteMouseReport>& HIDState::AbsoluteMouse() const {
return absolute_mouse_reports_;
}
const AbsoluteMouseReport& HIDState::AbsoluteMouse(size_t i) const {
return absolute_mouse_reports_.at(i);
}
const std::vector<ConsumerControlReport>& HIDState::ConsumerControl() const {
return consumer_control_reports_;
}
const ConsumerControlReport& HIDState::ConsumerControl(size_t i) const {
return consumer_control_reports_.at(i);
}
const std::vector<KeyboardReport>& HIDState::Keyboard() const {
return keyboard_reports_;
}
const KeyboardReport& HIDState::Keyboard(size_t i) const {
return keyboard_reports_.at(i);
}
const std::vector<MouseReport>& HIDState::Mouse() const {
return mouse_reports_;
}
const MouseReport& HIDState::Mouse(size_t i) const {
return mouse_reports_.at(i);
}
const std::vector<SystemControlReport>& HIDState::SystemControl() const {
return system_control_reports_;
}
const SystemControlReport& HIDState::SystemControl(size_t i) const {
return system_control_reports_.at(i);
}
namespace internal {
// static
void HIDStateBuilder::ProcessHidReport(
uint8_t id, const void* data, int len, int result) {
switch (id) {
case HID_REPORTID_KEYBOARD: {
LOG(ERROR) << "Dropped BootKeyboardReport: unimplemented";
break;
}
case HID_REPORTID_GAMEPAD: {
LOG(ERROR) << "Dropped GamePadReport: unimplemented";
break;
}
case HID_REPORTID_CONSUMERCONTROL: {
ProcessConsumerControlReport(ConsumerControlReport{data});
break;
}
case HID_REPORTID_SYSTEMCONTROL: {
ProcessSystemControlReport(SystemControlReport{data});
break;
}
case HID_REPORTID_MOUSE: {
ProcessMouseReport(MouseReport{data});
break;
}
case HID_REPORTID_MOUSE_ABSOLUTE: {
ProcessAbsoluteMouseReport(AbsoluteMouseReport{data});
break;
}
case HID_REPORTID_NKRO_KEYBOARD: {
ProcessKeyboardReport(KeyboardReport{data});
break;
}
default:
LOG(ERROR) << "Encountered unknown HID report with id = " << id;
}
}
// static
std::unique_ptr<HIDState> HIDStateBuilder::Snapshot() {
auto hid_state = std::make_unique<HIDState>();
// Populate state.
// TODO: Grab a copy of current instantaneous state, like:
// key states, layer stack, led states
hid_state->absolute_mouse_reports_ = std::move(absolute_mouse_reports_);
hid_state->consumer_control_reports_ = std::move(consumer_control_reports_);
hid_state->keyboard_reports_ = std::move(keyboard_reports_);
hid_state->mouse_reports_ = std::move(mouse_reports_);
hid_state->system_control_reports_ = std::move(system_control_reports_);
Clear(); // Clear global state.
return hid_state;
}
// static
void HIDStateBuilder::Clear() {
absolute_mouse_reports_.clear();
consumer_control_reports_.clear();
keyboard_reports_.clear();
mouse_reports_.clear();
system_control_reports_.clear();
}
// static
void HIDStateBuilder::ProcessAbsoluteMouseReport(const AbsoluteMouseReport& report) {
absolute_mouse_reports_.push_back(report);
}
// static
void HIDStateBuilder::ProcessConsumerControlReport(const ConsumerControlReport& report) {
consumer_control_reports_.push_back(report);
}
// static
void HIDStateBuilder::ProcessKeyboardReport(const KeyboardReport& report) {
keyboard_reports_.push_back(report);
}
// static
void HIDStateBuilder::ProcessMouseReport(const MouseReport& report) {
mouse_reports_.push_back(report);
}
// static
void HIDStateBuilder::ProcessSystemControlReport(const SystemControlReport& report) {
system_control_reports_.push_back(report);
}
// static
std::vector<AbsoluteMouseReport> HIDStateBuilder::absolute_mouse_reports_;
// static
std::vector<ConsumerControlReport> HIDStateBuilder::consumer_control_reports_;
// static
std::vector<KeyboardReport> HIDStateBuilder::keyboard_reports_;
// static
std::vector<MouseReport> HIDStateBuilder::mouse_reports_;
// static
std::vector<SystemControlReport> HIDStateBuilder::system_control_reports_;
} // namesapce internal
} // namespace testing
} // namespace kaleidoscope