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

Commit 2531e514 authored by Lais Andrade's avatar Lais Andrade
Browse files

Removing Vibrator HIDL HAL support from frameworks 

Android Q is now no longer supported for launching or
upgrading devices in Android V so the vibrator HIDL HAL
versions no longer needs to be supported by the platform.

Bug: 308452413
Test: manually using the command line
Flag: EXEMPT updating Android.bp and removing dependencies
Change-Id: I6ba36f7c153f39afa9cf1a3c6dd679885da49ce7
parent 69e737f0

services/vibratorservice/Android.bp

+0 −5
Original line number Diff line number Diff line
@@ -42,14 +42,9 @@ cc_library_shared { 


    shared_libs: [

        "libbinder_ndk",

        "libhidlbase",

        "liblog",

        "libutils",

        "android.hardware.vibrator-V3-ndk",

        "android.hardware.vibrator@1.0",

        "android.hardware.vibrator@1.1",

        "android.hardware.vibrator@1.2",

        "android.hardware.vibrator@1.3",

    ],



    cflags: [

services/vibratorservice/VibratorHalController.cpp

+6 −34
Original line number Diff line number Diff line
@@ -18,8 +18,6 @@ 


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

#include <android/binder_manager.h>

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

#include <hardware/vibrator.h>



#include <utils/Log.h>
@@ -31,15 +29,10 @@ 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::IVibrator;



using std::chrono::milliseconds;



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 = aidl::android::hardware::vibrator;



namespace android {



namespace vibrator {
@@ -53,9 +46,9 @@ std::shared_ptr<HalWrapper> connectHal(std::shared_ptr<CallbackScheduler> schedu 
        return nullptr;

    }



    auto serviceName = std::string(Aidl::IVibrator::descriptor) + "/default";

    auto serviceName = std::string(IVibrator::descriptor) + "/default";

    if (AServiceManager_isDeclared(serviceName.c_str())) {

        std::shared_ptr<Aidl::IVibrator> hal = Aidl::IVibrator::fromBinder(

        std::shared_ptr<IVibrator> hal = IVibrator::fromBinder(

                ndk::SpAIBinder(AServiceManager_waitForService(serviceName.c_str())));

        if (hal) {

            ALOGV("Successfully connected to Vibrator HAL AIDL service.");
@@ -63,32 +56,11 @@ std::shared_ptr<HalWrapper> connectHal(std::shared_ptr<CallbackScheduler> schedu 
        }

    }



    sp<V1_0::IVibrator> halV1_0 = V1_0::IVibrator::getService();

    if (halV1_0 == nullptr) {

    ALOGV("Vibrator HAL service not available.");

    gHalExists = false;

    return nullptr;

}



    sp<V1_3::IVibrator> halV1_3 = V1_3::IVibrator::castFrom(halV1_0);

    if (halV1_3) {

        ALOGV("Successfully connected to Vibrator HAL v1.3 service.");

        return std::make_shared<HidlHalWrapperV1_3>(std::move(scheduler), halV1_3);

    }

    sp<V1_2::IVibrator> halV1_2 = V1_2::IVibrator::castFrom(halV1_0);

    if (halV1_2) {

        ALOGV("Successfully connected to Vibrator HAL v1.2 service.");

        return std::make_shared<HidlHalWrapperV1_2>(std::move(scheduler), halV1_2);

    }

    sp<V1_1::IVibrator> halV1_1 = V1_1::IVibrator::castFrom(halV1_0);

    if (halV1_1) {

        ALOGV("Successfully connected to Vibrator HAL v1.1 service.");

        return std::make_shared<HidlHalWrapperV1_1>(std::move(scheduler), halV1_1);

    }

    ALOGV("Successfully connected to Vibrator HAL v1.0 service.");

    return std::make_shared<HidlHalWrapperV1_0>(std::move(scheduler), halV1_0);

}



// -------------------------------------------------------------------------------------------------



bool HalController::init() {

services/vibratorservice/VibratorHalWrapper.cpp

+3 −224
Original line number Diff line number Diff line
@@ -17,7 +17,6 @@ 
#define LOG_TAG "VibratorHalWrapper"



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

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

#include <hardware/vibrator.h>

#include <cmath>
@@ -33,32 +32,18 @@ using aidl::android::hardware::vibrator::CompositePwleV2; 
using aidl::android::hardware::vibrator::Effect;

using aidl::android::hardware::vibrator::EffectStrength;

using aidl::android::hardware::vibrator::FrequencyAccelerationMapEntry;

using aidl::android::hardware::vibrator::IVibrator;

using aidl::android::hardware::vibrator::PrimitivePwle;

using aidl::android::hardware::vibrator::VendorEffect;



using std::chrono::milliseconds;



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 = aidl::android::hardware::vibrator;



namespace android {



namespace vibrator {



// -------------------------------------------------------------------------------------------------



template <class T>

bool isStaticCastValid(Effect effect) {

    T castEffect = static_cast<T>(effect);

    auto iter = hardware::hidl_enum_range<T>();

    return castEffect >= *iter.begin() && castEffect <= *std::prev(iter.end());

}



// -------------------------------------------------------------------------------------------------



Info HalWrapper::getInfo() {

    getCapabilities();

    getPrimitiveDurations();
@@ -261,7 +246,7 @@ void AidlHalWrapper::tryReconnect() { 
    if (!result.isOk()) {

        return;

    }

    std::shared_ptr<Aidl::IVibrator> newHandle = result.value();

    std::shared_ptr<IVibrator> newHandle = result.value();

    if (newHandle) {

        std::lock_guard<std::mutex> lock(mHandleMutex);

        mHandle = std::move(newHandle);
@@ -514,219 +499,13 @@ AidlHalWrapper::getFrequencyToOutputAccelerationMapInternal() { 
                                                        frequencyToOutputAccelerationMap);

}



std::shared_ptr<Aidl::IVibrator> AidlHalWrapper::getHal() {

    std::lock_guard<std::mutex> lock(mHandleMutex);

    return mHandle;

}



// -------------------------------------------------------------------------------------------------



template <typename I>

HalResult<void> HidlHalWrapper<I>::ping() {

    return HalResultFactory::fromReturn(getHal()->ping());

}



template <typename I>

void HidlHalWrapper<I>::tryReconnect() {

    sp<I> newHandle = I::tryGetService();

    if (newHandle) {

        std::lock_guard<std::mutex> lock(mHandleMutex);

        mHandle = std::move(newHandle);

    }

}



template <typename I>

HalResult<void> HidlHalWrapper<I>::on(milliseconds timeout,

                                      const std::function<void()>& completionCallback) {

    auto status = getHal()->on(timeout.count());

    auto ret = HalResultFactory::fromStatus(status.withDefault(V1_0::Status::UNKNOWN_ERROR));

    if (ret.isOk()) {

        mCallbackScheduler->schedule(completionCallback, timeout);

    }

    return ret;

}



template <typename I>

HalResult<void> HidlHalWrapper<I>::off() {

    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 status = getHal()->setAmplitude(amp);

    return HalResultFactory::fromStatus(status.withDefault(V1_0::Status::UNKNOWN_ERROR));

}



template <typename I>

HalResult<void> HidlHalWrapper<I>::setExternalControl(bool) {

    ALOGV("Skipped setExternalControl because Vibrator HAL does not support it");

    return HalResult<void>::unsupported();

}



template <typename I>

HalResult<void> HidlHalWrapper<I>::alwaysOnEnable(int32_t, Effect, EffectStrength) {

    ALOGV("Skipped alwaysOnEnable because Vibrator HAL AIDL is not available");

    return HalResult<void>::unsupported();

}



template <typename I>

HalResult<void> HidlHalWrapper<I>::alwaysOnDisable(int32_t) {

    ALOGV("Skipped alwaysOnDisable because Vibrator HAL AIDL is not available");

    return HalResult<void>::unsupported();

}



template <typename I>

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>(std::move(result), capabilities);

}



template <typename I>

template <typename T>

HalResult<milliseconds> HidlHalWrapper<I>::performInternal(

        perform_fn<T> performFn, sp<I> handle, T effect, EffectStrength strength,

        const std::function<void()>& completionCallback) {

    V1_0::Status status;

    int32_t lengthMs;

    auto effectCallback = [&status, &lengthMs](V1_0::Status retStatus, uint32_t retLengthMs) {

        status = retStatus;

        lengthMs = retLengthMs;

    };



    V1_0::EffectStrength effectStrength = static_cast<V1_0::EffectStrength>(strength);

    auto result = std::invoke(performFn, handle, effect, effectStrength, effectCallback);

    milliseconds length = milliseconds(lengthMs);



    auto ret = HalResultFactory::fromReturn<milliseconds>(std::move(result), status, length);

    if (ret.isOk()) {

        mCallbackScheduler->schedule(completionCallback, length);

    }



    return ret;

}



template <typename I>

sp<I> HidlHalWrapper<I>::getHal() {

std::shared_ptr<IVibrator> AidlHalWrapper::getHal() {

    std::lock_guard<std::mutex> lock(mHandleMutex);

    return mHandle;

}



// -------------------------------------------------------------------------------------------------



HalResult<milliseconds> HidlHalWrapperV1_0::performEffect(

        Effect effect, EffectStrength strength, const std::function<void()>& completionCallback) {

    if (isStaticCastValid<V1_0::Effect>(effect)) {

        return performInternal(&V1_0::IVibrator::perform, getHal(),

                               static_cast<V1_0::Effect>(effect), strength, completionCallback);

    }



    ALOGV("Skipped performEffect because Vibrator HAL does not support effect %s",

          Aidl::toString(effect).c_str());

    return HalResult<milliseconds>::unsupported();

}



// -------------------------------------------------------------------------------------------------



HalResult<milliseconds> HidlHalWrapperV1_1::performEffect(

        Effect effect, EffectStrength strength, const std::function<void()>& completionCallback) {

    if (isStaticCastValid<V1_0::Effect>(effect)) {

        return performInternal(&V1_1::IVibrator::perform, getHal(),

                               static_cast<V1_0::Effect>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_1::Effect_1_1>(effect)) {

        return performInternal(&V1_1::IVibrator::perform_1_1, getHal(),

                               static_cast<V1_1::Effect_1_1>(effect), strength, completionCallback);

    }



    ALOGV("Skipped performEffect because Vibrator HAL does not support effect %s",

          Aidl::toString(effect).c_str());

    return HalResult<milliseconds>::unsupported();

}



// -------------------------------------------------------------------------------------------------



HalResult<milliseconds> HidlHalWrapperV1_2::performEffect(

        Effect effect, EffectStrength strength, const std::function<void()>& completionCallback) {

    if (isStaticCastValid<V1_0::Effect>(effect)) {

        return performInternal(&V1_2::IVibrator::perform, getHal(),

                               static_cast<V1_0::Effect>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_1::Effect_1_1>(effect)) {

        return performInternal(&V1_2::IVibrator::perform_1_1, getHal(),

                               static_cast<V1_1::Effect_1_1>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_2::Effect>(effect)) {

        return performInternal(&V1_2::IVibrator::perform_1_2, getHal(),

                               static_cast<V1_2::Effect>(effect), strength, completionCallback);

    }



    ALOGV("Skipped performEffect because Vibrator HAL does not support effect %s",

          Aidl::toString(effect).c_str());

    return HalResult<milliseconds>::unsupported();

}



// -------------------------------------------------------------------------------------------------



HalResult<void> HidlHalWrapperV1_3::setExternalControl(bool enabled) {

    auto result = getHal()->setExternalControl(static_cast<uint32_t>(enabled));

    return HalResultFactory::fromStatus(result.withDefault(V1_0::Status::UNKNOWN_ERROR));

}



HalResult<milliseconds> HidlHalWrapperV1_3::performEffect(

        Effect effect, EffectStrength strength, const std::function<void()>& completionCallback) {

    if (isStaticCastValid<V1_0::Effect>(effect)) {

        return performInternal(&V1_3::IVibrator::perform, getHal(),

                               static_cast<V1_0::Effect>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_1::Effect_1_1>(effect)) {

        return performInternal(&V1_3::IVibrator::perform_1_1, getHal(),

                               static_cast<V1_1::Effect_1_1>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_2::Effect>(effect)) {

        return performInternal(&V1_3::IVibrator::perform_1_2, getHal(),

                               static_cast<V1_2::Effect>(effect), strength, completionCallback);

    }

    if (isStaticCastValid<V1_3::Effect>(effect)) {

        return performInternal(&V1_3::IVibrator::perform_1_3, getHal(),

                               static_cast<V1_3::Effect>(effect), strength, completionCallback);

    }



    ALOGV("Skipped performEffect because Vibrator HAL does not support effect %s",

          Aidl::toString(effect).c_str());

    return HalResult<milliseconds>::unsupported();

}



HalResult<Capabilities> HidlHalWrapperV1_3::getCapabilitiesInternal() {

    Capabilities capabilities = Capabilities::NONE;



    sp<V1_3::IVibrator> hal = getHal();

    auto amplitudeResult = hal->supportsAmplitudeControl();

    if (!amplitudeResult.isOk()) {

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

    }



    auto externalControlResult = hal->supportsExternalControl();

    if (amplitudeResult.withDefault(false)) {

        capabilities |= Capabilities::AMPLITUDE_CONTROL;

    }

    if (externalControlResult.withDefault(false)) {

        capabilities |= Capabilities::EXTERNAL_CONTROL;



        if (amplitudeResult.withDefault(false)) {

            capabilities |= Capabilities::EXTERNAL_AMPLITUDE_CONTROL;

        }

    }



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

                                                      capabilities);

}



// -------------------------------------------------------------------------------------------------



}; // namespace vibrator



}; // namespace android

services/vibratorservice/VibratorManagerHalController.cpp

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


#include <vibratorservice/VibratorManagerHalController.h>



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

using aidl::android::hardware::vibrator::IVibrationSession;

using aidl::android::hardware::vibrator::IVibrator;

using aidl::android::hardware::vibrator::IVibratorManager;

using aidl::android::hardware::vibrator::VibrationSessionConfig;



namespace android {
@@ -29,9 +32,9 @@ namespace vibrator { 
std::shared_ptr<ManagerHalWrapper> connectManagerHal(std::shared_ptr<CallbackScheduler> scheduler) {

    static bool gHalExists = true;

    if (gHalExists) {

        auto serviceName = std::string(Aidl::IVibratorManager::descriptor) + "/default";

        auto serviceName = std::string(IVibratorManager::descriptor) + "/default";

        if (AServiceManager_isDeclared(serviceName.c_str())) {

            std::shared_ptr<Aidl::IVibratorManager> hal = Aidl::IVibratorManager::fromBinder(

            std::shared_ptr<IVibratorManager> hal = IVibratorManager::fromBinder(

                    ndk::SpAIBinder(AServiceManager_checkService(serviceName.c_str())));

            if (hal) {

                ALOGV("Successfully connected to VibratorManager HAL AIDL service.");
@@ -41,6 +44,7 @@ std::shared_ptr<ManagerHalWrapper> connectManagerHal(std::shared_ptr<CallbackSch 
        }

    }



    ALOGV("VibratorManager HAL service not available.");

    gHalExists = false;

    return std::make_shared<LegacyManagerHalWrapper>();

}
@@ -150,10 +154,10 @@ HalResult<void> ManagerHalController::cancelSynced() { 
    return apply(cancelSyncedFn, "cancelSynced");

}



HalResult<std::shared_ptr<Aidl::IVibrationSession>> ManagerHalController::startSession(

        const std::vector<int32_t>& ids, const Aidl::VibrationSessionConfig& config,

HalResult<std::shared_ptr<IVibrationSession>> ManagerHalController::startSession(

        const std::vector<int32_t>& ids, const VibrationSessionConfig& config,

        const std::function<void()>& completionCallback) {

    hal_fn<std::shared_ptr<Aidl::IVibrationSession>> startSessionFn =

    hal_fn<std::shared_ptr<IVibrationSession>> startSessionFn =

            [&](std::shared_ptr<ManagerHalWrapper> hal) {

                return hal->startSession(ids, config, completionCallback);

            };

services/vibratorservice/VibratorManagerHalWrapper.cpp

+19 −18
Original line number Diff line number Diff line
@@ -20,7 +20,10 @@ 


#include <vibratorservice/VibratorManagerHalWrapper.h>



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

using aidl::android::hardware::vibrator::IVibrationSession;

using aidl::android::hardware::vibrator::IVibrator;

using aidl::android::hardware::vibrator::IVibratorManager;

using aidl::android::hardware::vibrator::VibrationSessionConfig;



namespace android {
@@ -41,10 +44,9 @@ HalResult<void> ManagerHalWrapper::cancelSynced() { 
    return HalResult<void>::unsupported();

}



HalResult<std::shared_ptr<Aidl::IVibrationSession>> ManagerHalWrapper::startSession(

        const std::vector<int32_t>&, const Aidl::VibrationSessionConfig&,

        const std::function<void()>&) {

    return HalResult<std::shared_ptr<Aidl::IVibrationSession>>::unsupported();

HalResult<std::shared_ptr<IVibrationSession>> ManagerHalWrapper::startSession(

        const std::vector<int32_t>&, const VibrationSessionConfig&, const std::function<void()>&) {

    return HalResult<std::shared_ptr<IVibrationSession>>::unsupported();

}



HalResult<void> ManagerHalWrapper::clearSessions() {
@@ -87,10 +89,10 @@ HalResult<std::shared_ptr<HalController>> LegacyManagerHalWrapper::getVibrator(i 


std::shared_ptr<HalWrapper> AidlManagerHalWrapper::connectToVibrator(

        int32_t vibratorId, std::shared_ptr<CallbackScheduler> callbackScheduler) {

    std::function<HalResult<std::shared_ptr<Aidl::IVibrator>>()> reconnectFn = [=, this]() {

        std::shared_ptr<Aidl::IVibrator> vibrator;

    std::function<HalResult<std::shared_ptr<IVibrator>>()> reconnectFn = [=, this]() {

        std::shared_ptr<IVibrator> vibrator;

        auto status = this->getHal()->getVibrator(vibratorId, &vibrator);

        return HalResultFactory::fromStatus<std::shared_ptr<Aidl::IVibrator>>(std::move(status),

        return HalResultFactory::fromStatus<std::shared_ptr<IVibrator>>(std::move(status),

                                                                        vibrator);

    };

    auto result = reconnectFn();
@@ -110,8 +112,8 @@ HalResult<void> AidlManagerHalWrapper::ping() { 
}



void AidlManagerHalWrapper::tryReconnect() {

    auto aidlServiceName = std::string(Aidl::IVibratorManager::descriptor) + "/default";

    std::shared_ptr<Aidl::IVibratorManager> newHandle = Aidl::IVibratorManager::fromBinder(

    auto aidlServiceName = std::string(IVibratorManager::descriptor) + "/default";

    std::shared_ptr<IVibratorManager> newHandle = IVibratorManager::fromBinder(

            ndk::SpAIBinder(AServiceManager_checkService(aidlServiceName.c_str())));

    if (newHandle) {

        std::lock_guard<std::mutex> lock(mHandleMutex);
@@ -198,15 +200,14 @@ HalResult<void> AidlManagerHalWrapper::triggerSynced( 
    return HalResultFactory::fromStatus(getHal()->triggerSynced(cb));

}



HalResult<std::shared_ptr<Aidl::IVibrationSession>> AidlManagerHalWrapper::startSession(

        const std::vector<int32_t>& ids, const Aidl::VibrationSessionConfig& config,

HalResult<std::shared_ptr<IVibrationSession>> AidlManagerHalWrapper::startSession(

        const std::vector<int32_t>& ids, const VibrationSessionConfig& config,

        const std::function<void()>& completionCallback) {

    auto cb = ndk::SharedRefBase::make<HalCallbackWrapper>(completionCallback);

    std::shared_ptr<Aidl::IVibrationSession> session;

    std::shared_ptr<IVibrationSession> session;

    auto status = getHal()->startSession(ids, config, cb, &session);

    return HalResultFactory::fromStatus<std::shared_ptr<Aidl::IVibrationSession>>(std::move(status),

                                                                                  std::move(

                                                                                          session));

    return HalResultFactory::fromStatus<std::shared_ptr<IVibrationSession>>(std::move(status),

                                                                            std::move(session));

}



HalResult<void> AidlManagerHalWrapper::cancelSynced() {
@@ -227,7 +228,7 @@ HalResult<void> AidlManagerHalWrapper::clearSessions() { 
    return HalResultFactory::fromStatus(getHal()->clearSessions());

}



std::shared_ptr<Aidl::IVibratorManager> AidlManagerHalWrapper::getHal() {

std::shared_ptr<IVibratorManager> AidlManagerHalWrapper::getHal() {

    std::lock_guard<std::mutex> lock(mHandleMutex);

    return mHandle;

}