142 lines
5.1 KiB
C++
142 lines
5.1 KiB
C++
/*
|
|
* 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.
|
|
*/
|
|
|
|
#ifndef ANDROID_HARDWARE_SENSORS_V2_1_CONVERT_H
|
|
#define ANDROID_HARDWARE_SENSORS_V2_1_CONVERT_H
|
|
|
|
#include <android/hardware/sensors/2.1/types.h>
|
|
#include <hardware/sensors.h>
|
|
#include <sensors/convert.h>
|
|
|
|
namespace android {
|
|
namespace hardware {
|
|
namespace sensors {
|
|
namespace V2_1 {
|
|
namespace implementation {
|
|
|
|
static_assert(sizeof(V1_0::Event) == sizeof(V2_1::Event),
|
|
"New and old Event types must have the same size");
|
|
static_assert(sizeof(V1_0::SensorInfo) == sizeof(V2_1::SensorInfo),
|
|
"New and old SensorInfo types must have the same size");
|
|
|
|
// The following conversion methods are safe as the only difference between
|
|
// V1_0 and V2_1 for these types is an added enum value to SensorType which doesn't
|
|
// change the memory layout of the types.
|
|
inline const V1_0::Event& convertToOldEvent(const V2_1::Event& event) {
|
|
return reinterpret_cast<const V1_0::Event&>(event);
|
|
}
|
|
|
|
inline const std::vector<V1_0::Event>& convertToOldEvents(const std::vector<V2_1::Event>& events) {
|
|
return reinterpret_cast<const std::vector<V1_0::Event>&>(events);
|
|
}
|
|
|
|
inline V1_0::Event* convertToOldEvent(V2_1::Event* event) {
|
|
return reinterpret_cast<V1_0::Event*>(event);
|
|
}
|
|
|
|
inline const V2_1::SensorInfo& convertToNewSensorInfo(const V1_0::SensorInfo& info) {
|
|
return reinterpret_cast<const V2_1::SensorInfo&>(info);
|
|
}
|
|
|
|
inline const V1_0::SensorInfo& convertToOldSensorInfo(const V2_1::SensorInfo& info) {
|
|
return reinterpret_cast<const V1_0::SensorInfo&>(info);
|
|
}
|
|
|
|
inline const V2_1::Event& convertToNewEvent(const V1_0::Event& event) {
|
|
return reinterpret_cast<const V2_1::Event&>(event);
|
|
}
|
|
|
|
inline const std::vector<V2_1::Event>& convertToNewEvents(const std::vector<V1_0::Event>& events) {
|
|
return reinterpret_cast<const std::vector<V2_1::Event>&>(events);
|
|
}
|
|
|
|
inline const hidl_vec<V2_1::Event>& convertToNewEvents(const hidl_vec<V1_0::Event>& events) {
|
|
return reinterpret_cast<const hidl_vec<V2_1::Event>&>(events);
|
|
}
|
|
|
|
inline const hidl_vec<V2_1::SensorInfo>& convertToNewSensorInfos(
|
|
const hidl_vec<V1_0::SensorInfo>& infos) {
|
|
return reinterpret_cast<const hidl_vec<V2_1::SensorInfo>&>(infos);
|
|
}
|
|
|
|
inline const hidl_vec<V1_0::SensorInfo>& convertToOldSensorInfos(
|
|
const hidl_vec<V2_1::SensorInfo>& infos) {
|
|
return reinterpret_cast<const hidl_vec<V1_0::SensorInfo>&>(infos);
|
|
}
|
|
|
|
inline void convertToSensor(const V2_1::SensorInfo& src, sensor_t* dst) {
|
|
dst->name = strdup(src.name.c_str());
|
|
dst->vendor = strdup(src.vendor.c_str());
|
|
dst->version = src.version;
|
|
dst->handle = src.sensorHandle;
|
|
dst->type = (int)src.type;
|
|
dst->maxRange = src.maxRange;
|
|
dst->resolution = src.resolution;
|
|
dst->power = src.power;
|
|
dst->minDelay = src.minDelay;
|
|
dst->fifoReservedEventCount = src.fifoReservedEventCount;
|
|
dst->fifoMaxEventCount = src.fifoMaxEventCount;
|
|
dst->stringType = strdup(src.typeAsString.c_str());
|
|
dst->requiredPermission = strdup(src.requiredPermission.c_str());
|
|
dst->maxDelay = src.maxDelay;
|
|
dst->flags = src.flags;
|
|
dst->reserved[0] = dst->reserved[1] = 0;
|
|
}
|
|
|
|
inline void convertFromSensorEvent(const sensors_event_t& src, V2_1::Event* dst) {
|
|
switch ((SensorType)src.type) {
|
|
case SensorType::HINGE_ANGLE:
|
|
// Only fill in values for hinge angle as other sensors
|
|
// will have it filled in by legacy code.
|
|
*dst = {
|
|
.timestamp = src.timestamp,
|
|
.sensorHandle = src.sensor,
|
|
.sensorType = (SensorType)src.type,
|
|
};
|
|
dst->u.scalar = src.data[0];
|
|
break;
|
|
default:
|
|
V1_0::implementation::convertFromSensorEvent(src, convertToOldEvent(dst));
|
|
break;
|
|
}
|
|
}
|
|
|
|
inline void convertToSensorEvent(const V2_1::Event& src, sensors_event_t* dst) {
|
|
switch (src.sensorType) {
|
|
case SensorType::HINGE_ANGLE:
|
|
// Only fill in values for hinge angle as other sensors
|
|
// will have it filled in by legacy code.
|
|
*dst = {.version = sizeof(sensors_event_t),
|
|
.sensor = src.sensorHandle,
|
|
.type = (int32_t)src.sensorType,
|
|
.reserved0 = 0,
|
|
.timestamp = src.timestamp};
|
|
dst->data[0] = src.u.scalar;
|
|
break;
|
|
default:
|
|
V1_0::implementation::convertToSensorEvent(convertToOldEvent(src), dst);
|
|
break;
|
|
}
|
|
}
|
|
|
|
} // namespace implementation
|
|
} // namespace V2_1
|
|
} // namespace sensors
|
|
} // namespace hardware
|
|
} // namespace android
|
|
|
|
#endif // ANDROID_HARDWARE_SENSORS_V2_1_CONVERT_H
|