Introduce vibration session HAL support
Introduce support to IVibratorManager HAL for vibration sessions. A
session can be started with vendor extension parcelable to support
vendor vibration sessions in the platform.
Vibration sessions allows vibrator commands to be triggered without
resetting the vibrator motor state.
Some updates to the default Vibrator implementation were required to
make sure the vibration and session callbacks are handled by the off()
method as expected by the API docs.
Fix: 345417514
Test: VtsHalVibratorManagerTargetTest
Flag: EXEMPT HAL API changes
Change-Id: Id55ce2f23656c21734f9a18f016676250eb4227b
diff --git a/vibrator/aidl/default/VibratorManager.cpp b/vibrator/aidl/default/VibratorManager.cpp
index 26edf5a..c3be468 100644
--- a/vibrator/aidl/default/VibratorManager.cpp
+++ b/vibrator/aidl/default/VibratorManager.cpp
@@ -15,6 +15,9 @@
*/
#include "vibrator-impl/VibratorManager.h"
+#include "vibrator-impl/VibrationSession.h"
+
+#include <aidl/android/hardware/vibrator/BnVibratorCallback.h>
#include <android-base/logging.h>
#include <thread>
@@ -26,25 +29,52 @@
static constexpr int32_t kDefaultVibratorId = 1;
+class VibratorCallback : public BnVibratorCallback {
+ public:
+ VibratorCallback(const std::function<void()>& callback) : mCallback(callback) {}
+ ndk::ScopedAStatus onComplete() override {
+ mCallback();
+ return ndk::ScopedAStatus::ok();
+ }
+
+ private:
+ std::function<void()> mCallback;
+};
+
ndk::ScopedAStatus VibratorManager::getCapabilities(int32_t* _aidl_return) {
- LOG(INFO) << "Vibrator manager reporting capabilities";
- *_aidl_return =
- IVibratorManager::CAP_SYNC | IVibratorManager::CAP_PREPARE_ON |
- IVibratorManager::CAP_PREPARE_PERFORM | IVibratorManager::CAP_PREPARE_COMPOSE |
- IVibratorManager::CAP_MIXED_TRIGGER_ON | IVibratorManager::CAP_MIXED_TRIGGER_PERFORM |
- IVibratorManager::CAP_MIXED_TRIGGER_COMPOSE | IVibratorManager::CAP_TRIGGER_CALLBACK;
+ LOG(VERBOSE) << "Vibrator manager reporting capabilities";
+ std::lock_guard lock(mMutex);
+ if (mCapabilities == 0) {
+ int32_t version;
+ if (!getInterfaceVersion(&version).isOk()) {
+ return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_ILLEGAL_STATE));
+ }
+ mCapabilities = IVibratorManager::CAP_SYNC | IVibratorManager::CAP_PREPARE_ON |
+ IVibratorManager::CAP_PREPARE_PERFORM |
+ IVibratorManager::CAP_PREPARE_COMPOSE |
+ IVibratorManager::CAP_MIXED_TRIGGER_ON |
+ IVibratorManager::CAP_MIXED_TRIGGER_PERFORM |
+ IVibratorManager::CAP_MIXED_TRIGGER_COMPOSE |
+ IVibratorManager::CAP_TRIGGER_CALLBACK;
+
+ if (version >= 3) {
+ mCapabilities |= IVibratorManager::CAP_START_SESSIONS;
+ }
+ }
+
+ *_aidl_return = mCapabilities;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus VibratorManager::getVibratorIds(std::vector<int32_t>* _aidl_return) {
- LOG(INFO) << "Vibrator manager getting vibrator ids";
+ LOG(VERBOSE) << "Vibrator manager getting vibrator ids";
*_aidl_return = {kDefaultVibratorId};
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus VibratorManager::getVibrator(int32_t vibratorId,
std::shared_ptr<IVibrator>* _aidl_return) {
- LOG(INFO) << "Vibrator manager getting vibrator " << vibratorId;
+ LOG(VERBOSE) << "Vibrator manager getting vibrator " << vibratorId;
if (vibratorId == kDefaultVibratorId) {
*_aidl_return = mDefaultVibrator;
return ndk::ScopedAStatus::ok();
@@ -55,32 +85,131 @@
}
ndk::ScopedAStatus VibratorManager::prepareSynced(const std::vector<int32_t>& vibratorIds) {
- LOG(INFO) << "Vibrator Manager prepare synced";
- if (vibratorIds.size() == 1 && vibratorIds[0] == kDefaultVibratorId) {
- return ndk::ScopedAStatus::ok();
- } else {
+ LOG(VERBOSE) << "Vibrator Manager prepare synced";
+ if (vibratorIds.size() != 1 || vibratorIds[0] != kDefaultVibratorId) {
return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
}
+ std::lock_guard lock(mMutex);
+ if (mIsPreparing) {
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
+ }
+ mIsPreparing = true;
+ return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus VibratorManager::triggerSynced(
const std::shared_ptr<IVibratorCallback>& callback) {
- LOG(INFO) << "Vibrator Manager trigger synced";
+ LOG(VERBOSE) << "Vibrator Manager trigger synced";
+ std::lock_guard lock(mMutex);
+ if (!mIsPreparing) {
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
+ }
std::thread([callback] {
if (callback != nullptr) {
- LOG(INFO) << "Notifying perform complete";
+ LOG(VERBOSE) << "Notifying perform complete";
callback->onComplete();
}
}).detach();
-
+ mIsPreparing = false;
return ndk::ScopedAStatus::ok();
}
ndk::ScopedAStatus VibratorManager::cancelSynced() {
- LOG(INFO) << "Vibrator Manager cancel synced";
+ LOG(VERBOSE) << "Vibrator Manager cancel synced";
+ std::lock_guard lock(mMutex);
+ mIsPreparing = false;
return ndk::ScopedAStatus::ok();
}
+ndk::ScopedAStatus VibratorManager::startSession(const std::vector<int32_t>& vibratorIds,
+ const VibrationSessionConfig&,
+ const std::shared_ptr<IVibratorCallback>& callback,
+ std::shared_ptr<IVibrationSession>* _aidl_return) {
+ LOG(VERBOSE) << "Vibrator Manager start session";
+ *_aidl_return = nullptr;
+ int32_t capabilities = 0;
+ if (!getCapabilities(&capabilities).isOk()) {
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
+ }
+ if ((capabilities & IVibratorManager::CAP_START_SESSIONS) == 0) {
+ return ndk::ScopedAStatus(AStatus_fromExceptionCode(EX_UNSUPPORTED_OPERATION));
+ }
+ if (vibratorIds.size() != 1 || vibratorIds[0] != kDefaultVibratorId) {
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+ }
+ std::lock_guard lock(mMutex);
+ if (mIsPreparing || mSession) {
+ return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_STATE);
+ }
+ mSessionCallback = callback;
+ mSession = ndk::SharedRefBase::make<VibrationSession>(this->ref<VibratorManager>());
+ *_aidl_return = static_cast<std::shared_ptr<IVibrationSession>>(mSession);
+ return ndk::ScopedAStatus::ok();
+}
+
+ndk::ScopedAStatus VibratorManager::clearSessions() {
+ LOG(VERBOSE) << "Vibrator Manager clear sessions";
+ abortSession();
+ return ndk::ScopedAStatus::ok();
+}
+
+void VibratorManager::abortSession() {
+ std::shared_ptr<IVibrationSession> session;
+ {
+ std::lock_guard lock(mMutex);
+ session = mSession;
+ }
+ if (session) {
+ mDefaultVibrator->off();
+ clearSession(session);
+ }
+}
+
+void VibratorManager::closeSession(int32_t delayMs) {
+ std::shared_ptr<IVibrationSession> session;
+ {
+ std::lock_guard lock(mMutex);
+ if (mIsClosingSession) {
+ // Already closing session, ignore this.
+ return;
+ }
+ session = mSession;
+ mIsClosingSession = true;
+ }
+ if (session) {
+ auto callback = ndk::SharedRefBase::make<VibratorCallback>(
+ [session, delayMs, sharedThis = this->ref<VibratorManager>()] {
+ LOG(VERBOSE) << "Closing session after vibrator became idle";
+ usleep(delayMs * 1000);
+
+ if (sharedThis) {
+ sharedThis->clearSession(session);
+ }
+ });
+ mDefaultVibrator->setGlobalVibrationCallback(callback);
+ }
+}
+
+void VibratorManager::clearSession(const std::shared_ptr<IVibrationSession>& session) {
+ std::lock_guard lock(mMutex);
+ if (mSession != session) {
+ // Probably a delayed call from an old session that was already cleared, ignore it.
+ return;
+ }
+ std::shared_ptr<IVibratorCallback> callback = mSessionCallback;
+ mSession = nullptr;
+ mSessionCallback = nullptr; // make sure any delayed call will not trigger this again.
+ mIsClosingSession = false;
+ if (callback) {
+ std::thread([callback] {
+ LOG(VERBOSE) << "Notifying session complete";
+ if (!callback->onComplete().isOk()) {
+ LOG(ERROR) << "Failed to call onComplete";
+ }
+ }).detach();
+ }
+}
+
} // namespace vibrator
} // namespace hardware
} // namespace android