| /* |
| * Copyright (C) 2017 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| #define LOG_TAG "HidRawSensorTest" |
| |
| #include "HidDevice.h" |
| #include "HidLog.h" |
| #include "HidLog.h" |
| #include "HidParser.h" |
| #include "HidRawSensor.h" |
| #include "HidSensorDef.h" |
| #include "StreamIoUtil.h" |
| #include "TestHidDescriptor.h" |
| #include "Utils.h" |
| |
| #include <deque> |
| #include <unordered_map> |
| |
| namespace android { |
| namespace SensorHalExt { |
| |
| class HidRawDummyDevice : public HidDevice { |
| public: |
| struct DataPair { |
| uint8_t id; |
| std::vector<uint8_t> data; |
| }; |
| |
| HidRawDummyDevice() { |
| // dummy values |
| mInfo = { |
| .name = "Test sensor name", |
| .physicalPath = "/physical/path", |
| .busType = "USB", |
| .vendorId = 0x1234, |
| .productId = 0x5678, |
| .descriptor = {0} |
| }; |
| } |
| |
| virtual const HidDeviceInfo& getDeviceInfo() { |
| return mInfo; |
| } |
| |
| // get feature from device |
| virtual bool getFeature(uint8_t id, std::vector<uint8_t> *out) { |
| auto i = mFeature.find(id); |
| if (i == mFeature.end()) { |
| return false; |
| } |
| *out = i->second; |
| return true; |
| } |
| |
| // write feature to device |
| virtual bool setFeature(uint8_t id, const std::vector<uint8_t> &in) { |
| auto i = mFeature.find(id); |
| if (i == mFeature.end() || in.size() != i->second.size()) { |
| return false; |
| } |
| i->second = in; |
| return true; |
| } |
| |
| // send report to default output endpoint |
| virtual bool sendReport(uint8_t id, std::vector<uint8_t> &data) { |
| DataPair pair = { |
| .id = id, |
| .data = data |
| }; |
| mOutput.push_back(pair); |
| return true; |
| } |
| |
| // receive from default input endpoint |
| virtual bool receiveReport(uint8_t * /*id*/, std::vector<uint8_t> * /*data*/) { |
| // not necessary, as input report can be directly feed to HidRawSensor for testing purpose |
| return false; |
| } |
| |
| bool dequeuOutputReport(DataPair *pair) { |
| if (!mOutput.empty()) { |
| return false; |
| } |
| *pair = mOutput.front(); |
| mOutput.pop_front(); |
| return true; |
| } |
| |
| private: |
| HidDeviceInfo mInfo; |
| std::deque<DataPair> mOutput; |
| std::unordered_map<uint8_t, std::vector<uint8_t>> mFeature; |
| }; |
| |
| class HidRawSensorTest { |
| public: |
| static bool test() { |
| bool ret = true; |
| using namespace Hid::Sensor::SensorTypeUsage; |
| std::unordered_set<unsigned int> interestedUsage{ |
| ACCELEROMETER_3D, GYROMETER_3D, COMPASS_3D, CUSTOM}; |
| SP(HidDevice) device(new HidRawDummyDevice()); |
| |
| HidParser hidParser; |
| for (const TestHidDescriptor *p = gDescriptorArray; ; ++p) { |
| if (p->data == nullptr || p->len == 0) { |
| break; |
| } |
| const char *name = p->name != nullptr ? p->name : "unnamed"; |
| if (!hidParser.parse(p->data, p->len)) { |
| LOG_E << name << " parsing error!" << LOG_ENDL; |
| ret = false; |
| continue; |
| } |
| |
| hidParser.filterTree(); |
| LOG_V << name << " digest: " << LOG_ENDL; |
| auto digestVector = hidParser.generateDigest(interestedUsage); |
| LOG_V << digestVector; |
| |
| if (digestVector.empty()) { |
| LOG_V << name << " does not contain interested usage" << LOG_ENDL; |
| continue; |
| } |
| |
| LOG_V << name << " sensor: " << LOG_ENDL; |
| for (const auto &digest : digestVector) { |
| LOG_I << "Sensor usage " << std::hex << digest.fullUsage << std::dec << LOG_ENDL; |
| auto *s = new HidRawSensor(device, digest.fullUsage, digest.packets); |
| if (s->mValid) { |
| LOG_V << "Usage " << std::hex << digest.fullUsage << std::dec << LOG_ENDL; |
| LOG_V << s->dump(); |
| } else { |
| LOG_V << "Sensor of usage " << std::hex << digest.fullUsage << std::dec |
| << " not valid!" << LOG_ENDL; |
| } |
| } |
| LOG_V << LOG_ENDL; |
| } |
| return ret; |
| } |
| }; |
| |
| }// namespace SensorHalExt |
| }// namespace android |
| |
| int main() { |
| return android::SensorHalExt::HidRawSensorTest::test() ? 0 : 1; |
| } |