Implements HidlSensorHalWrapper
Bug: 195593357
Test: manually
Change-Id: Id3116859a054635b21690676aa841e32451f2407
diff --git a/services/sensorservice/Android.bp b/services/sensorservice/Android.bp
index b596708..dccbeb0 100644
--- a/services/sensorservice/Android.bp
+++ b/services/sensorservice/Android.bp
@@ -15,6 +15,7 @@
"CorrectedGyroSensor.cpp",
"Fusion.cpp",
"GravitySensor.cpp",
+ "HidlSensorHalWrapper.cpp",
"LinearAccelerationSensor.cpp",
"OrientationSensor.cpp",
"RecentEventLogger.cpp",
diff --git a/services/sensorservice/HidlSensorHalWrapper.cpp b/services/sensorservice/HidlSensorHalWrapper.cpp
new file mode 100644
index 0000000..f64a827
--- /dev/null
+++ b/services/sensorservice/HidlSensorHalWrapper.cpp
@@ -0,0 +1,585 @@
+/*
+ * Copyright (C) 2021 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.
+ */
+
+#include "HidlSensorHalWrapper.h"
+#include "android/hardware/sensors/2.0/types.h"
+#include "android/hardware/sensors/2.1/ISensorsCallback.h"
+#include "android/hardware/sensors/2.1/types.h"
+#include "convertV2_1.h"
+
+#include <android-base/logging.h>
+
+using android::hardware::hidl_vec;
+using android::hardware::sensors::V1_0::RateLevel;
+using android::hardware::sensors::V1_0::Result;
+using android::hardware::sensors::V1_0::SharedMemFormat;
+using android::hardware::sensors::V1_0::SharedMemInfo;
+using android::hardware::sensors::V1_0::SharedMemType;
+using android::hardware::sensors::V2_0::EventQueueFlagBits;
+using android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
+using android::hardware::sensors::V2_1::Event;
+using android::hardware::sensors::V2_1::ISensorsCallback;
+using android::hardware::sensors::V2_1::implementation::convertFromSensorEvent;
+using android::hardware::sensors::V2_1::implementation::convertToNewEvents;
+using android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos;
+using android::hardware::sensors::V2_1::implementation::convertToSensor;
+using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV1_0;
+using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_0;
+using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_1;
+
+namespace android {
+
+namespace {
+
+status_t statusFromResult(Result result) {
+ switch (result) {
+ case Result::OK:
+ return OK;
+ case Result::BAD_VALUE:
+ return BAD_VALUE;
+ case Result::PERMISSION_DENIED:
+ return PERMISSION_DENIED;
+ case Result::INVALID_OPERATION:
+ return INVALID_OPERATION;
+ case Result::NO_MEMORY:
+ return NO_MEMORY;
+ }
+}
+
+template <typename EnumType>
+constexpr typename std::underlying_type<EnumType>::type asBaseType(EnumType value) {
+ return static_cast<typename std::underlying_type<EnumType>::type>(value);
+}
+
+enum EventQueueFlagBitsInternal : uint32_t {
+ INTERNAL_WAKE = 1 << 16,
+};
+
+} // anonymous namespace
+
+void SensorsHalDeathReceiver::serviceDied(
+ uint64_t /* cookie */, const wp<::android::hidl::base::V1_0::IBase>& /* service */) {
+ ALOGW("Sensors HAL died, attempting to reconnect.");
+ mHidlSensorHalWrapper->prepareForReconnect();
+}
+
+struct SensorsCallback : public ISensorsCallback {
+ using Result = ::android::hardware::sensors::V1_0::Result;
+ using SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;
+
+ SensorsCallback(ISensorHalWrapper::SensorDeviceCallback* sensorDeviceCallback) {
+ mSensorDeviceCallback = sensorDeviceCallback;
+ }
+
+ Return<void> onDynamicSensorsConnected_2_1(
+ const hidl_vec<SensorInfo>& dynamicSensorsAdded) override {
+ std::vector<sensor_t> sensors;
+ for (const android::hardware::sensors::V2_1::SensorInfo& info : dynamicSensorsAdded) {
+ sensor_t sensor;
+ convertToSensor(info, &sensor);
+ sensors.push_back(sensor);
+ }
+
+ mSensorDeviceCallback->onDynamicSensorsConnected(sensors);
+ return Return<void>();
+ }
+
+ Return<void> onDynamicSensorsConnected(
+ const hidl_vec<android::hardware::sensors::V1_0::SensorInfo>& dynamicSensorsAdded)
+ override {
+ return onDynamicSensorsConnected_2_1(convertToNewSensorInfos(dynamicSensorsAdded));
+ }
+
+ Return<void> onDynamicSensorsDisconnected(
+ const hidl_vec<int32_t>& dynamicSensorHandlesRemoved) override {
+ mSensorDeviceCallback->onDynamicSensorsDisconnected(dynamicSensorHandlesRemoved);
+ return Return<void>();
+ }
+
+private:
+ ISensorHalWrapper::SensorDeviceCallback* mSensorDeviceCallback;
+};
+
+bool HidlSensorHalWrapper::supportsPolling() {
+ return mSensors->supportsPolling();
+}
+
+bool HidlSensorHalWrapper::supportsMessageQueues() {
+ return mSensors->supportsMessageQueues();
+}
+
+bool HidlSensorHalWrapper::connect(SensorDeviceCallback* callback) {
+ mSensorDeviceCallback = callback;
+ bool ret = connectHidlService();
+ if (mEventQueueFlag != nullptr) {
+ mEventQueueFlag->wake(asBaseType(INTERNAL_WAKE));
+ }
+ return ret;
+}
+
+void HidlSensorHalWrapper::prepareForReconnect() {
+ mReconnecting = true;
+ if (mEventQueueFlag != nullptr) {
+ mEventQueueFlag->wake(asBaseType(INTERNAL_WAKE));
+ }
+}
+
+ssize_t HidlSensorHalWrapper::poll(sensors_event_t* buffer, size_t count) {
+ ssize_t err;
+ int numHidlTransportErrors = 0;
+ bool hidlTransportError = false;
+
+ do {
+ auto ret = mSensors->poll(
+ count, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) {
+ if (result == Result::OK) {
+ convertToSensorEventsAndQuantize(convertToNewEvents(events),
+ convertToNewSensorInfos(
+ dynamicSensorsAdded),
+ buffer);
+ err = (ssize_t)events.size();
+ } else {
+ err = statusFromResult(result);
+ }
+ });
+
+ if (ret.isOk()) {
+ hidlTransportError = false;
+ } else {
+ hidlTransportError = true;
+ numHidlTransportErrors++;
+ if (numHidlTransportErrors > 50) {
+ // Log error and bail
+ ALOGE("Max Hidl transport errors this cycle : %d", numHidlTransportErrors);
+ handleHidlDeath(ret.description());
+ } else {
+ std::this_thread::sleep_for(std::chrono::milliseconds(10));
+ }
+ }
+ } while (hidlTransportError);
+
+ if (numHidlTransportErrors > 0) {
+ ALOGE("Saw %d Hidl transport failures", numHidlTransportErrors);
+ HidlTransportErrorLog errLog(time(nullptr), numHidlTransportErrors);
+ mHidlTransportErrors.add(errLog);
+ mTotalHidlTransportErrors++;
+ }
+
+ return err;
+}
+
+ssize_t HidlSensorHalWrapper::pollFmq(sensors_event_t* buffer, size_t maxNumEventsToRead) {
+ ssize_t eventsRead = 0;
+ size_t availableEvents = mSensors->getEventQueue()->availableToRead();
+
+ if (availableEvents == 0) {
+ uint32_t eventFlagState = 0;
+
+ // Wait for events to become available. This is necessary so that the Event FMQ's read() is
+ // able to be called with the correct number of events to read. If the specified number of
+ // events is not available, then read() would return no events, possibly introducing
+ // additional latency in delivering events to applications.
+ if (mEventQueueFlag != nullptr) {
+ mEventQueueFlag->wait(asBaseType(EventQueueFlagBits::READ_AND_PROCESS) |
+ asBaseType(INTERNAL_WAKE),
+ &eventFlagState);
+ }
+ availableEvents = mSensors->getEventQueue()->availableToRead();
+
+ if ((eventFlagState & asBaseType(INTERNAL_WAKE)) && mReconnecting) {
+ ALOGD("Event FMQ internal wake, returning from poll with no events");
+ return DEAD_OBJECT;
+ }
+ }
+
+ size_t eventsToRead = std::min({availableEvents, maxNumEventsToRead, mEventBuffer.size()});
+ if (eventsToRead > 0) {
+ if (mSensors->getEventQueue()->read(mEventBuffer.data(), eventsToRead)) {
+ // Notify the Sensors HAL that sensor events have been read. This is required to support
+ // the use of writeBlocking by the Sensors HAL.
+ if (mEventQueueFlag != nullptr) {
+ mEventQueueFlag->wake(asBaseType(EventQueueFlagBits::EVENTS_READ));
+ }
+
+ for (size_t i = 0; i < eventsToRead; i++) {
+ convertToSensorEvent(mEventBuffer[i], &buffer[i]);
+ android::SensorDeviceUtils::quantizeSensorEventValues(&buffer[i],
+ getResolutionForSensor(
+ buffer[i].sensor));
+ }
+ eventsRead = eventsToRead;
+ } else {
+ ALOGW("Failed to read %zu events, currently %zu events available", eventsToRead,
+ availableEvents);
+ }
+ }
+
+ return eventsRead;
+}
+
+std::vector<sensor_t> HidlSensorHalWrapper::getSensorsList() {
+ std::vector<sensor_t> sensorsFound;
+ if (mSensors != nullptr) {
+ checkReturn(mSensors->getSensorsList([&](const auto& list) {
+ for (size_t i = 0; i < list.size(); i++) {
+ sensor_t sensor;
+ convertToSensor(list[i], &sensor);
+ sensorsFound.push_back(sensor);
+
+ // Only disable all sensors on HAL 1.0 since HAL 2.0
+ // handles this in its initialize method
+ if (!mSensors->supportsMessageQueues()) {
+ checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
+ }
+ }
+ }));
+ }
+
+ return sensorsFound;
+}
+
+status_t HidlSensorHalWrapper::setOperationMode(SensorService::Mode mode) {
+ if (mSensors == nullptr) return NO_INIT;
+ return checkReturnAndGetStatus(
+ mSensors->setOperationMode(static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
+}
+
+status_t HidlSensorHalWrapper::activate(int32_t sensorHandle, bool enabled) {
+ if (mSensors == nullptr) return NO_INIT;
+ return checkReturnAndGetStatus(mSensors->activate(sensorHandle, enabled));
+}
+
+status_t HidlSensorHalWrapper::batch(int32_t sensorHandle, int64_t samplingPeriodNs,
+ int64_t maxReportLatencyNs) {
+ if (mSensors == nullptr) return NO_INIT;
+ return checkReturnAndGetStatus(
+ mSensors->batch(sensorHandle, samplingPeriodNs, maxReportLatencyNs));
+}
+
+status_t HidlSensorHalWrapper::flush(int32_t sensorHandle) {
+ if (mSensors == nullptr) return NO_INIT;
+ return checkReturnAndGetStatus(mSensors->flush(sensorHandle));
+}
+
+status_t HidlSensorHalWrapper::injectSensorData(const sensors_event_t* event) {
+ if (mSensors == nullptr) return NO_INIT;
+
+ Event ev;
+ convertFromSensorEvent(*event, &ev);
+ return checkReturnAndGetStatus(mSensors->injectSensorData(ev));
+}
+
+status_t HidlSensorHalWrapper::registerDirectChannel(const sensors_direct_mem_t* memory,
+ int32_t* /*channelHandle*/) {
+ if (mSensors == nullptr) return NO_INIT;
+
+ SharedMemType type;
+ switch (memory->type) {
+ case SENSOR_DIRECT_MEM_TYPE_ASHMEM:
+ type = SharedMemType::ASHMEM;
+ break;
+ case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
+ type = SharedMemType::GRALLOC;
+ break;
+ default:
+ return BAD_VALUE;
+ }
+
+ SharedMemFormat format;
+ if (memory->format != SENSOR_DIRECT_FMT_SENSORS_EVENT) {
+ return BAD_VALUE;
+ }
+ format = SharedMemFormat::SENSORS_EVENT;
+
+ SharedMemInfo mem = {
+ .type = type,
+ .format = format,
+ .size = static_cast<uint32_t>(memory->size),
+ .memoryHandle = memory->handle,
+ };
+
+ status_t ret;
+ checkReturn(mSensors->registerDirectChannel(mem, [&ret](auto result, auto channelHandle) {
+ if (result == Result::OK) {
+ ret = channelHandle;
+ } else {
+ ret = statusFromResult(result);
+ }
+ }));
+ return ret;
+}
+
+status_t HidlSensorHalWrapper::unregisterDirectChannel(int32_t channelHandle) {
+ if (mSensors == nullptr) return NO_INIT;
+ return checkReturnAndGetStatus(mSensors->unregisterDirectChannel(channelHandle));
+}
+
+status_t HidlSensorHalWrapper::configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
+ const struct sensors_direct_cfg_t* config) {
+ if (mSensors == nullptr) return NO_INIT;
+
+ RateLevel rate;
+ switch (config->rate_level) {
+ case SENSOR_DIRECT_RATE_STOP:
+ rate = RateLevel::STOP;
+ break;
+ case SENSOR_DIRECT_RATE_NORMAL:
+ rate = RateLevel::NORMAL;
+ break;
+ case SENSOR_DIRECT_RATE_FAST:
+ rate = RateLevel::FAST;
+ break;
+ case SENSOR_DIRECT_RATE_VERY_FAST:
+ rate = RateLevel::VERY_FAST;
+ break;
+ default:
+ return BAD_VALUE;
+ }
+
+ status_t ret;
+ checkReturn(mSensors->configDirectReport(sensorHandle, channelHandle, rate,
+ [&ret, rate](auto result, auto token) {
+ if (rate == RateLevel::STOP) {
+ ret = statusFromResult(result);
+ } else {
+ if (result == Result::OK) {
+ ret = token;
+ } else {
+ ret = statusFromResult(result);
+ }
+ }
+ }));
+
+ return ret;
+}
+
+void HidlSensorHalWrapper::writeWakeLockHandled(uint32_t count) {
+ if (mWakeLockQueue->write(&count)) {
+ mWakeLockQueueFlag->wake(asBaseType(WakeLockQueueFlagBits::DATA_WRITTEN));
+ } else {
+ ALOGW("Failed to write wake lock handled");
+ }
+}
+
+void HidlSensorHalWrapper::onDynamicSensorsConnected(
+ const std::vector<sensor_t>& dynamicSensorsAdded) {
+ std::unique_lock<std::mutex> lock(mDynamicSensorsMutex);
+
+ // Allocate a sensor_t structure for each dynamic sensor added and insert
+ // it into the dictionary of connected dynamic sensors keyed by handle.
+ for (size_t i = 0; i < dynamicSensorsAdded.size(); ++i) {
+ const sensor_t& sensor = dynamicSensorsAdded[i];
+
+ auto it = mConnectedDynamicSensors.find(sensor.handle);
+ CHECK(it == mConnectedDynamicSensors.end());
+
+ mConnectedDynamicSensors.insert(std::make_pair(sensor.handle, sensor));
+ }
+
+ mDynamicSensorsCv.notify_all();
+}
+
+void HidlSensorHalWrapper::onDynamicSensorsDisconnected(
+ const std::vector<int32_t>& /*dynamicSensorHandlesRemoved*/) {
+ // TODO: Currently dynamic sensors do not seem to be removed
+}
+
+status_t HidlSensorHalWrapper::checkReturnAndGetStatus(const hardware::Return<Result>& ret) {
+ checkReturn(ret);
+ return (!ret.isOk()) ? DEAD_OBJECT : statusFromResult(ret);
+}
+
+void HidlSensorHalWrapper::handleHidlDeath(const std::string& detail) {
+ if (!mSensors->supportsMessageQueues()) {
+ // restart is the only option at present.
+ LOG_ALWAYS_FATAL("Abort due to ISensors hidl service failure, detail: %s.", detail.c_str());
+ } else {
+ ALOGD("ISensors HAL died, death recipient will attempt reconnect");
+ }
+}
+
+bool HidlSensorHalWrapper::connectHidlService() {
+ HalConnectionStatus status = connectHidlServiceV2_1();
+ if (status == HalConnectionStatus::DOES_NOT_EXIST) {
+ status = connectHidlServiceV2_0();
+ }
+
+ if (status == HalConnectionStatus::DOES_NOT_EXIST) {
+ status = connectHidlServiceV1_0();
+ }
+ return (status == HalConnectionStatus::CONNECTED);
+}
+
+ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::connectHidlServiceV1_0() {
+ // SensorDevice will wait for HAL service to start if HAL is declared in device manifest.
+ size_t retry = 10;
+ HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
+
+ while (retry-- > 0) {
+ sp<android::hardware::sensors::V1_0::ISensors> sensors =
+ android::hardware::sensors::V1_0::ISensors::getService();
+ if (sensors == nullptr) {
+ // no sensor hidl service found
+ connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
+ break;
+ }
+
+ mSensors = new ISensorsWrapperV1_0(sensors);
+ mRestartWaiter->reset();
+ // Poke ISensor service. If it has lingering connection from previous generation of
+ // system server, it will kill itself. There is no intention to handle the poll result,
+ // which will be done since the size is 0.
+ if (mSensors->poll(0, [](auto, const auto&, const auto&) {}).isOk()) {
+ // ok to continue
+ connectionStatus = HalConnectionStatus::CONNECTED;
+ break;
+ }
+
+ // hidl service is restarting, pointer is invalid.
+ mSensors = nullptr;
+ connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
+ ALOGI("%s unsuccessful, remaining retry %zu.", __FUNCTION__, retry);
+ mRestartWaiter->wait();
+ }
+
+ return connectionStatus;
+}
+
+ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::connectHidlServiceV2_0() {
+ HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
+ sp<android::hardware::sensors::V2_0::ISensors> sensors =
+ android::hardware::sensors::V2_0::ISensors::getService();
+
+ if (sensors == nullptr) {
+ connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
+ } else {
+ mSensors = new ISensorsWrapperV2_0(sensors);
+ connectionStatus = initializeHidlServiceV2_X();
+ }
+
+ return connectionStatus;
+}
+
+ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::connectHidlServiceV2_1() {
+ HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
+ sp<android::hardware::sensors::V2_1::ISensors> sensors =
+ android::hardware::sensors::V2_1::ISensors::getService();
+
+ if (sensors == nullptr) {
+ connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
+ } else {
+ mSensors = new ISensorsWrapperV2_1(sensors);
+ connectionStatus = initializeHidlServiceV2_X();
+ }
+
+ return connectionStatus;
+}
+
+ISensorHalWrapper::HalConnectionStatus HidlSensorHalWrapper::initializeHidlServiceV2_X() {
+ HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
+
+ mWakeLockQueue =
+ std::make_unique<WakeLockQueue>(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
+ true /* configureEventFlagWord */);
+
+ hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
+ hardware::EventFlag::createEventFlag(mSensors->getEventQueue()->getEventFlagWord(),
+ &mEventQueueFlag);
+
+ hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
+ hardware::EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(), &mWakeLockQueueFlag);
+
+ CHECK(mSensors != nullptr && mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&
+ mWakeLockQueueFlag != nullptr);
+
+ mCallback = new SensorsCallback(mSensorDeviceCallback);
+ status_t status =
+ checkReturnAndGetStatus(mSensors->initialize(*mWakeLockQueue->getDesc(), mCallback));
+
+ if (status != NO_ERROR) {
+ connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
+ ALOGE("Failed to initialize Sensors HAL (%s)", strerror(-status));
+ } else {
+ connectionStatus = HalConnectionStatus::CONNECTED;
+ mSensorsHalDeathReceiver = new SensorsHalDeathReceiver(this);
+ mSensors->linkToDeath(mSensorsHalDeathReceiver, 0 /* cookie */);
+ }
+
+ return connectionStatus;
+}
+
+void HidlSensorHalWrapper::convertToSensorEvent(const Event& src, sensors_event_t* dst) {
+ android::hardware::sensors::V2_1::implementation::convertToSensorEvent(src, dst);
+
+ if (src.sensorType == android::hardware::sensors::V2_1::SensorType::DYNAMIC_SENSOR_META) {
+ const hardware::sensors::V1_0::DynamicSensorInfo& dyn = src.u.dynamic;
+
+ dst->dynamic_sensor_meta.connected = dyn.connected;
+ dst->dynamic_sensor_meta.handle = dyn.sensorHandle;
+ if (dyn.connected) {
+ std::unique_lock<std::mutex> lock(mDynamicSensorsMutex);
+ // Give MAX_DYN_SENSOR_WAIT_SEC for onDynamicSensorsConnected to be invoked since it
+ // can be received out of order from this event due to a bug in the HIDL spec that
+ // marks it as oneway.
+ auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
+ if (it == mConnectedDynamicSensors.end()) {
+ mDynamicSensorsCv.wait_for(lock, MAX_DYN_SENSOR_WAIT, [&, dyn] {
+ return mConnectedDynamicSensors.find(dyn.sensorHandle) !=
+ mConnectedDynamicSensors.end();
+ });
+ it = mConnectedDynamicSensors.find(dyn.sensorHandle);
+ CHECK(it != mConnectedDynamicSensors.end());
+ }
+
+ dst->dynamic_sensor_meta.sensor = &it->second;
+
+ memcpy(dst->dynamic_sensor_meta.uuid, dyn.uuid.data(),
+ sizeof(dst->dynamic_sensor_meta.uuid));
+ }
+ }
+}
+
+void HidlSensorHalWrapper::convertToSensorEventsAndQuantize(
+ const hidl_vec<Event>& src, const hidl_vec<SensorInfo>& dynamicSensorsAdded,
+ sensors_event_t* dst) {
+ if (dynamicSensorsAdded.size() > 0 && mCallback != nullptr) {
+ mCallback->onDynamicSensorsConnected_2_1(dynamicSensorsAdded);
+ }
+
+ for (size_t i = 0; i < src.size(); ++i) {
+ android::hardware::sensors::V2_1::implementation::convertToSensorEvent(src[i], &dst[i]);
+ android::SensorDeviceUtils::quantizeSensorEventValues(&dst[i],
+ getResolutionForSensor(
+ dst[i].sensor));
+ }
+}
+
+float HidlSensorHalWrapper::getResolutionForSensor(int sensorHandle) {
+ for (size_t i = 0; i < mSensorList.size(); i++) {
+ if (sensorHandle == mSensorList[i].handle) {
+ return mSensorList[i].resolution;
+ }
+ }
+
+ auto it = mConnectedDynamicSensors.find(sensorHandle);
+ if (it != mConnectedDynamicSensors.end()) {
+ return it->second.resolution;
+ }
+
+ return 0;
+}
+
+} // namespace android
diff --git a/services/sensorservice/HidlSensorHalWrapper.h b/services/sensorservice/HidlSensorHalWrapper.h
new file mode 100644
index 0000000..6542c6a
--- /dev/null
+++ b/services/sensorservice/HidlSensorHalWrapper.h
@@ -0,0 +1,187 @@
+/*
+ * Copyright (C) 2021 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_HIDL_SENSOR_HAL_WRAPPER_H
+#define ANDROID_HIDL_SENSOR_HAL_WRAPPER_H
+
+#include <sensor/SensorEventQueue.h>
+#include <utils/Singleton.h>
+
+#include "ISensorHalWrapper.h"
+
+#include "ISensorsWrapper.h"
+#include "SensorDeviceUtils.h"
+
+namespace android {
+
+using android::hardware::sensors::V1_0::Result;
+using android::hardware::sensors::V2_1::Event;
+using android::hardware::sensors::V2_1::SensorInfo;
+
+class HidlTransportErrorLog {
+public:
+ HidlTransportErrorLog() {
+ mTs = 0;
+ mCount = 0;
+ }
+
+ HidlTransportErrorLog(time_t ts, int count) {
+ mTs = ts;
+ mCount = count;
+ }
+
+ String8 toString() const {
+ String8 result;
+ struct tm* timeInfo = localtime(&mTs);
+ result.appendFormat("%02d:%02d:%02d :: %d", timeInfo->tm_hour, timeInfo->tm_min,
+ timeInfo->tm_sec, mCount);
+ return result;
+ }
+
+private:
+ time_t mTs; // timestamp of the error
+ int mCount; // number of transport errors observed
+};
+
+class SensorsHalDeathReceiver : public android::hardware::hidl_death_recipient {
+public:
+ SensorsHalDeathReceiver(ISensorHalWrapper* wrapper) : mHidlSensorHalWrapper(wrapper) {}
+
+ virtual void serviceDied(uint64_t cookie,
+ const wp<::android::hidl::base::V1_0::IBase>& service) override;
+
+private:
+ ISensorHalWrapper* mHidlSensorHalWrapper;
+};
+
+class HidlSensorHalWrapper : public ISensorHalWrapper {
+public:
+ HidlSensorHalWrapper()
+ : mHidlTransportErrors(20),
+ mRestartWaiter(new SensorDeviceUtils::HidlServiceRegistrationWaiter()),
+ mEventQueueFlag(nullptr),
+ mWakeLockQueueFlag(nullptr) {}
+
+ ~HidlSensorHalWrapper() override {
+ if (mEventQueueFlag != nullptr) {
+ hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
+ mEventQueueFlag = nullptr;
+ }
+ if (mWakeLockQueueFlag != nullptr) {
+ hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
+ mWakeLockQueueFlag = nullptr;
+ }
+ }
+ virtual bool connect(SensorDeviceCallback* callback) override;
+
+ virtual void prepareForReconnect() override;
+
+ virtual bool supportsPolling() override;
+
+ virtual bool supportsMessageQueues() override;
+
+ virtual ssize_t poll(sensors_event_t* buffer, size_t count) override;
+
+ virtual ssize_t pollFmq(sensors_event_t* buffer, size_t count) override;
+
+ virtual std::vector<sensor_t> getSensorsList() override;
+
+ virtual status_t setOperationMode(SensorService::Mode mode) override;
+
+ virtual status_t activate(int32_t sensorHandle, bool enabled) override;
+
+ virtual status_t batch(int32_t sensorHandle, int64_t samplingPeriodNs,
+ int64_t maxReportLatencyNs) override;
+
+ virtual status_t flush(int32_t sensorHandle) override;
+
+ virtual status_t injectSensorData(const sensors_event_t* event) override;
+
+ virtual status_t registerDirectChannel(const sensors_direct_mem_t* memory,
+ int32_t* channelHandle) override;
+
+ virtual status_t unregisterDirectChannel(int32_t channelHandle) override;
+
+ virtual status_t configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
+ const struct sensors_direct_cfg_t* config) override;
+
+ virtual void onDynamicSensorsConnected(
+ const std::vector<sensor_t>& dynamicSensorsAdded) override;
+
+ virtual void onDynamicSensorsDisconnected(
+ const std::vector<int32_t>& dynamicSensorHandlesRemoved) override;
+
+ virtual void writeWakeLockHandled(uint32_t count) override;
+
+private:
+ sp<::android::hardware::sensors::V2_1::implementation::ISensorsWrapperBase> mSensors;
+ sp<::android::hardware::sensors::V2_1::ISensorsCallback> mCallback;
+ std::vector<sensor_t> mSensorList;
+ std::unordered_map<int32_t, sensor_t> mConnectedDynamicSensors;
+
+ std::mutex mDynamicSensorsMutex;
+ std::condition_variable mDynamicSensorsCv;
+ static constexpr std::chrono::seconds MAX_DYN_SENSOR_WAIT{5};
+
+ // Keep track of any hidl transport failures
+ SensorServiceUtil::RingBuffer<HidlTransportErrorLog> mHidlTransportErrors;
+ int mTotalHidlTransportErrors;
+
+ SensorDeviceCallback* mSensorDeviceCallback = nullptr;
+
+ // TODO(b/67425500): remove waiter after bug is resolved.
+ sp<SensorDeviceUtils::HidlServiceRegistrationWaiter> mRestartWaiter;
+
+ template <typename T>
+ void checkReturn(const hardware::Return<T>& ret) {
+ if (!ret.isOk()) {
+ handleHidlDeath(ret.description());
+ }
+ }
+
+ status_t checkReturnAndGetStatus(const hardware::Return<Result>& ret);
+
+ void handleHidlDeath(const std::string& detail);
+
+ void convertToSensorEvent(const Event& src, sensors_event_t* dst);
+
+ void convertToSensorEventsAndQuantize(const hardware::hidl_vec<Event>& src,
+ const hardware::hidl_vec<SensorInfo>& dynamicSensorsAdded,
+ sensors_event_t* dst);
+
+ bool connectHidlService();
+
+ HalConnectionStatus connectHidlServiceV1_0();
+ HalConnectionStatus connectHidlServiceV2_0();
+ HalConnectionStatus connectHidlServiceV2_1();
+ HalConnectionStatus initializeHidlServiceV2_X();
+
+ typedef hardware::MessageQueue<uint32_t, hardware::kSynchronizedReadWrite> WakeLockQueue;
+ std::unique_ptr<WakeLockQueue> mWakeLockQueue;
+
+ float getResolutionForSensor(int sensorHandle);
+
+ hardware::EventFlag* mEventQueueFlag;
+ hardware::EventFlag* mWakeLockQueueFlag;
+
+ std::array<Event, SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT> mEventBuffer;
+
+ sp<SensorsHalDeathReceiver> mSensorsHalDeathReceiver;
+};
+
+} // namespace android
+
+#endif // ANDROID_HIDL_SENSOR_HAL_WRAPPER_H
diff --git a/services/sensorservice/ISensorHalWrapper.h b/services/sensorservice/ISensorHalWrapper.h
index c9e089e..7a51685 100644
--- a/services/sensorservice/ISensorHalWrapper.h
+++ b/services/sensorservice/ISensorHalWrapper.h
@@ -30,26 +30,45 @@
*/
class ISensorHalWrapper {
public:
- class ICallback : public ISensorsCallback {
-
- void onDynamicSensorsConnected(
+ class SensorDeviceCallback {
+ public:
+ virtual void onDynamicSensorsConnected(
const std::vector<sensor_t> &dynamicSensorsAdded) = 0;
- void onDynamicSensorsDisconnected(
+ virtual void onDynamicSensorsDisconnected(
const std::vector<int32_t> &dynamicSensorHandlesRemoved) = 0;
+
+ virtual ~SensorDeviceCallback(){};
};
+ enum HalConnectionStatus {
+ CONNECTED, // Successfully connected to the HAL
+ DOES_NOT_EXIST, // Could not find the HAL
+ FAILED_TO_CONNECT, // Found the HAL but failed to connect/initialize
+ UNKNOWN,
+ };
+
+ virtual ~ISensorHalWrapper(){};
+
/**
* Connects to the underlying sensors HAL. This should also be used for any reconnections
* due to HAL resets.
*/
- virtual bool connect(ICallback *callback) = 0;
+ virtual bool connect(SensorDeviceCallback *callback) = 0;
+
+ virtual void prepareForReconnect() = 0;
+
+ virtual bool supportsPolling() = 0;
+
+ virtual bool supportsMessageQueues() = 0;
/**
* Polls for available sensor events. This could be using the traditional sensors
* polling or from a FMQ.
*/
- virtual ssize_t poll(sensors_event_t* buffer, size_t count) = 0;
+ virtual ssize_t poll(sensors_event_t *buffer, size_t count) = 0;
+
+ virtual ssize_t pollFmq(sensors_event_t *buffer, size_t maxNumEventsToRead) = 0;
/**
* The below functions directly mirrors the sensors HAL definitions.
@@ -70,11 +89,20 @@
virtual status_t registerDirectChannel(const sensors_direct_mem_t *memory,
int32_t *channelHandle) = 0;
- virtual void unregisterDirectChannel(int32_t channelHandle) = 0;
+ virtual status_t unregisterDirectChannel(int32_t channelHandle) = 0;
virtual status_t configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
const struct sensors_direct_cfg_t *config) = 0;
-}
+
+ virtual void onDynamicSensorsConnected(const std::vector<sensor_t> &dynamicSensorsAdded) = 0;
+
+ virtual void onDynamicSensorsDisconnected(
+ const std::vector<int32_t> &dynamicSensorHandlesRemoved) = 0;
+
+ virtual void writeWakeLockHandled(uint32_t count) = 0;
+
+ std::atomic_bool mReconnecting = false;
+};
} // namespace android
diff --git a/services/sensorservice/SensorDevice.cpp b/services/sensorservice/SensorDevice.cpp
index c67acbf..84a1076 100644
--- a/services/sensorservice/SensorDevice.cpp
+++ b/services/sensorservice/SensorDevice.cpp
@@ -17,7 +17,6 @@
#include "SensorDevice.h"
#include "android/hardware/sensors/2.0/types.h"
-#include "android/hardware/sensors/2.1/ISensorsCallback.h"
#include "android/hardware/sensors/2.1/types.h"
#include "convertV2_1.h"
@@ -35,21 +34,7 @@
#include <thread>
using namespace android::hardware::sensors;
-using namespace android::hardware::sensors::V1_0;
-using namespace android::hardware::sensors::V1_0::implementation;
-using android::hardware::hidl_vec;
using android::hardware::Return;
-using android::hardware::sensors::V2_0::EventQueueFlagBits;
-using android::hardware::sensors::V2_0::WakeLockQueueFlagBits;
-using android::hardware::sensors::V2_1::ISensorsCallback;
-using android::hardware::sensors::V2_1::implementation::convertToNewEvents;
-using android::hardware::sensors::V2_1::implementation::convertToNewSensorInfos;
-using android::hardware::sensors::V2_1::implementation::convertToOldSensorInfo;
-using android::hardware::sensors::V2_1::implementation::convertToSensor;
-using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV1_0;
-using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_0;
-using android::hardware::sensors::V2_1::implementation::ISensorsWrapperV2_1;
-using android::SensorDeviceUtils::HidlServiceRegistrationWaiter;
using android::util::ProtoOutputStream;
namespace android {
@@ -59,21 +44,6 @@
namespace {
-status_t statusFromResult(Result result) {
- switch (result) {
- case Result::OK:
- return OK;
- case Result::BAD_VALUE:
- return BAD_VALUE;
- case Result::PERMISSION_DENIED:
- return PERMISSION_DENIED;
- case Result::INVALID_OPERATION:
- return INVALID_OPERATION;
- case Result::NO_MEMORY:
- return NO_MEMORY;
- }
-}
-
template <typename EnumType>
constexpr typename std::underlying_type<EnumType>::type asBaseType(EnumType value) {
return static_cast<typename std::underlying_type<EnumType>::type>(value);
@@ -85,245 +55,98 @@
INTERNAL_WAKE = 1 << 16,
};
-} // anonymous namespace
-
-void SensorsHalDeathReceivier::serviceDied(
- uint64_t /* cookie */, const wp<::android::hidl::base::V1_0::IBase>& /* service */) {
- ALOGW("Sensors HAL died, attempting to reconnect.");
- SensorDevice::getInstance().prepareForReconnect();
-}
-
-struct SensorsCallback : public ISensorsCallback {
- using Result = ::android::hardware::sensors::V1_0::Result;
- using SensorInfo = ::android::hardware::sensors::V2_1::SensorInfo;
-
- Return<void> onDynamicSensorsConnected_2_1(
- const hidl_vec<SensorInfo>& dynamicSensorsAdded) override {
- std::vector<sensor_t> sensors;
- for (const V2_1::SensorInfo& info : dynamicSensorsAdded) {
- sensor_t sensor;
- convertToSensor(info, &sensor);
- sensors.push_back(sensor);
- }
-
- SensorDevice::getInstance().onDynamicSensorsConnected(sensors);
- return Return<void>();
- }
-
- Return<void> onDynamicSensorsConnected(
- const hidl_vec<V1_0::SensorInfo>& dynamicSensorsAdded) override {
- return onDynamicSensorsConnected_2_1(convertToNewSensorInfos(dynamicSensorsAdded));
- }
-
- Return<void> onDynamicSensorsDisconnected(
- const hidl_vec<int32_t>& dynamicSensorHandlesRemoved) override {
- SensorDevice::getInstance().onDynamicSensorsDisconnected(dynamicSensorHandlesRemoved);
- return Return<void>();
- }
+enum DevicePrivateBase : int32_t {
+ DEVICE_PRIVATE_BASE = 65536,
};
-SensorDevice::SensorDevice()
- : mHidlTransportErrors(20),
- mRestartWaiter(new HidlServiceRegistrationWaiter()),
- mEventQueueFlag(nullptr),
- mWakeLockQueueFlag(nullptr),
- mReconnecting(false) {
- if (!connectHidlService()) {
+} // anonymous namespace
+
+SensorDevice::SensorDevice() {
+ if (!connectHalService()) {
return;
}
initializeSensorList();
- mIsDirectReportSupported =
- (checkReturnAndGetStatus(mSensors->unregisterDirectChannel(-1)) != INVALID_OPERATION);
+ mIsDirectReportSupported = (mHalWrapper->unregisterDirectChannel(-1) != INVALID_OPERATION);
}
void SensorDevice::initializeSensorList() {
- checkReturn(mSensors->getSensorsList([&](const auto& list) {
- const size_t count = list.size();
+ if (mHalWrapper == nullptr) {
+ return;
+ }
- mActivationCount.setCapacity(count);
- Info model;
- for (size_t i = 0; i < count; i++) {
- sensor_t sensor;
- convertToSensor(list[i], &sensor);
+ auto list = mHalWrapper->getSensorsList();
+ const size_t count = list.size();
- if (sensor.type < static_cast<int>(SensorType::DEVICE_PRIVATE_BASE)) {
- sensor.resolution = SensorDeviceUtils::resolutionForSensor(sensor);
+ mActivationCount.setCapacity(count);
+ Info model;
+ for (size_t i = 0; i < count; i++) {
+ sensor_t sensor = list[i];
- // Some sensors don't have a default resolution and will be left at 0.
- // Don't crash in this case since CTS will verify that devices don't go to
- // production with a resolution of 0.
- if (sensor.resolution != 0) {
- float quantizedRange = sensor.maxRange;
- SensorDeviceUtils::quantizeValue(&quantizedRange, sensor.resolution,
- /*factor=*/1);
- // Only rewrite maxRange if the requantization produced a "significant"
- // change, which is fairly arbitrarily defined as resolution / 8.
- // Smaller deltas are permitted, as they may simply be due to floating
- // point representation error, etc.
- if (fabsf(sensor.maxRange - quantizedRange) > sensor.resolution / 8) {
- ALOGW("%s's max range %.12f is not a multiple of the resolution "
- "%.12f - updated to %.12f",
- sensor.name, sensor.maxRange, sensor.resolution, quantizedRange);
- sensor.maxRange = quantizedRange;
- }
- } else {
- // Don't crash here or the device will go into a crashloop.
- ALOGW("%s should have a non-zero resolution", sensor.name);
+ if (sensor.type < DEVICE_PRIVATE_BASE) {
+ sensor.resolution = SensorDeviceUtils::resolutionForSensor(sensor);
+
+ // Some sensors don't have a default resolution and will be left at 0.
+ // Don't crash in this case since CTS will verify that devices don't go to
+ // production with a resolution of 0.
+ if (sensor.resolution != 0) {
+ float quantizedRange = sensor.maxRange;
+ SensorDeviceUtils::quantizeValue(&quantizedRange, sensor.resolution,
+ /*factor=*/1);
+ // Only rewrite maxRange if the requantization produced a "significant"
+ // change, which is fairly arbitrarily defined as resolution / 8.
+ // Smaller deltas are permitted, as they may simply be due to floating
+ // point representation error, etc.
+ if (fabsf(sensor.maxRange - quantizedRange) > sensor.resolution / 8) {
+ ALOGW("%s's max range %.12f is not a multiple of the resolution "
+ "%.12f - updated to %.12f",
+ sensor.name, sensor.maxRange, sensor.resolution, quantizedRange);
+ sensor.maxRange = quantizedRange;
}
- }
-
- // Check and clamp power if it is 0 (or close)
- constexpr float MIN_POWER_MA = 0.001; // 1 microAmp
- if (sensor.power < MIN_POWER_MA) {
- ALOGI("%s's reported power %f invalid, clamped to %f", sensor.name, sensor.power,
- MIN_POWER_MA);
- sensor.power = MIN_POWER_MA;
- }
- mSensorList.push_back(sensor);
-
- mActivationCount.add(list[i].sensorHandle, model);
-
- // Only disable all sensors on HAL 1.0 since HAL 2.0
- // handles this in its initialize method
- if (!mSensors->supportsMessageQueues()) {
- checkReturn(mSensors->activate(list[i].sensorHandle, 0 /* enabled */));
+ } else {
+ // Don't crash here or the device will go into a crashloop.
+ ALOGW("%s should have a non-zero resolution", sensor.name);
}
}
- }));
-}
-SensorDevice::~SensorDevice() {
- if (mEventQueueFlag != nullptr) {
- hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
- mEventQueueFlag = nullptr;
- }
-
- if (mWakeLockQueueFlag != nullptr) {
- hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
- mWakeLockQueueFlag = nullptr;
- }
-}
-
-bool SensorDevice::connectHidlService() {
- HalConnectionStatus status = connectHidlServiceV2_1();
- if (status == HalConnectionStatus::DOES_NOT_EXIST) {
- status = connectHidlServiceV2_0();
- }
-
- if (status == HalConnectionStatus::DOES_NOT_EXIST) {
- status = connectHidlServiceV1_0();
- }
- return (status == HalConnectionStatus::CONNECTED);
-}
-
-SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV1_0() {
- // SensorDevice will wait for HAL service to start if HAL is declared in device manifest.
- size_t retry = 10;
- HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
-
- while (retry-- > 0) {
- sp<V1_0::ISensors> sensors = V1_0::ISensors::getService();
- if (sensors == nullptr) {
- // no sensor hidl service found
- connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
- break;
+ // Check and clamp power if it is 0 (or close)
+ constexpr float MIN_POWER_MA = 0.001; // 1 microAmp
+ if (sensor.power < MIN_POWER_MA) {
+ ALOGI("%s's reported power %f invalid, clamped to %f", sensor.name, sensor.power,
+ MIN_POWER_MA);
+ sensor.power = MIN_POWER_MA;
}
+ mSensorList.push_back(sensor);
- mSensors = new ISensorsWrapperV1_0(sensors);
- mRestartWaiter->reset();
- // Poke ISensor service. If it has lingering connection from previous generation of
- // system server, it will kill itself. There is no intention to handle the poll result,
- // which will be done since the size is 0.
- if (mSensors->poll(0, [](auto, const auto&, const auto&) {}).isOk()) {
- // ok to continue
- connectionStatus = HalConnectionStatus::CONNECTED;
- break;
+ mActivationCount.add(list[i].handle, model);
+
+ // Only disable all sensors on HAL 1.0 since HAL 2.0
+ // handles this in its initialize method
+ if (!mHalWrapper->supportsMessageQueues()) {
+ mHalWrapper->activate(list[i].handle, 0 /* enabled */);
}
-
- // hidl service is restarting, pointer is invalid.
- mSensors = nullptr;
- connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
- ALOGI("%s unsuccessful, remaining retry %zu.", __FUNCTION__, retry);
- mRestartWaiter->wait();
}
-
- return connectionStatus;
}
-SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV2_0() {
- HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
- sp<V2_0::ISensors> sensors = V2_0::ISensors::getService();
+SensorDevice::~SensorDevice() {}
- if (sensors == nullptr) {
- connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
- } else {
- mSensors = new ISensorsWrapperV2_0(sensors);
- connectionStatus = initializeHidlServiceV2_X();
+bool SensorDevice::connectHalService() {
+ std::unique_ptr<ISensorHalWrapper> hidl_wrapper = std::make_unique<HidlSensorHalWrapper>();
+ if (hidl_wrapper->connect(this)) {
+ mHalWrapper = std::move(hidl_wrapper);
+ return true;
}
-
- return connectionStatus;
-}
-
-SensorDevice::HalConnectionStatus SensorDevice::connectHidlServiceV2_1() {
- HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
- sp<V2_1::ISensors> sensors = V2_1::ISensors::getService();
-
- if (sensors == nullptr) {
- connectionStatus = HalConnectionStatus::DOES_NOT_EXIST;
- } else {
- mSensors = new ISensorsWrapperV2_1(sensors);
- connectionStatus = initializeHidlServiceV2_X();
- }
-
- return connectionStatus;
-}
-
-SensorDevice::HalConnectionStatus SensorDevice::initializeHidlServiceV2_X() {
- HalConnectionStatus connectionStatus = HalConnectionStatus::UNKNOWN;
-
- mWakeLockQueue =
- std::make_unique<WakeLockQueue>(SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT,
- true /* configureEventFlagWord */);
-
- hardware::EventFlag::deleteEventFlag(&mEventQueueFlag);
- hardware::EventFlag::createEventFlag(mSensors->getEventQueue()->getEventFlagWord(),
- &mEventQueueFlag);
-
- hardware::EventFlag::deleteEventFlag(&mWakeLockQueueFlag);
- hardware::EventFlag::createEventFlag(mWakeLockQueue->getEventFlagWord(), &mWakeLockQueueFlag);
-
- CHECK(mSensors != nullptr && mWakeLockQueue != nullptr && mEventQueueFlag != nullptr &&
- mWakeLockQueueFlag != nullptr);
-
- mCallback = new SensorsCallback();
- status_t status =
- checkReturnAndGetStatus(mSensors->initialize(*mWakeLockQueue->getDesc(), mCallback));
-
- if (status != NO_ERROR) {
- connectionStatus = HalConnectionStatus::FAILED_TO_CONNECT;
- ALOGE("Failed to initialize Sensors HAL (%s)", strerror(-status));
- } else {
- connectionStatus = HalConnectionStatus::CONNECTED;
- mSensorsHalDeathReceiver = new SensorsHalDeathReceivier();
- mSensors->linkToDeath(mSensorsHalDeathReceiver, 0 /* cookie */);
- }
-
- return connectionStatus;
+ // TODO: check aidl connection;
+ return false;
}
void SensorDevice::prepareForReconnect() {
- mReconnecting = true;
-
- // Wake up the polling thread so it returns and allows the SensorService to initiate
- // a reconnect.
- mEventQueueFlag->wake(asBaseType(INTERNAL_WAKE));
+ mHalWrapper->prepareForReconnect();
}
void SensorDevice::reconnect() {
Mutex::Autolock _l(mLock);
- mSensors = nullptr;
auto previousActivations = mActivationCount;
auto previousSensorList = mSensorList;
@@ -331,7 +154,7 @@
mActivationCount.clear();
mSensorList.clear();
- if (connectHidlService()) {
+ if (mHalWrapper->connect(this)) {
initializeSensorList();
if (sensorHandlesChanged(previousSensorList, mSensorList)) {
@@ -340,7 +163,7 @@
reactivateSensors(previousActivations);
}
}
- mReconnecting = false;
+ mHalWrapper->mReconnecting = false;
}
bool SensorDevice::sensorHandlesChanged(const std::vector<sensor_t>& oldSensorList,
@@ -422,14 +245,14 @@
if (connected) {
Info model;
mActivationCount.add(handle, model);
- checkReturn(mSensors->activate(handle, 0 /* enabled */));
+ mHalWrapper->activate(handle, 0 /* enabled */);
} else {
mActivationCount.removeItem(handle);
}
}
std::string SensorDevice::dump() const {
- if (mSensors == nullptr) return "HAL not initialized\n";
+ if (mHalWrapper == nullptr) return "HAL not initialized\n";
String8 result;
result.appendFormat("Total %zu h/w sensors, %zu running %zu disabled clients:\n",
@@ -476,7 +299,7 @@
*/
void SensorDevice::dump(ProtoOutputStream* proto) const {
using namespace service::SensorDeviceProto;
- if (mSensors == nullptr) {
+ if (mHalWrapper == nullptr) {
proto->write(INITIALIZED, false);
return;
}
@@ -511,17 +334,17 @@
}
status_t SensorDevice::initCheck() const {
- return mSensors != nullptr ? NO_ERROR : NO_INIT;
+ return mHalWrapper != nullptr ? NO_ERROR : NO_INIT;
}
ssize_t SensorDevice::poll(sensors_event_t* buffer, size_t count) {
- if (mSensors == nullptr) return NO_INIT;
+ if (mHalWrapper == nullptr) return NO_INIT;
ssize_t eventsRead = 0;
- if (mSensors->supportsMessageQueues()) {
- eventsRead = pollFmq(buffer, count);
- } else if (mSensors->supportsPolling()) {
- eventsRead = pollHal(buffer, count);
+ if (mHalWrapper->supportsMessageQueues()) {
+ eventsRead = mHalWrapper->pollFmq(buffer, count);
+ } else if (mHalWrapper->supportsPolling()) {
+ eventsRead = mHalWrapper->poll(buffer, count);
} else {
ALOGE("Must support polling or FMQ");
eventsRead = -1;
@@ -529,95 +352,6 @@
return eventsRead;
}
-ssize_t SensorDevice::pollHal(sensors_event_t* buffer, size_t count) {
- ssize_t err;
- int numHidlTransportErrors = 0;
- bool hidlTransportError = false;
-
- do {
- auto ret = mSensors->poll(
- count, [&](auto result, const auto& events, const auto& dynamicSensorsAdded) {
- if (result == Result::OK) {
- convertToSensorEventsAndQuantize(convertToNewEvents(events),
- convertToNewSensorInfos(
- dynamicSensorsAdded),
- buffer);
- err = (ssize_t)events.size();
- } else {
- err = statusFromResult(result);
- }
- });
-
- if (ret.isOk()) {
- hidlTransportError = false;
- } else {
- hidlTransportError = true;
- numHidlTransportErrors++;
- if (numHidlTransportErrors > 50) {
- // Log error and bail
- ALOGE("Max Hidl transport errors this cycle : %d", numHidlTransportErrors);
- handleHidlDeath(ret.description());
- } else {
- std::this_thread::sleep_for(std::chrono::milliseconds(10));
- }
- }
- } while (hidlTransportError);
-
- if (numHidlTransportErrors > 0) {
- ALOGE("Saw %d Hidl transport failures", numHidlTransportErrors);
- HidlTransportErrorLog errLog(time(nullptr), numHidlTransportErrors);
- mHidlTransportErrors.add(errLog);
- mTotalHidlTransportErrors++;
- }
-
- return err;
-}
-
-ssize_t SensorDevice::pollFmq(sensors_event_t* buffer, size_t maxNumEventsToRead) {
- ssize_t eventsRead = 0;
- size_t availableEvents = mSensors->getEventQueue()->availableToRead();
-
- if (availableEvents == 0) {
- uint32_t eventFlagState = 0;
-
- // Wait for events to become available. This is necessary so that the Event FMQ's read() is
- // able to be called with the correct number of events to read. If the specified number of
- // events is not available, then read() would return no events, possibly introducing
- // additional latency in delivering events to applications.
- mEventQueueFlag->wait(asBaseType(EventQueueFlagBits::READ_AND_PROCESS) |
- asBaseType(INTERNAL_WAKE),
- &eventFlagState);
- availableEvents = mSensors->getEventQueue()->availableToRead();
-
- if ((eventFlagState & asBaseType(INTERNAL_WAKE)) && mReconnecting) {
- ALOGD("Event FMQ internal wake, returning from poll with no events");
- return DEAD_OBJECT;
- }
- }
-
- size_t eventsToRead = std::min({availableEvents, maxNumEventsToRead, mEventBuffer.size()});
- if (eventsToRead > 0) {
- if (mSensors->getEventQueue()->read(mEventBuffer.data(), eventsToRead)) {
- // Notify the Sensors HAL that sensor events have been read. This is required to support
- // the use of writeBlocking by the Sensors HAL.
- mEventQueueFlag->wake(asBaseType(EventQueueFlagBits::EVENTS_READ));
-
- for (size_t i = 0; i < eventsToRead; i++) {
- convertToSensorEvent(mEventBuffer[i], &buffer[i]);
- android::SensorDeviceUtils::quantizeSensorEventValues(&buffer[i],
- getResolutionForSensor(
- buffer[i].sensor));
- }
- eventsRead = eventsToRead;
- } else {
- ALOGW("Failed to read %zu events, currently %zu events available", eventsToRead,
- availableEvents);
- }
- }
-
- return eventsRead;
-}
-
void SensorDevice::onDynamicSensorsConnected(const std::vector<sensor_t>& dynamicSensorsAdded) {
std::unique_lock<std::mutex> lock(mDynamicSensorsMutex);
@@ -641,12 +375,8 @@
}
void SensorDevice::writeWakeLockHandled(uint32_t count) {
- if (mSensors != nullptr && mSensors->supportsMessageQueues()) {
- if (mWakeLockQueue->write(&count)) {
- mWakeLockQueueFlag->wake(asBaseType(WakeLockQueueFlagBits::DATA_WRITTEN));
- } else {
- ALOGW("Failed to write wake lock handled");
- }
+ if (mHalWrapper != nullptr && mHalWrapper->supportsMessageQueues()) {
+ mHalWrapper->writeWakeLockHandled(count);
}
}
@@ -665,7 +395,7 @@
}
status_t SensorDevice::activate(void* ident, int handle, int enabled) {
- if (mSensors == nullptr) return NO_INIT;
+ if (mHalWrapper == nullptr) return NO_INIT;
Mutex::Autolock _l(mLock);
return activateLocked(ident, handle, enabled);
@@ -724,8 +454,8 @@
// events, and the best effort batch parameters might have changed.
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w batch 0x%08x %" PRId64 " %" PRId64,
handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
- checkReturn(mSensors->batch(handle, info.bestBatchParams.mTSample,
- info.bestBatchParams.mTBatch));
+ mHalWrapper->batch(handle, info.bestBatchParams.mTSample,
+ info.bestBatchParams.mTBatch);
}
} else {
// sensor wasn't enabled for this ident
@@ -756,7 +486,7 @@
status_t SensorDevice::doActivateHardwareLocked(int handle, bool enabled) {
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w activate handle=%d enabled=%d", handle,
enabled);
- status_t err = checkReturnAndGetStatus(mSensors->activate(handle, enabled));
+ status_t err = mHalWrapper->activate(handle, enabled);
ALOGE_IF(err, "Error %s sensor %d (%s)", enabled ? "activating" : "disabling", handle,
strerror(-err));
return err;
@@ -764,7 +494,7 @@
status_t SensorDevice::batch(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs) {
- if (mSensors == nullptr) return NO_INIT;
+ if (mHalWrapper == nullptr) return NO_INIT;
if (samplingPeriodNs < MINIMUM_EVENTS_PERIOD) {
samplingPeriodNs = MINIMUM_EVENTS_PERIOD;
@@ -801,8 +531,8 @@
status_t err = updateBatchParamsLocked(handle, info);
if (err != NO_ERROR) {
- ALOGE("sensor batch failed %p 0x%08x %" PRId64 " %" PRId64 " err=%s", mSensors.get(),
- handle, info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch, strerror(-err));
+ ALOGE("sensor batch failed 0x%08x %" PRId64 " %" PRId64 " err=%s", handle,
+ info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch, strerror(-err));
info.removeBatchParamsForIdent(ident);
}
@@ -825,8 +555,8 @@
if (prevBestBatchParams != info.bestBatchParams && info.numActiveClients() > 0) {
ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w BATCH 0x%08x %" PRId64 " %" PRId64, handle,
info.bestBatchParams.mTSample, info.bestBatchParams.mTBatch);
- err = checkReturnAndGetStatus(mSensors->batch(handle, info.bestBatchParams.mTSample,
- info.bestBatchParams.mTBatch));
+ err = mHalWrapper->batch(handle, info.bestBatchParams.mTSample,
+ info.bestBatchParams.mTBatch);
}
return err;
@@ -837,15 +567,12 @@
}
int SensorDevice::getHalDeviceVersion() const {
- if (mSensors == nullptr) return -1;
+ if (mHalWrapper == nullptr) return -1;
return SENSORS_DEVICE_API_VERSION_1_4;
}
-status_t SensorDevice::flush(void* ident, int handle) {
- if (mSensors == nullptr) return NO_INIT;
- if (isClientDisabled(ident)) return INVALID_OPERATION;
- ALOGD_IF(DEBUG_CONNECTIONS, "\t>>> actuating h/w flush %d", handle);
- return checkReturnAndGetStatus(mSensors->flush(handle));
+status_t SensorDevice::flush(void* /*ident*/, int handle) {
+ return mHalWrapper->flush(handle);
}
bool SensorDevice::isClientDisabled(void* ident) const {
@@ -928,7 +655,7 @@
}
void SensorDevice::enableAllSensors() {
- if (mSensors == nullptr) return;
+ if (mHalWrapper == nullptr) return;
Mutex::Autolock _l(mLock);
for (void* client : getDisabledClientsLocked()) {
@@ -943,13 +670,12 @@
const int sensor_handle = mActivationCount.keyAt(i);
ALOGD_IF(DEBUG_CONNECTIONS, "\t>> reenable actuating h/w sensor enable handle=%d ",
sensor_handle);
- status_t err = checkReturnAndGetStatus(mSensors->batch(sensor_handle,
- info.bestBatchParams.mTSample,
- info.bestBatchParams.mTBatch));
+ status_t err = mHalWrapper->batch(sensor_handle, info.bestBatchParams.mTSample,
+ info.bestBatchParams.mTBatch);
ALOGE_IF(err, "Error calling batch on sensor %d (%s)", sensor_handle, strerror(-err));
if (err == NO_ERROR) {
- err = checkReturnAndGetStatus(mSensors->activate(sensor_handle, 1 /* enabled */));
+ err = mHalWrapper->activate(sensor_handle, 1 /* enabled */);
ALOGE_IF(err, "Error activating sensor %d (%s)", sensor_handle, strerror(-err));
}
@@ -960,7 +686,7 @@
}
void SensorDevice::disableAllSensors() {
- if (mSensors == nullptr) return;
+ if (mHalWrapper == nullptr) return;
Mutex::Autolock _l(mLock);
for (size_t i = 0; i < mActivationCount.size(); ++i) {
Info& info = mActivationCount.editValueAt(i);
@@ -969,7 +695,7 @@
const int sensor_handle = mActivationCount.keyAt(i);
ALOGD_IF(DEBUG_CONNECTIONS, "\t>> actuating h/w sensor disable handle=%d ",
sensor_handle);
- checkReturn(mSensors->activate(sensor_handle, 0 /* enabled */));
+ mHalWrapper->activate(sensor_handle, 0 /* enabled */);
// Add all the connections that were registered for this sensor to the disabled
// clients list.
@@ -985,110 +711,29 @@
}
status_t SensorDevice::injectSensorData(const sensors_event_t* injected_sensor_event) {
- if (mSensors == nullptr) return NO_INIT;
- ALOGD_IF(DEBUG_CONNECTIONS,
- "sensor_event handle=%d ts=%" PRId64 " data=%.2f, %.2f, %.2f %.2f %.2f %.2f",
- injected_sensor_event->sensor, injected_sensor_event->timestamp,
- injected_sensor_event->data[0], injected_sensor_event->data[1],
- injected_sensor_event->data[2], injected_sensor_event->data[3],
- injected_sensor_event->data[4], injected_sensor_event->data[5]);
-
- Event ev;
- V2_1::implementation::convertFromSensorEvent(*injected_sensor_event, &ev);
-
- return checkReturnAndGetStatus(mSensors->injectSensorData(ev));
+ return mHalWrapper->injectSensorData(injected_sensor_event);
}
status_t SensorDevice::setMode(uint32_t mode) {
- if (mSensors == nullptr) return NO_INIT;
- return checkReturnAndGetStatus(
- mSensors->setOperationMode(static_cast<hardware::sensors::V1_0::OperationMode>(mode)));
+ if (mHalWrapper == nullptr) return NO_INIT;
+ return mHalWrapper->setOperationMode(static_cast<SensorService::Mode>(mode));
}
int32_t SensorDevice::registerDirectChannel(const sensors_direct_mem_t* memory) {
- if (mSensors == nullptr) return NO_INIT;
Mutex::Autolock _l(mLock);
- SharedMemType type;
- switch (memory->type) {
- case SENSOR_DIRECT_MEM_TYPE_ASHMEM:
- type = SharedMemType::ASHMEM;
- break;
- case SENSOR_DIRECT_MEM_TYPE_GRALLOC:
- type = SharedMemType::GRALLOC;
- break;
- default:
- return BAD_VALUE;
- }
-
- SharedMemFormat format;
- if (memory->format != SENSOR_DIRECT_FMT_SENSORS_EVENT) {
- return BAD_VALUE;
- }
- format = SharedMemFormat::SENSORS_EVENT;
-
- SharedMemInfo mem = {
- .type = type,
- .format = format,
- .size = static_cast<uint32_t>(memory->size),
- .memoryHandle = memory->handle,
- };
-
- int32_t ret;
- checkReturn(mSensors->registerDirectChannel(mem, [&ret](auto result, auto channelHandle) {
- if (result == Result::OK) {
- ret = channelHandle;
- } else {
- ret = statusFromResult(result);
- }
- }));
- return ret;
+ return mHalWrapper->registerDirectChannel(memory, nullptr);
}
void SensorDevice::unregisterDirectChannel(int32_t channelHandle) {
- if (mSensors == nullptr) return;
- Mutex::Autolock _l(mLock);
- checkReturn(mSensors->unregisterDirectChannel(channelHandle));
+ mHalWrapper->unregisterDirectChannel(channelHandle);
}
int32_t SensorDevice::configureDirectChannel(int32_t sensorHandle, int32_t channelHandle,
const struct sensors_direct_cfg_t* config) {
- if (mSensors == nullptr) return NO_INIT;
Mutex::Autolock _l(mLock);
- RateLevel rate;
- switch (config->rate_level) {
- case SENSOR_DIRECT_RATE_STOP:
- rate = RateLevel::STOP;
- break;
- case SENSOR_DIRECT_RATE_NORMAL:
- rate = RateLevel::NORMAL;
- break;
- case SENSOR_DIRECT_RATE_FAST:
- rate = RateLevel::FAST;
- break;
- case SENSOR_DIRECT_RATE_VERY_FAST:
- rate = RateLevel::VERY_FAST;
- break;
- default:
- return BAD_VALUE;
- }
-
- int32_t ret;
- checkReturn(mSensors->configDirectReport(sensorHandle, channelHandle, rate,
- [&ret, rate](auto result, auto token) {
- if (rate == RateLevel::STOP) {
- ret = statusFromResult(result);
- } else {
- if (result == Result::OK) {
- ret = token;
- } else {
- ret = statusFromResult(result);
- }
- }
- }));
-
- return ret;
+ return mHalWrapper->configureDirectChannel(sensorHandle, channelHandle, config);
}
// ---------------------------------------------------------------------------
@@ -1153,52 +798,6 @@
return mIsDirectReportSupported;
}
-void SensorDevice::convertToSensorEvent(const Event& src, sensors_event_t* dst) {
- V2_1::implementation::convertToSensorEvent(src, dst);
-
- if (src.sensorType == V2_1::SensorType::DYNAMIC_SENSOR_META) {
- const DynamicSensorInfo& dyn = src.u.dynamic;
-
- dst->dynamic_sensor_meta.connected = dyn.connected;
- dst->dynamic_sensor_meta.handle = dyn.sensorHandle;
- if (dyn.connected) {
- std::unique_lock<std::mutex> lock(mDynamicSensorsMutex);
- // Give MAX_DYN_SENSOR_WAIT_SEC for onDynamicSensorsConnected to be invoked since it
- // can be received out of order from this event due to a bug in the HIDL spec that
- // marks it as oneway.
- auto it = mConnectedDynamicSensors.find(dyn.sensorHandle);
- if (it == mConnectedDynamicSensors.end()) {
- mDynamicSensorsCv.wait_for(lock, MAX_DYN_SENSOR_WAIT, [&, dyn] {
- return mConnectedDynamicSensors.find(dyn.sensorHandle) !=
- mConnectedDynamicSensors.end();
- });
- it = mConnectedDynamicSensors.find(dyn.sensorHandle);
- CHECK(it != mConnectedDynamicSensors.end());
- }
-
- dst->dynamic_sensor_meta.sensor = &it->second;
-
- memcpy(dst->dynamic_sensor_meta.uuid, dyn.uuid.data(),
- sizeof(dst->dynamic_sensor_meta.uuid));
- }
- }
-}
-
-void SensorDevice::convertToSensorEventsAndQuantize(const hidl_vec<Event>& src,
- const hidl_vec<SensorInfo>& dynamicSensorsAdded,
- sensors_event_t* dst) {
- if (dynamicSensorsAdded.size() > 0 && mCallback != nullptr) {
- mCallback->onDynamicSensorsConnected_2_1(dynamicSensorsAdded);
- }
-
- for (size_t i = 0; i < src.size(); ++i) {
- V2_1::implementation::convertToSensorEvent(src[i], &dst[i]);
- android::SensorDeviceUtils::quantizeSensorEventValues(&dst[i],
- getResolutionForSensor(
- dst[i].sensor));
- }
-}
-
float SensorDevice::getResolutionForSensor(int sensorHandle) {
for (size_t i = 0; i < mSensorList.size(); i++) {
if (sensorHandle == mSensorList[i].handle) {
@@ -1214,19 +813,5 @@
return 0;
}
-void SensorDevice::handleHidlDeath(const std::string& detail) {
- if (!mSensors->supportsMessageQueues()) {
- // restart is the only option at present.
- LOG_ALWAYS_FATAL("Abort due to ISensors hidl service failure, detail: %s.", detail.c_str());
- } else {
- ALOGD("ISensors HAL died, death recipient will attempt reconnect");
- }
-}
-
-status_t SensorDevice::checkReturnAndGetStatus(const Return<Result>& ret) {
- checkReturn(ret);
- return (!ret.isOk()) ? DEAD_OBJECT : statusFromResult(ret);
-}
-
// ---------------------------------------------------------------------------
}; // namespace android
diff --git a/services/sensorservice/SensorDevice.h b/services/sensorservice/SensorDevice.h
index 314ddb8..80e77d9 100644
--- a/services/sensorservice/SensorDevice.h
+++ b/services/sensorservice/SensorDevice.h
@@ -17,12 +17,14 @@
#ifndef ANDROID_SENSOR_DEVICE_H
#define ANDROID_SENSOR_DEVICE_H
+#include "HidlSensorHalWrapper.h"
+#include "ISensorHalWrapper.h"
+
#include "ISensorsWrapper.h"
#include "SensorDeviceUtils.h"
#include "SensorService.h"
#include "SensorServiceUtils.h"
-#include <fmq/MessageQueue.h>
#include <sensor/Sensor.h>
#include <sensor/SensorEventQueue.h>
#include <stdint.h>
@@ -43,41 +45,12 @@
namespace android {
-using Result = ::android::hardware::sensors::V1_0::Result;
-
// ---------------------------------------------------------------------------
-class SensorsHalDeathReceivier : public android::hardware::hidl_death_recipient {
- virtual void serviceDied(uint64_t cookie,
- const wp<::android::hidl::base::V1_0::IBase>& service) override;
-};
-class SensorDevice : public Singleton<SensorDevice>, public SensorServiceUtil::Dumpable {
+class SensorDevice : public Singleton<SensorDevice>,
+ public SensorServiceUtil::Dumpable,
+ public ISensorHalWrapper::SensorDeviceCallback {
public:
- class HidlTransportErrorLog {
- public:
- HidlTransportErrorLog() {
- mTs = 0;
- mCount = 0;
- }
-
- HidlTransportErrorLog(time_t ts, int count) {
- mTs = ts;
- mCount = count;
- }
-
- String8 toString() const {
- String8 result;
- struct tm* timeInfo = localtime(&mTs);
- result.appendFormat("%02d:%02d:%02d :: %d", timeInfo->tm_hour, timeInfo->tm_min,
- timeInfo->tm_sec, mCount);
- return result;
- }
-
- private:
- time_t mTs; // timestamp of the error
- int mCount; // number of transport errors observed
- };
-
~SensorDevice();
void prepareForReconnect();
void reconnect();
@@ -112,12 +85,15 @@
status_t injectSensorData(const sensors_event_t* event);
void notifyConnectionDestroyed(void* ident);
- void onDynamicSensorsConnected(const std::vector<sensor_t>& dynamicSensorsAdded);
- void onDynamicSensorsDisconnected(const std::vector<int32_t>& dynamicSensorHandlesRemoved);
+ // SensorDeviceCallback
+ virtual void onDynamicSensorsConnected(
+ const std::vector<sensor_t>& dynamicSensorsAdded) override;
+ virtual void onDynamicSensorsDisconnected(
+ const std::vector<int32_t>& dynamicSensorHandlesRemoved) override;
void setUidStateForConnection(void* ident, SensorService::UidState state);
- bool isReconnecting() const { return mReconnecting; }
+ bool isReconnecting() const { return mHalWrapper->mReconnecting; }
bool isSensorActive(int handle) const;
@@ -132,8 +108,8 @@
private:
friend class Singleton<SensorDevice>;
- sp<::android::hardware::sensors::V2_1::implementation::ISensorsWrapperBase> mSensors;
- sp<::android::hardware::sensors::V2_1::ISensorsCallback> mCallback;
+ std::unique_ptr<ISensorHalWrapper> mHalWrapper;
+
std::vector<sensor_t> mSensorList;
std::unordered_map<int32_t, sensor_t> mConnectedDynamicSensors;
@@ -143,7 +119,6 @@
// HAL implementations.
std::mutex mDynamicSensorsMutex;
std::condition_variable mDynamicSensorsCv;
- static constexpr std::chrono::seconds MAX_DYN_SENSOR_WAIT{5};
static const nsecs_t MINIMUM_EVENTS_PERIOD = 1000000; // 1000 Hz
mutable Mutex mLock; // protect mActivationCount[].batchParams
@@ -203,8 +178,6 @@
};
DefaultKeyedVector<int, Info> mActivationCount;
- // Keep track of any hidl transport failures
- SensorServiceUtil::RingBuffer<HidlTransportErrorLog> mHidlTransportErrors;
int mTotalHidlTransportErrors;
/**
@@ -228,26 +201,13 @@
void removeDisabledReasonForIdentLocked(void* ident, DisabledReason reason);
SensorDevice();
- bool connectHidlService();
+ bool connectHalService();
void initializeSensorList();
void reactivateSensors(const DefaultKeyedVector<int, Info>& previousActivations);
static bool sensorHandlesChanged(const std::vector<sensor_t>& oldSensorList,
const std::vector<sensor_t>& newSensorList);
static bool sensorIsEquivalent(const sensor_t& prevSensor, const sensor_t& newSensor);
- enum HalConnectionStatus {
- CONNECTED, // Successfully connected to the HAL
- DOES_NOT_EXIST, // Could not find the HAL
- FAILED_TO_CONNECT, // Found the HAL but failed to connect/initialize
- UNKNOWN,
- };
- HalConnectionStatus connectHidlServiceV1_0();
- HalConnectionStatus connectHidlServiceV2_0();
- HalConnectionStatus connectHidlServiceV2_1();
- HalConnectionStatus initializeHidlServiceV2_X();
-
- ssize_t pollHal(sensors_event_t* buffer, size_t count);
- ssize_t pollFmq(sensors_event_t* buffer, size_t count);
status_t activateLocked(void* ident, int handle, int enabled);
status_t batchLocked(void* ident, int handle, int flags, int64_t samplingPeriodNs,
int64_t maxBatchReportLatencyNs);
@@ -255,47 +215,15 @@
status_t updateBatchParamsLocked(int handle, Info& info);
status_t doActivateHardwareLocked(int handle, bool enable);
- void handleHidlDeath(const std::string& detail);
- template <typename T>
- void checkReturn(const Return<T>& ret) {
- if (!ret.isOk()) {
- handleHidlDeath(ret.description());
- }
- }
-
- status_t checkReturnAndGetStatus(const Return<Result>& ret);
- // TODO(b/67425500): remove waiter after bug is resolved.
- sp<SensorDeviceUtils::HidlServiceRegistrationWaiter> mRestartWaiter;
-
bool isClientDisabled(void* ident) const;
bool isClientDisabledLocked(void* ident) const;
std::vector<void*> getDisabledClientsLocked() const;
bool clientHasNoAccessLocked(void* ident) const;
- using Event = hardware::sensors::V2_1::Event;
- using SensorInfo = hardware::sensors::V2_1::SensorInfo;
-
- void convertToSensorEvent(const Event& src, sensors_event_t* dst);
-
- void convertToSensorEventsAndQuantize(const hardware::hidl_vec<Event>& src,
- const hardware::hidl_vec<SensorInfo>& dynamicSensorsAdded,
- sensors_event_t* dst);
-
float getResolutionForSensor(int sensorHandle);
bool mIsDirectReportSupported;
-
- typedef hardware::MessageQueue<uint32_t, hardware::kSynchronizedReadWrite> WakeLockQueue;
- std::unique_ptr<WakeLockQueue> mWakeLockQueue;
-
- hardware::EventFlag* mEventQueueFlag;
- hardware::EventFlag* mWakeLockQueueFlag;
-
- std::array<Event, SensorEventQueue::MAX_RECEIVE_BUFFER_EVENT_COUNT> mEventBuffer;
-
- sp<SensorsHalDeathReceivier> mSensorsHalDeathReceiver;
- std::atomic_bool mReconnecting;
};
// ---------------------------------------------------------------------------