Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit 818a2257 authored by Lais Andrade's avatar Lais Andrade
Browse files

Use android.hardware.vibrator NDK backend

Update vibrator HAL dependency to use the NDK backend.

Bug: 349595412
Test: libvibratorservice_test
Flag: EXEMPT mechanical refactor
Change-Id: I1eee7ea86d0535f93ed09d5295b3efbb4d5a1870
parent 0bab9286
Loading
Loading
Loading
Loading
+7 −7
Original line number Diff line number Diff line
@@ -37,15 +37,15 @@ cc_library_shared {
        include_dirs: [
            "hardware/interfaces/vibrator/aidl/android/hardware/vibrator",
        ],
       export_aidl_headers: true
        export_aidl_headers: true,
    },

    shared_libs: [
        "libbinder",
        "libbinder_ndk",
        "libhidlbase",
        "liblog",
        "libutils",
        "android.hardware.vibrator-V2-cpp",
        "android.hardware.vibrator-V2-ndk",
        "android.hardware.vibrator@1.0",
        "android.hardware.vibrator@1.1",
        "android.hardware.vibrator@1.2",
+15 −11
Original line number Diff line number Diff line
@@ -16,9 +16,9 @@

#define LOG_TAG "VibratorHalController"

#include <aidl/android/hardware/vibrator/IVibrator.h>
#include <android/binder_manager.h>
#include <android/hardware/vibrator/1.3/IVibrator.h>
#include <android/hardware/vibrator/IVibrator.h>
#include <binder/IServiceManager.h>
#include <hardware/vibrator.h>

#include <utils/Log.h>
@@ -27,10 +27,10 @@
#include <vibratorservice/VibratorHalController.h>
#include <vibratorservice/VibratorHalWrapper.h>

using android::hardware::vibrator::CompositeEffect;
using android::hardware::vibrator::CompositePrimitive;
using android::hardware::vibrator::Effect;
using android::hardware::vibrator::EffectStrength;
using aidl::android::hardware::vibrator::CompositeEffect;
using aidl::android::hardware::vibrator::CompositePrimitive;
using aidl::android::hardware::vibrator::Effect;
using aidl::android::hardware::vibrator::EffectStrength;

using std::chrono::milliseconds;

@@ -38,7 +38,7 @@ namespace V1_0 = android::hardware::vibrator::V1_0;
namespace V1_1 = android::hardware::vibrator::V1_1;
namespace V1_2 = android::hardware::vibrator::V1_2;
namespace V1_3 = android::hardware::vibrator::V1_3;
namespace Aidl = android::hardware::vibrator;
namespace Aidl = aidl::android::hardware::vibrator;

namespace android {

@@ -53,10 +53,14 @@ std::shared_ptr<HalWrapper> connectHal(std::shared_ptr<CallbackScheduler> schedu
        return nullptr;
    }

    sp<Aidl::IVibrator> aidlHal = waitForVintfService<Aidl::IVibrator>();
    if (aidlHal) {
    auto serviceName = std::string(Aidl::IVibrator::descriptor) + "/default";
    if (AServiceManager_isDeclared(serviceName.c_str())) {
        std::shared_ptr<Aidl::IVibrator> hal = Aidl::IVibrator::fromBinder(
                ndk::SpAIBinder(AServiceManager_waitForService(serviceName.c_str())));
        if (hal) {
            ALOGV("Successfully connected to Vibrator HAL AIDL service.");
        return std::make_shared<AidlHalWrapper>(std::move(scheduler), aidlHal);
            return std::make_shared<AidlHalWrapper>(std::move(scheduler), std::move(hal));
        }
    }

    sp<V1_0::IVibrator> halV1_0 = V1_0::IVibrator::getService();
+63 −61
Original line number Diff line number Diff line
@@ -16,8 +16,8 @@

#define LOG_TAG "VibratorHalWrapper"

#include <aidl/android/hardware/vibrator/IVibrator.h>
#include <android/hardware/vibrator/1.3/IVibrator.h>
#include <android/hardware/vibrator/IVibrator.h>
#include <hardware/vibrator.h>
#include <cmath>

@@ -26,12 +26,12 @@
#include <vibratorservice/VibratorCallbackScheduler.h>
#include <vibratorservice/VibratorHalWrapper.h>

using android::hardware::vibrator::Braking;
using android::hardware::vibrator::CompositeEffect;
using android::hardware::vibrator::CompositePrimitive;
using android::hardware::vibrator::Effect;
using android::hardware::vibrator::EffectStrength;
using android::hardware::vibrator::PrimitivePwle;
using aidl::android::hardware::vibrator::Braking;
using aidl::android::hardware::vibrator::CompositeEffect;
using aidl::android::hardware::vibrator::CompositePrimitive;
using aidl::android::hardware::vibrator::Effect;
using aidl::android::hardware::vibrator::EffectStrength;
using aidl::android::hardware::vibrator::PrimitivePwle;

using std::chrono::milliseconds;

@@ -39,7 +39,7 @@ namespace V1_0 = android::hardware::vibrator::V1_0;
namespace V1_1 = android::hardware::vibrator::V1_1;
namespace V1_2 = android::hardware::vibrator::V1_2;
namespace V1_3 = android::hardware::vibrator::V1_3;
namespace Aidl = android::hardware::vibrator;
namespace Aidl = aidl::android::hardware::vibrator;

namespace android {

@@ -200,7 +200,7 @@ HalResult<std::vector<float>> HalWrapper::getMaxAmplitudesInternal() {
// -------------------------------------------------------------------------------------------------

HalResult<void> AidlHalWrapper::ping() {
    return HalResultFactory::fromStatus(IInterface::asBinder(getHal())->pingBinder());
    return HalResultFactory::fromStatus(AIBinder_ping(getHal()->asBinder().get()));
}

void AidlHalWrapper::tryReconnect() {
@@ -208,7 +208,7 @@ void AidlHalWrapper::tryReconnect() {
    if (!result.isOk()) {
        return;
    }
    sp<Aidl::IVibrator> newHandle = result.value();
    std::shared_ptr<Aidl::IVibrator> newHandle = result.value();
    if (newHandle) {
        std::lock_guard<std::mutex> lock(mHandleMutex);
        mHandle = std::move(newHandle);
@@ -220,7 +220,8 @@ HalResult<void> AidlHalWrapper::on(milliseconds timeout,
    HalResult<Capabilities> capabilities = getCapabilities();
    bool supportsCallback = capabilities.isOk() &&
            static_cast<int32_t>(capabilities.value() & Capabilities::ON_CALLBACK);
    auto cb = supportsCallback ? new HalCallbackWrapper(completionCallback) : nullptr;
    auto cb = supportsCallback ? ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback)
                               : nullptr;

    auto ret = HalResultFactory::fromStatus(getHal()->on(timeout.count(), cb));
    if (!supportsCallback && ret.isOk()) {
@@ -255,13 +256,14 @@ HalResult<milliseconds> AidlHalWrapper::performEffect(
    HalResult<Capabilities> capabilities = getCapabilities();
    bool supportsCallback = capabilities.isOk() &&
            static_cast<int32_t>(capabilities.value() & Capabilities::PERFORM_CALLBACK);
    auto cb = supportsCallback ? new HalCallbackWrapper(completionCallback) : nullptr;
    auto cb = supportsCallback ? ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback)
                               : nullptr;

    int32_t lengthMs;
    auto result = getHal()->perform(effect, strength, cb, &lengthMs);
    auto status = getHal()->perform(effect, strength, cb, &lengthMs);
    milliseconds length = milliseconds(lengthMs);

    auto ret = HalResultFactory::fromStatus<milliseconds>(result, length);
    auto ret = HalResultFactory::fromStatus<milliseconds>(std::move(status), length);
    if (!supportsCallback && ret.isOk()) {
        mCallbackScheduler->schedule(completionCallback, length);
    }
@@ -273,7 +275,7 @@ HalResult<milliseconds> AidlHalWrapper::performComposedEffect(
        const std::vector<CompositeEffect>& primitives,
        const std::function<void()>& completionCallback) {
    // This method should always support callbacks, so no need to double check.
    auto cb = new HalCallbackWrapper(completionCallback);
    auto cb = ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback);

    auto durations = getPrimitiveDurations().valueOr({});
    milliseconds duration(0);
@@ -294,40 +296,40 @@ HalResult<milliseconds> AidlHalWrapper::performComposedEffect(
HalResult<void> AidlHalWrapper::performPwleEffect(const std::vector<PrimitivePwle>& primitives,
                                                  const std::function<void()>& completionCallback) {
    // This method should always support callbacks, so no need to double check.
    auto cb = new HalCallbackWrapper(completionCallback);
    auto cb = ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback);
    return HalResultFactory::fromStatus(getHal()->composePwle(primitives, cb));
}

HalResult<Capabilities> AidlHalWrapper::getCapabilitiesInternal() {
    int32_t capabilities = 0;
    auto result = getHal()->getCapabilities(&capabilities);
    return HalResultFactory::fromStatus<Capabilities>(result,
                                                      static_cast<Capabilities>(capabilities));
    int32_t cap = 0;
    auto status = getHal()->getCapabilities(&cap);
    auto capabilities = static_cast<Capabilities>(cap);
    return HalResultFactory::fromStatus<Capabilities>(std::move(status), capabilities);
}

HalResult<std::vector<Effect>> AidlHalWrapper::getSupportedEffectsInternal() {
    std::vector<Effect> supportedEffects;
    auto result = getHal()->getSupportedEffects(&supportedEffects);
    return HalResultFactory::fromStatus<std::vector<Effect>>(result, supportedEffects);
    auto status = getHal()->getSupportedEffects(&supportedEffects);
    return HalResultFactory::fromStatus<std::vector<Effect>>(std::move(status), supportedEffects);
}

HalResult<std::vector<Braking>> AidlHalWrapper::getSupportedBrakingInternal() {
    std::vector<Braking> supportedBraking;
    auto result = getHal()->getSupportedBraking(&supportedBraking);
    return HalResultFactory::fromStatus<std::vector<Braking>>(result, supportedBraking);
    auto status = getHal()->getSupportedBraking(&supportedBraking);
    return HalResultFactory::fromStatus<std::vector<Braking>>(std::move(status), supportedBraking);
}

HalResult<std::vector<CompositePrimitive>> AidlHalWrapper::getSupportedPrimitivesInternal() {
    std::vector<CompositePrimitive> supportedPrimitives;
    auto result = getHal()->getSupportedPrimitives(&supportedPrimitives);
    return HalResultFactory::fromStatus<std::vector<CompositePrimitive>>(result,
    auto status = getHal()->getSupportedPrimitives(&supportedPrimitives);
    return HalResultFactory::fromStatus<std::vector<CompositePrimitive>>(std::move(status),
                                                                         supportedPrimitives);
}

HalResult<std::vector<milliseconds>> AidlHalWrapper::getPrimitiveDurationsInternal(
        const std::vector<CompositePrimitive>& supportedPrimitives) {
    std::vector<milliseconds> durations;
    constexpr auto primitiveRange = enum_range<CompositePrimitive>();
    constexpr auto primitiveRange = ndk::enum_range<CompositePrimitive>();
    constexpr auto primitiveCount = std::distance(primitiveRange.begin(), primitiveRange.end());
    durations.resize(primitiveCount);

@@ -340,8 +342,8 @@ HalResult<std::vector<milliseconds>> AidlHalWrapper::getPrimitiveDurationsIntern
            continue;
        }
        int32_t duration = 0;
        auto result = getHal()->getPrimitiveDuration(primitive, &duration);
        auto halResult = HalResultFactory::fromStatus<int32_t>(result, duration);
        auto status = getHal()->getPrimitiveDuration(primitive, &duration);
        auto halResult = HalResultFactory::fromStatus<int32_t>(std::move(status), duration);
        if (halResult.isUnsupported()) {
            // Should not happen, supported primitives should always support requesting duration.
            ALOGE("Supported primitive %zu returned unsupported for getPrimitiveDuration",
@@ -349,7 +351,7 @@ HalResult<std::vector<milliseconds>> AidlHalWrapper::getPrimitiveDurationsIntern
        }
        if (halResult.isFailed()) {
            // Fail entire request if one request has failed.
            return HalResult<std::vector<milliseconds>>::failed(result.toString8().c_str());
            return HalResult<std::vector<milliseconds>>::failed(status.getMessage());
        }
        durations[primitiveIdx] = milliseconds(duration);
    }
@@ -359,59 +361,59 @@ HalResult<std::vector<milliseconds>> AidlHalWrapper::getPrimitiveDurationsIntern

HalResult<milliseconds> AidlHalWrapper::getPrimitiveDelayMaxInternal() {
    int32_t delay = 0;
    auto result = getHal()->getCompositionDelayMax(&delay);
    return HalResultFactory::fromStatus<milliseconds>(result, milliseconds(delay));
    auto status = getHal()->getCompositionDelayMax(&delay);
    return HalResultFactory::fromStatus<milliseconds>(std::move(status), milliseconds(delay));
}

HalResult<milliseconds> AidlHalWrapper::getPrimitiveDurationMaxInternal() {
    int32_t delay = 0;
    auto result = getHal()->getPwlePrimitiveDurationMax(&delay);
    return HalResultFactory::fromStatus<milliseconds>(result, milliseconds(delay));
    auto status = getHal()->getPwlePrimitiveDurationMax(&delay);
    return HalResultFactory::fromStatus<milliseconds>(std::move(status), milliseconds(delay));
}

HalResult<int32_t> AidlHalWrapper::getCompositionSizeMaxInternal() {
    int32_t size = 0;
    auto result = getHal()->getCompositionSizeMax(&size);
    return HalResultFactory::fromStatus<int32_t>(result, size);
    auto status = getHal()->getCompositionSizeMax(&size);
    return HalResultFactory::fromStatus<int32_t>(std::move(status), size);
}

HalResult<int32_t> AidlHalWrapper::getPwleSizeMaxInternal() {
    int32_t size = 0;
    auto result = getHal()->getPwleCompositionSizeMax(&size);
    return HalResultFactory::fromStatus<int32_t>(result, size);
    auto status = getHal()->getPwleCompositionSizeMax(&size);
    return HalResultFactory::fromStatus<int32_t>(std::move(status), size);
}

HalResult<float> AidlHalWrapper::getMinFrequencyInternal() {
    float minFrequency = 0;
    auto result = getHal()->getFrequencyMinimum(&minFrequency);
    return HalResultFactory::fromStatus<float>(result, minFrequency);
    auto status = getHal()->getFrequencyMinimum(&minFrequency);
    return HalResultFactory::fromStatus<float>(std::move(status), minFrequency);
}

HalResult<float> AidlHalWrapper::getResonantFrequencyInternal() {
    float f0 = 0;
    auto result = getHal()->getResonantFrequency(&f0);
    return HalResultFactory::fromStatus<float>(result, f0);
    auto status = getHal()->getResonantFrequency(&f0);
    return HalResultFactory::fromStatus<float>(std::move(status), f0);
}

HalResult<float> AidlHalWrapper::getFrequencyResolutionInternal() {
    float frequencyResolution = 0;
    auto result = getHal()->getFrequencyResolution(&frequencyResolution);
    return HalResultFactory::fromStatus<float>(result, frequencyResolution);
    auto status = getHal()->getFrequencyResolution(&frequencyResolution);
    return HalResultFactory::fromStatus<float>(std::move(status), frequencyResolution);
}

HalResult<float> AidlHalWrapper::getQFactorInternal() {
    float qFactor = 0;
    auto result = getHal()->getQFactor(&qFactor);
    return HalResultFactory::fromStatus<float>(result, qFactor);
    auto status = getHal()->getQFactor(&qFactor);
    return HalResultFactory::fromStatus<float>(std::move(status), qFactor);
}

HalResult<std::vector<float>> AidlHalWrapper::getMaxAmplitudesInternal() {
    std::vector<float> amplitudes;
    auto result = getHal()->getBandwidthAmplitudeMap(&amplitudes);
    return HalResultFactory::fromStatus<std::vector<float>>(result, amplitudes);
    auto status = getHal()->getBandwidthAmplitudeMap(&amplitudes);
    return HalResultFactory::fromStatus<std::vector<float>>(std::move(status), amplitudes);
}

sp<Aidl::IVibrator> AidlHalWrapper::getHal() {
std::shared_ptr<Aidl::IVibrator> AidlHalWrapper::getHal() {
    std::lock_guard<std::mutex> lock(mHandleMutex);
    return mHandle;
}
@@ -420,8 +422,7 @@ sp<Aidl::IVibrator> AidlHalWrapper::getHal() {

template <typename I>
HalResult<void> HidlHalWrapper<I>::ping() {
    auto result = getHal()->ping();
    return HalResultFactory::fromReturn(result);
    return HalResultFactory::fromReturn(getHal()->ping());
}

template <typename I>
@@ -436,8 +437,8 @@ void HidlHalWrapper<I>::tryReconnect() {
template <typename I>
HalResult<void> HidlHalWrapper<I>::on(milliseconds timeout,
                                      const std::function<void()>& completionCallback) {
    auto result = getHal()->on(timeout.count());
    auto ret = HalResultFactory::fromStatus(result.withDefault(V1_0::Status::UNKNOWN_ERROR));
    auto status = getHal()->on(timeout.count());
    auto ret = HalResultFactory::fromStatus(status.withDefault(V1_0::Status::UNKNOWN_ERROR));
    if (ret.isOk()) {
        mCallbackScheduler->schedule(completionCallback, timeout);
    }
@@ -446,15 +447,15 @@ HalResult<void> HidlHalWrapper<I>::on(milliseconds timeout,

template <typename I>
HalResult<void> HidlHalWrapper<I>::off() {
    auto result = getHal()->off();
    return HalResultFactory::fromStatus(result.withDefault(V1_0::Status::UNKNOWN_ERROR));
    auto status = getHal()->off();
    return HalResultFactory::fromStatus(status.withDefault(V1_0::Status::UNKNOWN_ERROR));
}

template <typename I>
HalResult<void> HidlHalWrapper<I>::setAmplitude(float amplitude) {
    uint8_t amp = static_cast<uint8_t>(amplitude * std::numeric_limits<uint8_t>::max());
    auto result = getHal()->setAmplitude(amp);
    return HalResultFactory::fromStatus(result.withDefault(V1_0::Status::UNKNOWN_ERROR));
    auto status = getHal()->setAmplitude(amp);
    return HalResultFactory::fromStatus(status.withDefault(V1_0::Status::UNKNOWN_ERROR));
}

template <typename I>
@@ -480,7 +481,7 @@ HalResult<Capabilities> HidlHalWrapper<I>::getCapabilitiesInternal() {
    hardware::Return<bool> result = getHal()->supportsAmplitudeControl();
    Capabilities capabilities =
            result.withDefault(false) ? Capabilities::AMPLITUDE_CONTROL : Capabilities::NONE;
    return HalResultFactory::fromReturn<Capabilities>(result, capabilities);
    return HalResultFactory::fromReturn<Capabilities>(std::move(result), capabilities);
}

template <typename I>
@@ -499,7 +500,7 @@ HalResult<milliseconds> HidlHalWrapper<I>::performInternal(
    auto result = std::invoke(performFn, handle, effect, effectStrength, effectCallback);
    milliseconds length = milliseconds(lengthMs);

    auto ret = HalResultFactory::fromReturn<milliseconds>(result, status, length);
    auto ret = HalResultFactory::fromReturn<milliseconds>(std::move(result), status, length);
    if (ret.isOk()) {
        mCallbackScheduler->schedule(completionCallback, length);
    }
@@ -604,7 +605,7 @@ HalResult<Capabilities> HidlHalWrapperV1_3::getCapabilitiesInternal() {
    sp<V1_3::IVibrator> hal = getHal();
    auto amplitudeResult = hal->supportsAmplitudeControl();
    if (!amplitudeResult.isOk()) {
        return HalResultFactory::fromReturn<Capabilities>(amplitudeResult, capabilities);
        return HalResultFactory::fromReturn<Capabilities>(std::move(amplitudeResult), capabilities);
    }

    auto externalControlResult = hal->supportsExternalControl();
@@ -619,7 +620,8 @@ HalResult<Capabilities> HidlHalWrapperV1_3::getCapabilitiesInternal() {
        }
    }

    return HalResultFactory::fromReturn<Capabilities>(externalControlResult, capabilities);
    return HalResultFactory::fromReturn<Capabilities>(std::move(externalControlResult),
                                                      capabilities);
}

// -------------------------------------------------------------------------------------------------
+10 −5
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@

#include <vibratorservice/VibratorManagerHalController.h>

namespace Aidl = android::hardware::vibrator;
namespace Aidl = aidl::android::hardware::vibrator;

namespace android {

@@ -29,10 +29,15 @@ namespace vibrator {
std::shared_ptr<ManagerHalWrapper> connectManagerHal(std::shared_ptr<CallbackScheduler> scheduler) {
    static bool gHalExists = true;
    if (gHalExists) {
        sp<Aidl::IVibratorManager> hal = waitForVintfService<Aidl::IVibratorManager>();
        auto serviceName = std::string(Aidl::IVibratorManager::descriptor) + "/default";
        if (AServiceManager_isDeclared(serviceName.c_str())) {
            std::shared_ptr<Aidl::IVibratorManager> hal = Aidl::IVibratorManager::fromBinder(
                    ndk::SpAIBinder(AServiceManager_checkService(serviceName.c_str())));
            if (hal) {
                ALOGV("Successfully connected to VibratorManager HAL AIDL service.");
            return std::make_shared<AidlManagerHalWrapper>(std::move(scheduler), hal);
                return std::make_shared<AidlManagerHalWrapper>(std::move(scheduler),
                                                               std::move(hal));
            }
        }
    }

+17 −13
Original line number Diff line number Diff line
@@ -20,7 +20,7 @@

#include <vibratorservice/VibratorManagerHalWrapper.h>

namespace Aidl = android::hardware::vibrator;
namespace Aidl = aidl::android::hardware::vibrator;

namespace android {

@@ -75,10 +75,11 @@ HalResult<void> LegacyManagerHalWrapper::cancelSynced() {

std::shared_ptr<HalWrapper> AidlManagerHalWrapper::connectToVibrator(
        int32_t vibratorId, std::shared_ptr<CallbackScheduler> callbackScheduler) {
    std::function<HalResult<sp<Aidl::IVibrator>>()> reconnectFn = [=, this]() {
        sp<Aidl::IVibrator> vibrator;
        auto result = this->getHal()->getVibrator(vibratorId, &vibrator);
        return HalResultFactory::fromStatus<sp<Aidl::IVibrator>>(result, vibrator);
    std::function<HalResult<std::shared_ptr<Aidl::IVibrator>>()> reconnectFn = [=, this]() {
        std::shared_ptr<Aidl::IVibrator> vibrator;
        auto status = this->getHal()->getVibrator(vibratorId, &vibrator);
        return HalResultFactory::fromStatus<std::shared_ptr<Aidl::IVibrator>>(std::move(status),
                                                                              vibrator);
    };
    auto result = reconnectFn();
    if (!result.isOk()) {
@@ -93,11 +94,13 @@ std::shared_ptr<HalWrapper> AidlManagerHalWrapper::connectToVibrator(
}

HalResult<void> AidlManagerHalWrapper::ping() {
    return HalResultFactory::fromStatus(IInterface::asBinder(getHal())->pingBinder());
    return HalResultFactory::fromStatus(AIBinder_ping(getHal()->asBinder().get()));
}

void AidlManagerHalWrapper::tryReconnect() {
    sp<Aidl::IVibratorManager> newHandle = checkVintfService<Aidl::IVibratorManager>();
    auto aidlServiceName = std::string(Aidl::IVibratorManager::descriptor) + "/default";
    std::shared_ptr<Aidl::IVibratorManager> newHandle = Aidl::IVibratorManager::fromBinder(
            ndk::SpAIBinder(AServiceManager_checkService(aidlServiceName.c_str())));
    if (newHandle) {
        std::lock_guard<std::mutex> lock(mHandleMutex);
        mHandle = std::move(newHandle);
@@ -111,9 +114,9 @@ HalResult<ManagerCapabilities> AidlManagerHalWrapper::getCapabilities() {
        return HalResult<ManagerCapabilities>::ok(*mCapabilities);
    }
    int32_t cap = 0;
    auto result = getHal()->getCapabilities(&cap);
    auto status = getHal()->getCapabilities(&cap);
    auto capabilities = static_cast<ManagerCapabilities>(cap);
    auto ret = HalResultFactory::fromStatus<ManagerCapabilities>(result, capabilities);
    auto ret = HalResultFactory::fromStatus<ManagerCapabilities>(std::move(status), capabilities);
    if (ret.isOk()) {
        // Cache copy of returned value.
        mCapabilities.emplace(ret.value());
@@ -128,8 +131,8 @@ HalResult<std::vector<int32_t>> AidlManagerHalWrapper::getVibratorIds() {
        return HalResult<std::vector<int32_t>>::ok(*mVibratorIds);
    }
    std::vector<int32_t> ids;
    auto result = getHal()->getVibratorIds(&ids);
    auto ret = HalResultFactory::fromStatus<std::vector<int32_t>>(result, ids);
    auto status = getHal()->getVibratorIds(&ids);
    auto ret = HalResultFactory::fromStatus<std::vector<int32_t>>(std::move(status), ids);
    if (ret.isOk()) {
        // Cache copy of returned value and the individual controllers.
        mVibratorIds.emplace(ret.value());
@@ -178,7 +181,8 @@ HalResult<void> AidlManagerHalWrapper::triggerSynced(
    HalResult<ManagerCapabilities> capabilities = getCapabilities();
    bool supportsCallback = capabilities.isOk() &&
            static_cast<int32_t>(capabilities.value() & ManagerCapabilities::TRIGGER_CALLBACK);
    auto cb = supportsCallback ? new HalCallbackWrapper(completionCallback) : nullptr;
    auto cb = supportsCallback ? ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback)
                               : nullptr;
    return HalResultFactory::fromStatus(getHal()->triggerSynced(cb));
}

@@ -196,7 +200,7 @@ HalResult<void> AidlManagerHalWrapper::cancelSynced() {
    return ret;
}

sp<Aidl::IVibratorManager> AidlManagerHalWrapper::getHal() {
std::shared_ptr<Aidl::IVibratorManager> AidlManagerHalWrapper::getHal() {
    std::lock_guard<std::mutex> lock(mHandleMutex);
    return mHandle;
}
Loading