Simplify libvibratorservice after HIDL support removal

Introduce a simplified VibratorController class to the
libvibratorservice module that only handles AIDL vibrator HAL versions
and reuse the binder ndk objects.

This removes all wrapper classes introduced to handle both AIDL and HIDL
objects seamlesly, reducing complexity for the library.

The connect/reconnect logic on transcation falure remains, with most HAL
operations working with a retry logic.

This first change introduced the core for the VibratorController with
basic APIs like off / setAmplitude / setExternalControl.

Following changes will introduce the remaining IVibrator API support.

Bug: 308452413
Test: libvibratorservice_test
Flag: android.os.vibrator.remove_hidl_support
Change-Id: Ie76168eaf9fd5cd0ce9719499d4ef9b086b2fca6

7 files changed, 572 insertions, 4 deletions

diff --git a/services/vibratorservice/Android.bp b/services/vibratorservice/Android.bp
index ed03cfc3f5..4b12cc20a4 100644
--- a/services/vibratorservice/Android.bp
+++ b/services/vibratorservice/Android.bp
@@ -26,6 +26,7 @@ cc_library_shared {
 
     srcs: [
         "VibratorCallbackScheduler.cpp",
+        "VibratorController.cpp",
         "VibratorHalController.cpp",
         "VibratorHalWrapper.cpp",
         "VibratorManagerHalController.cpp",
@@ -41,17 +42,17 @@ cc_library_shared {
     },
 
     shared_libs: [
+        "android.hardware.vibrator-V3-ndk",
         "libbinder_ndk",
         "liblog",
         "libutils",
-        "android.hardware.vibrator-V3-ndk",
     ],
 
     cflags: [
         "-Wall",
         "-Werror",
-        "-Wunused",
         "-Wunreachable-code",
+        "-Wunused",
     ],
 
     local_include_dirs: ["include"],
diff --git a/services/vibratorservice/VibratorController.cpp b/services/vibratorservice/VibratorController.cpp
new file mode 100644
index 0000000000..21924e9f13
--- /dev/null
+++ b/services/vibratorservice/VibratorController.cpp
@@ -0,0 +1,196 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "VibratorController"
+
+#ifndef qDoWithRetries
+#define qDoWithRetries(op) doWithRetries(op, __FUNCTION__)
+#endif
+
+#include <aidl/android/hardware/vibrator/IVibrator.h>
+#include <android/binder_manager.h>
+#include <binder/IServiceManager.h>
+
+#include <utils/Log.h>
+
+#include <vibratorservice/VibratorController.h>
+
+using ::aidl::android::hardware::vibrator::Effect;
+using ::aidl::android::hardware::vibrator::EffectStrength;
+using ::aidl::android::hardware::vibrator::IVibrator;
+
+using Status = ::ndk::ScopedAStatus;
+
+using namespace std::placeholders;
+
+namespace android {
+
+namespace vibrator {
+
+// -------------------------------------------------------------------------------------------------
+
+inline bool isStatusUnsupported(const Status& status) {
+    // STATUS_UNKNOWN_TRANSACTION means the HAL is an older version, so operation is unsupported.
+    return status.getStatus() == STATUS_UNKNOWN_TRANSACTION ||
+            status.getExceptionCode() == EX_UNSUPPORTED_OPERATION;
+}
+
+inline bool isStatusTransactionFailed(const Status& status) {
+    // STATUS_UNKNOWN_TRANSACTION means the HAL is an older version, so operation is unsupported.
+    return status.getStatus() != STATUS_UNKNOWN_TRANSACTION &&
+            status.getExceptionCode() == EX_TRANSACTION_FAILED;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+bool VibratorProvider::isDeclared() {
+    std::lock_guard<std::mutex> lock(mMutex);
+    if (mIsDeclared.has_value()) {
+        return *mIsDeclared;
+    }
+
+    bool isDeclared = AServiceManager_isDeclared(mServiceName.c_str());
+    if (!isDeclared) {
+        ALOGV("Vibrator HAL service not declared.");
+    }
+
+    mIsDeclared.emplace(isDeclared);
+    return isDeclared;
+}
+
+std::shared_ptr<IVibrator> VibratorProvider::waitForVibrator() {
+    if (!isDeclared()) {
+        return nullptr;
+    }
+
+    auto vibrator = IVibrator::fromBinder(
+            ndk::SpAIBinder(AServiceManager_waitForService(mServiceName.c_str())));
+    if (vibrator) {
+        ALOGV("Successfully connected to Vibrator HAL service.");
+    } else {
+        ALOGE("Error connecting to declared Vibrator HAL service.");
+    }
+
+    return vibrator;
+}
+
+std::shared_ptr<IVibrator> VibratorProvider::checkForVibrator() {
+    if (!isDeclared()) {
+        return nullptr;
+    }
+
+    auto vibrator = IVibrator::fromBinder(
+            ndk::SpAIBinder(AServiceManager_checkService(mServiceName.c_str())));
+    if (vibrator) {
+        ALOGV("Successfully reconnected to Vibrator HAL service.");
+    } else {
+        ALOGE("Error reconnecting to declared Vibrator HAL service.");
+    }
+
+    return vibrator;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+bool VibratorController::init() {
+    if (!mVibratorProvider->isDeclared()) {
+        return false;
+    }
+    std::lock_guard<std::mutex> lock(mMutex);
+    if (mVibrator == nullptr) {
+        mVibrator = mVibratorProvider->waitForVibrator();
+    }
+    return mVibratorProvider->isDeclared();
+}
+
+Status VibratorController::off() {
+    return qDoWithRetries(std::bind(&IVibrator::off, _1));
+}
+
+Status VibratorController::setAmplitude(float amplitude) {
+    return qDoWithRetries(std::bind(&IVibrator::setAmplitude, _1, amplitude));
+}
+
+Status VibratorController::setExternalControl(bool enabled) {
+    return qDoWithRetries(std::bind(&IVibrator::setExternalControl, _1, enabled));
+}
+
+Status VibratorController::alwaysOnEnable(int32_t id, const Effect& effect,
+                                          const EffectStrength& strength) {
+    return qDoWithRetries(std::bind(&IVibrator::alwaysOnEnable, _1, id, effect, strength));
+}
+
+Status VibratorController::alwaysOnDisable(int32_t id) {
+    return qDoWithRetries(std::bind(&IVibrator::alwaysOnDisable, _1, id));
+}
+
+// -------------------------------------------------------------------------------------------------
+
+std::shared_ptr<IVibrator> VibratorController::reconnectToVibrator() {
+    std::lock_guard<std::mutex> lock(mMutex);
+    mVibrator = mVibratorProvider->checkForVibrator();
+    return mVibrator;
+}
+
+Status VibratorController::doWithRetries(const VibratorController::VibratorOp& op,
+                                         const char* logLabel) {
+    if (!init()) {
+        ALOGV("Skipped %s because Vibrator HAL is not declared", logLabel);
+        return Status::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE, "IVibrator not declared");
+    }
+    std::shared_ptr<IVibrator> vibrator;
+    {
+        std::lock_guard<std::mutex> lock(mMutex);
+        vibrator = mVibrator;
+    }
+
+    if (!vibrator) {
+        ALOGE("Skipped %s because Vibrator HAL is declared but failed to load", logLabel);
+        return Status::fromExceptionCodeWithMessage(EX_ILLEGAL_STATE,
+                                                    "IVibrator declared but failed to load");
+    }
+
+    auto status = doOnce(vibrator.get(), op, logLabel);
+    for (int i = 1; i < MAX_ATTEMPTS && isStatusTransactionFailed(status); i++) {
+        vibrator = reconnectToVibrator();
+        if (!vibrator) {
+            // Failed to reconnect to vibrator HAL after a transaction failed, skip retries.
+            break;
+        }
+        status = doOnce(vibrator.get(), op, logLabel);
+    }
+
+    return status;
+}
+
+Status VibratorController::doOnce(IVibrator* vibrator, const VibratorController::VibratorOp& op,
+                                  const char* logLabel) {
+    auto status = op(vibrator);
+    if (!status.isOk()) {
+        if (isStatusUnsupported(status)) {
+            ALOGV("Vibrator HAL %s is unsupported: %s", logLabel, status.getMessage());
+        } else {
+            ALOGE("Vibrator HAL %s failed: %s", logLabel, status.getMessage());
+        }
+    }
+    return status;
+}
+
+// -------------------------------------------------------------------------------------------------
+
+}; // namespace vibrator
+
+}; // namespace android
diff --git a/services/vibratorservice/include/vibratorservice/VibratorController.h b/services/vibratorservice/include/vibratorservice/VibratorController.h
new file mode 100644
index 0000000000..691c8ae518
--- /dev/null
+++ b/services/vibratorservice/include/vibratorservice/VibratorController.h
@@ -0,0 +1,118 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ANDROID_OS_VIBRATOR_CONTROLLER_H
+#define ANDROID_OS_VIBRATOR_CONTROLLER_H
+
+#include <aidl/android/hardware/vibrator/IVibrator.h>
+
+#include <android-base/thread_annotations.h>
+
+namespace android {
+
+namespace vibrator {
+
+// -------------------------------------------------------------------------------------------------
+
+/* Provider for IVibrator HAL service instances. */
+class VibratorProvider {
+public:
+    using IVibrator = ::aidl::android::hardware::vibrator::IVibrator;
+
+    VibratorProvider() : mServiceName(std::string(IVibrator::descriptor) + "/default") {}
+    virtual ~VibratorProvider() = default;
+
+    /* Returns true if vibrator HAL service is declared in the device, false otherwise. */
+    virtual bool isDeclared();
+
+    /* Connects to vibrator HAL, possibly waiting for the declared service to become available. */
+    virtual std::shared_ptr<IVibrator> waitForVibrator();
+
+    /* Connects to vibrator HAL if declared and available, without waiting. */
+    virtual std::shared_ptr<IVibrator> checkForVibrator();
+
+private:
+    std::mutex mMutex;
+    const std::string mServiceName;
+    std::optional<bool> mIsDeclared GUARDED_BY(mMutex);
+};
+
+// -------------------------------------------------------------------------------------------------
+
+/* Controller for Vibrator HAL handle.
+ * This relies on VibratorProvider to connect to the underlying Vibrator HAL service and reconnects
+ * after each transaction failed call. This also ensures connecting to the service is thread-safe.
+ */
+class VibratorController {
+public:
+    using Effect = ::aidl::android::hardware::vibrator::Effect;
+    using EffectStrength = ::aidl::android::hardware::vibrator::EffectStrength;
+    using IVibrator = ::aidl::android::hardware::vibrator::IVibrator;
+    using Status = ::ndk::ScopedAStatus;
+    using VibratorOp = std::function<Status(IVibrator*)>;
+
+    VibratorController() : VibratorController(std::make_shared<VibratorProvider>()) {}
+    VibratorController(std::shared_ptr<VibratorProvider> vibratorProvider)
+          : mVibratorProvider(std::move(vibratorProvider)), mVibrator(nullptr) {}
+    virtual ~VibratorController() = default;
+
+    /* Connects HAL service, possibly waiting for the declared service to become available.
+     * This will automatically be called at the first API usage if it was not manually called
+     * beforehand. Call this manually during the setup phase to avoid slowing the first API call.
+     * Returns true if HAL service is declared, false otherwise.
+     */
+    bool init();
+
+    /* Turn vibrator off. */
+    Status off();
+
+    /* Set vibration amplitude in [0,1]. */
+    Status setAmplitude(float amplitude);
+
+    /* Enable/disable external control. */
+    Status setExternalControl(bool enabled);
+
+    /* Enable always-on for given id, with given effect and strength. */
+    Status alwaysOnEnable(int32_t id, const Effect& effect, const EffectStrength& strength);
+
+    /* Disable always-on for given id. */
+    Status alwaysOnDisable(int32_t id);
+
+private:
+    /* Max number of attempts to perform an operation when it fails with transaction error. */
+    static constexpr int MAX_ATTEMPTS = 2;
+
+    std::mutex mMutex;
+    std::shared_ptr<VibratorProvider> mVibratorProvider;
+    std::shared_ptr<IVibrator> mVibrator GUARDED_BY(mMutex);
+
+    /* Reconnects HAL service without waiting for the service to become available. */
+    std::shared_ptr<IVibrator> reconnectToVibrator();
+
+    /* Perform given operation on HAL with retries on transaction failures. */
+    Status doWithRetries(const VibratorOp& op, const char* logLabel);
+
+    /* Perform given operation on HAL with logs for error/unsupported results. */
+    static Status doOnce(IVibrator* vibrator, const VibratorOp& op, const char* logLabel);
+};
+
+// -------------------------------------------------------------------------------------------------
+
+}; // namespace vibrator
+
+}; // namespace android
+
+#endif // ANDROID_OS_VIBRATOR_CONTROLLER_H
diff --git a/services/vibratorservice/include/vibratorservice/VibratorHalController.h b/services/vibratorservice/include/vibratorservice/VibratorHalController.h
index a1cb3fad35..9b3202bc60 100644
--- a/services/vibratorservice/include/vibratorservice/VibratorHalController.h
+++ b/services/vibratorservice/include/vibratorservice/VibratorHalController.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+// TODO(b/308452413): remove this file once android.os.vibrator.remove_hidl_support is removed
+
 #ifndef ANDROID_OS_VIBRATORHALCONTROLLER_H
 #define ANDROID_OS_VIBRATORHALCONTROLLER_H
 
diff --git a/services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h b/services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h
index 065227861d..68568d4163 100644
--- a/services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h
+++ b/services/vibratorservice/include/vibratorservice/VibratorHalWrapper.h
@@ -14,6 +14,8 @@
  * limitations under the License.
  */
 
+// TODO(b/308452413): remove this file once android.os.vibrator.remove_hidl_support is removed
+
 #ifndef ANDROID_OS_VIBRATORHALWRAPPER_H
 #define ANDROID_OS_VIBRATORHALWRAPPER_H
 
diff --git a/services/vibratorservice/test/Android.bp b/services/vibratorservice/test/Android.bp
index 038248e636..92c6286513 100644
--- a/services/vibratorservice/test/Android.bp
+++ b/services/vibratorservice/test/Android.bp
@@ -27,6 +27,7 @@ cc_test {
     test_suites: ["device-tests"],
     srcs: [
         "VibratorCallbackSchedulerTest.cpp",
+        "VibratorControllerTest.cpp",
         "VibratorHalControllerTest.cpp",
         "VibratorHalWrapperAidlTest.cpp",
         "VibratorManagerHalControllerTest.cpp",
@@ -39,12 +40,12 @@ cc_test {
         "-Wextra",
     ],
     shared_libs: [
+        "android.hardware.vibrator-V3-ndk",
         "libbase",
         "libbinder_ndk",
         "liblog",
-        "libvibratorservice",
         "libutils",
-        "android.hardware.vibrator-V3-ndk",
+        "libvibratorservice",
     ],
     static_libs: [
         "libgmock",
diff --git a/services/vibratorservice/test/VibratorControllerTest.cpp b/services/vibratorservice/test/VibratorControllerTest.cpp
new file mode 100644
index 0000000000..11ec75bc36
--- /dev/null
+++ b/services/vibratorservice/test/VibratorControllerTest.cpp
@@ -0,0 +1,248 @@
+/*
+ * Copyright (C) 2025 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *            http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#define LOG_TAG "VibratorControllerTest"
+
+#include <aidl/android/hardware/vibrator/IVibrator.h>
+
+#include <gmock/gmock.h>
+#include <gtest/gtest.h>
+
+#include <utils/Log.h>
+#include <thread>
+
+#include <vibratorservice/VibratorController.h>
+
+#include "test_mocks.h"
+#include "test_utils.h"
+
+using ::aidl::android::hardware::vibrator::Effect;
+using ::aidl::android::hardware::vibrator::EffectStrength;
+using ::aidl::android::hardware::vibrator::IVibrator;
+
+using namespace android;
+using namespace testing;
+
+const auto kReturnOk = []() { return ndk::ScopedAStatus::ok(); };
+const auto kReturnUnsupported = []() {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+};
+const auto kReturnTransactionFailed = []() {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_TRANSACTION_FAILED);
+};
+const auto kReturnUnknownTransaction = []() {
+    return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_TRANSACTION);
+};
+const auto kReturnIllegalArgument = []() {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
+};
+
+// -------------------------------------------------------------------------------------------------
+
+/* Provides mock IVibrator instance for testing. */
+class FakeVibratorProvider : public vibrator::VibratorProvider {
+public:
+    FakeVibratorProvider()
+          : mIsDeclared(true),
+            mMockVibrator(ndk::SharedRefBase::make<StrictMock<vibrator::MockIVibrator>>()),
+            mConnectCount(0),
+            mReconnectCount(0) {}
+    virtual ~FakeVibratorProvider() = default;
+
+    bool isDeclared() override { return mIsDeclared; }
+
+    std::shared_ptr<IVibrator> waitForVibrator() override {
+        mConnectCount++;
+        return mIsDeclared ? mMockVibrator : nullptr;
+    }
+
+    std::shared_ptr<IVibrator> checkForVibrator() override {
+        mReconnectCount++;
+        return mIsDeclared ? mMockVibrator : nullptr;
+    }
+
+    void setDeclared(bool isDeclared) { mIsDeclared = isDeclared; }
+
+    int32_t getConnectCount() { return mConnectCount; }
+
+    int32_t getReconnectCount() { return mReconnectCount; }
+
+    std::shared_ptr<StrictMock<vibrator::MockIVibrator>> getMockVibrator() { return mMockVibrator; }
+
+private:
+    bool mIsDeclared;
+    std::shared_ptr<StrictMock<vibrator::MockIVibrator>> mMockVibrator;
+    int32_t mConnectCount;
+    int32_t mReconnectCount;
+};
+
+// -------------------------------------------------------------------------------------------------
+
+class VibratorControllerTest : public Test {
+public:
+    void SetUp() override {
+        mProvider = std::make_shared<FakeVibratorProvider>();
+        mController = std::make_unique<vibrator::VibratorController>(mProvider);
+        ASSERT_NE(mController, nullptr);
+    }
+
+protected:
+    std::shared_ptr<FakeVibratorProvider> mProvider = nullptr;
+    std::unique_ptr<vibrator::VibratorController> mController = nullptr;
+};
+
+// -------------------------------------------------------------------------------------------------
+
+TEST_F(VibratorControllerTest, TestInitServiceDeclared) {
+    ASSERT_TRUE(mController->init());
+    ASSERT_EQ(1, mProvider->getConnectCount());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+
+    // Noop when wrapper was already initialized.
+    ASSERT_TRUE(mController->init());
+    ASSERT_EQ(1, mProvider->getConnectCount());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestInitServiceNotDeclared) {
+    mProvider->setDeclared(false);
+
+    ASSERT_FALSE(mController->init());
+    ASSERT_EQ(0, mProvider->getConnectCount());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+
+    ASSERT_FALSE(mController->init());
+    ASSERT_EQ(0, mProvider->getConnectCount());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestFirstCallTriggersInit) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+
+    auto status = mController->off();
+    ASSERT_TRUE(status.isOk());
+    ASSERT_EQ(1, mProvider->getConnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestSuccessfulResultDoesNotRetry) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+
+    auto status = mController->off();
+    ASSERT_TRUE(status.isOk());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestUnsupportedOperationResultDoesNotRetry) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnUnsupported);
+
+    auto status = mController->off();
+    ASSERT_FALSE(status.isOk());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestUnknownTransactionResultDoesNotRetry) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnUnknownTransaction);
+
+    auto status = mController->off();
+    ASSERT_FALSE(status.isOk());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestOperationFailedDoesNotRetry) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnIllegalArgument);
+
+    auto status = mController->off();
+    ASSERT_FALSE(status.isOk());
+    ASSERT_EQ(0, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestTransactionFailedRetriesOnlyOnce) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(2))
+            .WillRepeatedly(kReturnTransactionFailed);
+
+    auto status = mController->off();
+    ASSERT_FALSE(status.isOk());
+    ASSERT_EQ(1, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestTransactionFailedThenSucceedsReturnsSuccessAfterRetries) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(2))
+            .WillOnce(kReturnTransactionFailed)
+            .WillRepeatedly(kReturnOk);
+
+    auto status = mController->off();
+    ASSERT_TRUE(status.isOk());
+    ASSERT_EQ(1, mProvider->getReconnectCount());
+}
+
+TEST_F(VibratorControllerTest, TestOff) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), off())
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+
+    auto status = mController->off();
+    ASSERT_TRUE(status.isOk());
+}
+
+TEST_F(VibratorControllerTest, TestSetAmplitude) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), setAmplitude(Eq(0.1f)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), setAmplitude(Eq(0.2f)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnIllegalArgument);
+
+    ASSERT_TRUE(mController->setAmplitude(0.1f).isOk());
+    ASSERT_FALSE(mController->setAmplitude(0.2f).isOk());
+}
+
+TEST_F(VibratorControllerTest, TestSetExternalControl) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), setExternalControl(Eq(false)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+    EXPECT_CALL(*mProvider->getMockVibrator().get(), setExternalControl(Eq(true)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnIllegalArgument);
+
+    ASSERT_TRUE(mController->setExternalControl(false).isOk());
+    ASSERT_FALSE(mController->setExternalControl(true).isOk());
+}
+
+TEST_F(VibratorControllerTest, TestAlwaysOnEnable) {
+    EXPECT_CALL(*mProvider->getMockVibrator().get(),
+                alwaysOnEnable(Eq(1), Eq(Effect::CLICK), Eq(EffectStrength::LIGHT)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnOk);
+    EXPECT_CALL(*mProvider->getMockVibrator().get(),
+                alwaysOnEnable(Eq(2), Eq(Effect::TICK), Eq(EffectStrength::MEDIUM)))
+            .Times(Exactly(1))
+            .WillRepeatedly(kReturnIllegalArgument);
+
+    ASSERT_TRUE(mController->alwaysOnEnable(1, Effect::CLICK, EffectStrength::LIGHT).isOk());
+    ASSERT_FALSE(mController->alwaysOnEnable(2, Effect::TICK, EffectStrength::MEDIUM).isOk());
+}