Use android.hardware.vibrator NDK backend (818a2257) · Commits · e / os / android_frameworks_native

services/vibratorservice/Android.bp

+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",

services/vibratorservice/VibratorHalController.cpp

+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();

services/vibratorservice/VibratorHalWrapper.cpp

+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);
		}

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

services/vibratorservice/VibratorManagerHalController.cpp

+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));
		}
		}
		}

services/vibratorservice/VibratorManagerHalWrapper.cpp

+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;
		}