1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
|
/*
* Copyright (C) 2020 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.
*/
#pragma once
#include <optional>
#include <string>
#include "InputMapper.h"
namespace android {
// sensor data vector length
static constexpr ssize_t SENSOR_VEC_LEN = 3;
class SensorInputMapper : public InputMapper {
public:
template <class T, class... Args>
friend std::unique_ptr<T> createInputMapper(InputDeviceContext& deviceContext,
const InputReaderConfiguration& readerConfig,
Args... args);
~SensorInputMapper() override;
uint32_t getSources() const override;
void populateDeviceInfo(InputDeviceInfo& deviceInfo) override;
void dump(std::string& dump) override;
[[nodiscard]] std::list<NotifyArgs> reconfigure(nsecs_t when,
const InputReaderConfiguration& config,
ConfigurationChanges changes) override;
[[nodiscard]] std::list<NotifyArgs> reset(nsecs_t when) override;
[[nodiscard]] std::list<NotifyArgs> process(const RawEvent* rawEvent) override;
bool enableSensor(InputDeviceSensorType sensorType, std::chrono::microseconds samplingPeriod,
std::chrono::microseconds maxBatchReportLatency) override;
void disableSensor(InputDeviceSensorType sensorType) override;
void flushSensor(InputDeviceSensorType sensorType) override;
private:
struct Axis {
explicit Axis(const RawAbsoluteAxisInfo& rawAxisInfo, const AxisInfo& axisInfo, float scale,
float offset, float min, float max, float flat, float fuzz, float resolution,
float filter)
: rawAxisInfo(rawAxisInfo),
axisInfo(axisInfo),
scale(scale),
offset(offset),
min(min),
max(max),
flat(flat),
fuzz(fuzz),
resolution(resolution),
filter(filter) {
resetValue();
}
RawAbsoluteAxisInfo rawAxisInfo;
AxisInfo axisInfo;
float scale; // scale factor from raw to normalized values
float offset; // offset to add after scaling for normalization
float min; // normalized inclusive minimum
float max; // normalized inclusive maximum
float flat; // normalized flat region size
float fuzz; // normalized error tolerance
float resolution; // normalized resolution in units
float filter; // filter out small variations of this size
float currentValue; // current value
float newValue; // most recent value
void resetValue() {
this->currentValue = 0;
this->newValue = 0;
}
};
struct Sensor {
explicit Sensor(const InputDeviceSensorInfo& sensorInfo) : sensorInfo(sensorInfo) {
resetValue();
}
bool enabled;
InputDeviceSensorAccuracy accuracy;
std::chrono::nanoseconds samplingPeriod;
std::chrono::nanoseconds maxBatchReportLatency;
// last sample time in nano seconds
std::optional<nsecs_t> lastSampleTimeNs;
InputDeviceSensorInfo sensorInfo;
// Sensor X, Y, Z data mapping to abs
std::array<int32_t, SENSOR_VEC_LEN> dataVec;
void resetValue() {
this->enabled = false;
this->accuracy = InputDeviceSensorAccuracy::ACCURACY_NONE;
this->samplingPeriod = std::chrono::nanoseconds(0);
this->maxBatchReportLatency = std::chrono::nanoseconds(0);
this->lastSampleTimeNs = std::nullopt;
}
};
explicit SensorInputMapper(InputDeviceContext& deviceContext,
const InputReaderConfiguration& readerConfig);
static Axis createAxis(const AxisInfo& AxisInfo, const RawAbsoluteAxisInfo& rawAxisInfo);
// Axes indexed by raw ABS_* axis index.
std::unordered_map<int32_t, Axis> mAxes;
// hardware timestamp from MSC_TIMESTAMP
nsecs_t mHardwareTimestamp;
uint32_t mPrevMscTime;
bool mDeviceEnabled;
// Does device support MSC_TIMESTAMP
bool mHasHardwareTimestamp;
// Sensor list
std::unordered_map<InputDeviceSensorType, Sensor> mSensors;
[[nodiscard]] std::list<NotifyArgs> sync(nsecs_t when, bool force);
void parseSensorConfiguration(InputDeviceSensorType sensorType, int32_t absCode,
int32_t sensorDataIndex, const Axis& axis);
void processHardWareTimestamp(nsecs_t evTime, int32_t evValue);
Sensor createSensor(InputDeviceSensorType sensorType, const Axis& axis);
bool setSensorEnabled(InputDeviceSensorType sensorType, bool enabled);
};
} // namespace android
|
