services/vibratorservice/include/vibratorservice/VibratorManagerHalWrapper.h

/*
 * 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