Merge "Removing Vibrator HIDL HAL support from frameworks" into main (cedbda82) · Commits · e / os / android_frameworks_native

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