diff options
Diffstat (limited to 'services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h')
-rw-r--r-- | services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h | 145 |
1 files changed, 145 insertions, 0 deletions
diff --git a/services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h b/services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h new file mode 100644 index 0000000000..563f55e9f3 --- /dev/null +++ b/services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h @@ -0,0 +1,145 @@ +/* + * 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_OS_VIBRATOR_MANAGER_HAL_WRAPPER_H +#define ANDROID_OS_VIBRATOR_MANAGER_HAL_WRAPPER_H + +#include <android/hardware/vibrator/IVibratorManager.h> +#include <vibratorservice/VibratorHalController.h> +#include <unordered_map> + +namespace android { + +namespace vibrator { + +// VibratorManager HAL capabilities. +enum class ManagerCapabilities : int32_t { + NONE = 0, + SYNC = hardware::vibrator::IVibratorManager::CAP_SYNC, + PREPARE_ON = hardware::vibrator::IVibratorManager::CAP_PREPARE_ON, + PREPARE_PERFORM = hardware::vibrator::IVibratorManager::CAP_PREPARE_PERFORM, + PREPARE_COMPOSE = hardware::vibrator::IVibratorManager::CAP_PREPARE_COMPOSE, + MIXED_TRIGGER_ON = hardware::vibrator::IVibratorManager::IVibratorManager::CAP_MIXED_TRIGGER_ON, + MIXED_TRIGGER_PERFORM = hardware::vibrator::IVibratorManager::CAP_MIXED_TRIGGER_PERFORM, + MIXED_TRIGGER_COMPOSE = hardware::vibrator::IVibratorManager::CAP_MIXED_TRIGGER_COMPOSE, + TRIGGER_CALLBACK = hardware::vibrator::IVibratorManager::CAP_TRIGGER_CALLBACK +}; + +inline ManagerCapabilities operator|(ManagerCapabilities lhs, ManagerCapabilities rhs) { + using underlying = typename std::underlying_type<ManagerCapabilities>::type; + return static_cast<ManagerCapabilities>(static_cast<underlying>(lhs) | + static_cast<underlying>(rhs)); +} + +inline ManagerCapabilities& operator|=(ManagerCapabilities& lhs, ManagerCapabilities rhs) { + return lhs = lhs | rhs; +} + +inline ManagerCapabilities operator&(ManagerCapabilities lhs, ManagerCapabilities rhs) { + using underlying = typename std::underlying_type<ManagerCapabilities>::type; + return static_cast<ManagerCapabilities>(static_cast<underlying>(lhs) & + static_cast<underlying>(rhs)); +} + +inline ManagerCapabilities& operator&=(ManagerCapabilities& lhs, ManagerCapabilities rhs) { + return lhs = lhs & rhs; +} + +// Wrapper for VibratorManager HAL handlers. +class ManagerHalWrapper { +public: + ManagerHalWrapper() = default; + virtual ~ManagerHalWrapper() = default; + + virtual HalResult<void> ping() = 0; + + /* reloads wrapped HAL service instance without waiting. This can be used to reconnect when the + * service restarts, to rapidly retry after a failure. + */ + virtual void tryReconnect() = 0; + + virtual HalResult<ManagerCapabilities> getCapabilities() = 0; + virtual HalResult<std::vector<int32_t>> getVibratorIds() = 0; + virtual HalResult<std::shared_ptr<HalController>> getVibrator(int32_t id) = 0; + + virtual HalResult<void> prepareSynced(const std::vector<int32_t>& ids) = 0; + virtual HalResult<void> triggerSynced(const std::function<void()>& completionCallback) = 0; + virtual HalResult<void> cancelSynced() = 0; +}; + +// Wrapper for the VibratorManager over single Vibrator HAL. +class LegacyManagerHalWrapper : public ManagerHalWrapper { +public: + LegacyManagerHalWrapper() : LegacyManagerHalWrapper(std::make_shared<HalController>()) {} + explicit LegacyManagerHalWrapper(std::shared_ptr<HalController> controller) + : mController(std::move(controller)) {} + virtual ~LegacyManagerHalWrapper() = default; + + HalResult<void> ping() override final; + void tryReconnect() override final; + + HalResult<ManagerCapabilities> getCapabilities() override final; + HalResult<std::vector<int32_t>> getVibratorIds() override final; + HalResult<std::shared_ptr<HalController>> getVibrator(int32_t id) override final; + + HalResult<void> prepareSynced(const std::vector<int32_t>& ids) override final; + HalResult<void> triggerSynced(const std::function<void()>& completionCallback) override final; + HalResult<void> cancelSynced() override final; + +private: + const std::shared_ptr<HalController> mController; +}; + +// Wrapper for the AIDL VibratorManager HAL. +class AidlManagerHalWrapper : public ManagerHalWrapper { +public: + explicit AidlManagerHalWrapper(std::shared_ptr<CallbackScheduler> callbackScheduler, + sp<hardware::vibrator::IVibratorManager> handle) + : mHandle(std::move(handle)), mCallbackScheduler(callbackScheduler) {} + virtual ~AidlManagerHalWrapper() = default; + + HalResult<void> ping() override final; + void tryReconnect() override final; + + HalResult<ManagerCapabilities> getCapabilities() override final; + HalResult<std::vector<int32_t>> getVibratorIds() override final; + HalResult<std::shared_ptr<HalController>> getVibrator(int32_t id) override final; + + HalResult<void> prepareSynced(const std::vector<int32_t>& ids) override final; + HalResult<void> triggerSynced(const std::function<void()>& completionCallback) override final; + HalResult<void> cancelSynced() override final; + +private: + std::mutex mHandleMutex; + std::mutex mCapabilitiesMutex; + std::mutex mVibratorsMutex; + sp<hardware::vibrator::IVibratorManager> mHandle GUARDED_BY(mHandleMutex); + std::optional<ManagerCapabilities> mCapabilities GUARDED_BY(mCapabilitiesMutex); + std::optional<std::vector<int32_t>> mVibratorIds GUARDED_BY(mVibratorsMutex); + std::unordered_map<int32_t, std::shared_ptr<HalController>> mVibrators + GUARDED_BY(mVibratorsMutex); + std::shared_ptr<CallbackScheduler> mCallbackScheduler; + + sp<hardware::vibrator::IVibratorManager> getHal(); + std::shared_ptr<HalWrapper> connectToVibrator(int32_t vibratorId, + std::shared_ptr<CallbackScheduler> scheduler); +}; + +}; // namespace vibrator + +}; // namespace android + +#endif // ANDROID_OS_VIBRATOR_MANAGER_HAL_WRAPPER_H |