sm7125: vibrator: Update to hardware/samsung AIDL implementation

Change-Id: I6e912e74bebf10a6f15acb347135a763bf473383

common.mk

@@ -406,7 +406,7 @@ PRODUCT_PACKAGES += \
 
 # Vibrator
 PRODUCT_PACKAGES += \
-    android.hardware.vibrator@1.3-service.sm7125
+    android.hardware.vibrator-service.sm7125
 
 # Tether
 PRODUCT_PACKAGES += \

sepolicy/vendor/file_contexts

@@ -20,6 +20,6 @@
 /(vendor|system/vendor)/bin/hw/vendor\.lineage\.livedisplay@2\.0-service.samsung-qcom\.sm7125		u:object_r:hal_lineage_livedisplay_sysfs_exec:s0
 /(vendor|system/vendor)/bin/hw/vendor.samsung.hardware.biometrics.fingerprint@3.0-service.sm7125		u:object_r:hal_fingerprint_default_exec:s0
 /(vendor|system/vendor)/bin/hw/vendor.lineage.biometrics.fingerprint.inscreen@1.0-service.samsung.sm7125	u:object_r:hal_lineage_fod_default_exec:s0
-/(vendor|system/vendor)/bin/hw/android.hardware.vibrator@1.3-service.sm7125					u:object_r:hal_vibrator_default_exec:s0
+/(vendor|system/vendor)/bin/hw/android.hardware.vibrator-service.sm7125					u:object_r:hal_vibrator_default_exec:s0
 /(vendor|system/vendor)/bin/hw/android\.hardware\.nfc@1\.2-service\.samsung					u:object_r:hal_nfc_default_exec:s0
 /(vendor|system/vendor)/bin/hw/android\.hardware\.power-service\.samsung-libperfmgr				u:object_r:hal_power_default_exec:s0

vibrator/Android.bp

@@ -1,35 +1,22 @@
-// Copyright (C) 2020 The LineageOS 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
+// Copyright (C) 2022 The LineageOS Project
 //
-//      http://www.apache.org/licenses/LICENSE-2.0
+// SPDX-License-Identifier: Apache-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.
 
 cc_binary {
-    name: "android.hardware.vibrator@1.3-service.sm7125",
-    defaults: ["hidl_defaults"],
-    vendor: true,
+    name: "android.hardware.vibrator-service.sm7125",
     relative_install_path: "hw",
-    init_rc: ["android.hardware.vibrator@1.3-service.sm7125.rc"],
-    vintf_fragments: ["android.hardware.vibrator@1.3-service.sm7125.xml"],
-    srcs: ["service.cpp", "Vibrator.cpp"],
-    cflags: ["-Wall", "-Wextra", "-Werror"],
+    init_rc: ["android.hardware.vibrator-service.sm7125.rc"],
+    vintf_fragments: ["android.hardware.vibrator-service.sm7125.xml"],
+    srcs: [
+        "Vibrator.cpp",
+        "service.cpp",
+    ],
     shared_libs: [
         "libbase",
-        "libhidlbase",
-        "liblog",
-        "libutils",
-        "libhardware",
-        "android.hardware.vibrator@1.0",
-        "android.hardware.vibrator@1.1",
-        "android.hardware.vibrator@1.2",
-        "android.hardware.vibrator@1.3",
+        "libbinder_ndk",
+        "android.hardware.vibrator-V2-ndk_platform",
     ],
+    vendor: true,
 }

vibrator/Vibrator.cpp

@@ -1,48 +1,32 @@
 /*
- * Copyright (C) 2020 The LineageOS Project
+ * Copyright (C) 2022 The LineageOS 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.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-#define LOG_TAG "vibrator@1.3-sm7125"
-
 #include "Vibrator.h"
 
 #include <android-base/logging.h>
-#include <android-base/stringprintf.h>
-#include <hardware/hardware.h>
-#include <hardware/vibrator.h>
 
-#include <cinttypes>
 #include <cmath>
 #include <fstream>
 #include <iostream>
+#include <thread>
 
+namespace aidl {
 namespace android {
 namespace hardware {
 namespace vibrator {
-namespace V1_3 {
-namespace implementation {
 
 /*
  * Write value to path and close file.
  */
 template <typename T>
-static Return<Status> writeNode(const std::string& path, const T& value) {
+static ndk::ScopedAStatus writeNode(const std::string& path, const T& value) {
     std::ofstream node(path);
     if (!node) {
         LOG(ERROR) << "Failed to open: " << path;
-        return Status::UNKNOWN_ERROR;
+        return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_ERROR);
     }
 
     LOG(DEBUG) << "writeNode node: " << path << " value: " << value;
@@ -50,10 +34,10 @@ static Return<Status> writeNode(const std::string& path, const T& value) {
     node << value << std::endl;
     if (!node) {
         LOG(ERROR) << "Failed to write: " << value;
-        return Status::UNKNOWN_ERROR;
+        return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_ERROR);
     }
 
-    return Status::OK;
+    return ndk::ScopedAStatus::ok();
 }
 
 static bool nodeExists(const std::string& path) {
@@ -62,134 +46,188 @@ static bool nodeExists(const std::string& path) {
 }
 
 Vibrator::Vibrator() {
-    bool ok;
+    mIsTimedOutVibrator = nodeExists(VIBRATOR_TIMEOUT_PATH);
+    mHasTimedOutIntensity = nodeExists(VIBRATOR_INTENSITY_PATH);
+}
 
-    ok = nodeExists(VIBRATOR_TIMEOUT_PATH);
-    if (ok) {
-        mIsTimedOutVibriator = true;
+ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
+    *_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
+                    IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
+                    IVibrator::CAP_ALWAYS_ON_CONTROL*/;
+
+    if (mHasTimedOutIntensity) {
+        *_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
+                        IVibrator::CAP_EXTERNAL_AMPLITUDE_CONTROL;
     }
 
-    ok = nodeExists(VIBRATOR_INTENSITY_PATH);
-    if (ok) {
-        mhasTimedOutIntensity = true;
+    return ndk::ScopedAStatus::ok();
 }
+
+ndk::ScopedAStatus Vibrator::off() {
+    return activate(0);
 }
 
-// Methods from ::android::hardware::vibrator::V1_0::IVibrator follow.
+ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) {
+    ndk::ScopedAStatus status = activate(timeoutMs);
 
-Return<Status> Vibrator::on(uint32_t timeoutMs) {
-    return activate(timeoutMs);
+    if (callback != nullptr) {
+        std::thread([=] {
+            LOG(INFO) << "Starting on on another thread";
+            usleep(timeoutMs * 1000);
+            LOG(INFO) << "Notifying on complete";
+            if (!callback->onComplete().isOk()) {
+                LOG(ERROR) << "Failed to call onComplete";
+            }
+        }).detach();
     }
 
-Return<Status> Vibrator::off() {
-    return activate(0);
+    return status;
 }
 
-Return<bool> Vibrator::supportsAmplitudeControl() {
-    return true;
+ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) {
+    ndk::ScopedAStatus status;
+    uint8_t amplitude;
+    uint32_t ms;
+
+    amplitude = strengthToAmplitude(strength, &status);
+    if (!status.isOk()) {
+        return status;
+    }
+    setAmplitude(amplitude);
+
+    ms = effectToMs(effect, &status);
+    if (!status.isOk()) {
+        return status;
+    }
+    status = activate(ms);
+
+    if (callback != nullptr) {
+        std::thread([=] {
+            LOG(INFO) << "Starting perform on another thread";
+            usleep(ms * 1000);
+            LOG(INFO) << "Notifying perform complete";
+            callback->onComplete();
+        }).detach();
+    }
+
+    *_aidl_return = ms;
+    return status;
 }
 
-Return<Status> Vibrator::setAmplitude(uint8_t amplitude) {
+ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) {
+    *_aidl_return = {Effect::CLICK, Effect::DOUBLE_CLICK, Effect::HEAVY_CLICK,
+                     Effect::TICK, Effect::TEXTURE_TICK, Effect::THUD, Effect::POP,
+                     Effect::RINGTONE_1, Effect::RINGTONE_2, Effect::RINGTONE_3,
+                     Effect::RINGTONE_4, Effect::RINGTONE_5, Effect::RINGTONE_6,
+                     Effect::RINGTONE_7, Effect::RINGTONE_7, Effect::RINGTONE_8,
+                     Effect::RINGTONE_9, Effect::RINGTONE_10, Effect::RINGTONE_11,
+                     Effect::RINGTONE_12, Effect::RINGTONE_13, Effect::RINGTONE_14,
+                     Effect::RINGTONE_15};
+    return ndk::ScopedAStatus::ok();
+}
+
+ndk::ScopedAStatus Vibrator::setAmplitude(float amplitude) {
     uint32_t intensity;
 
     if (amplitude == 0) {
-        return Status::BAD_VALUE;
+        return ndk::ScopedAStatus::fromExceptionCode(EX_ILLEGAL_ARGUMENT);
     }
 
-    LOG(DEBUG) << "setting amplitude: " << (uint32_t)amplitude;
+    LOG(DEBUG) << "Setting amplitude: " << (uint32_t)amplitude;
 
-    intensity = std::lround((amplitude - 1) * 10000.0 / 254.0);
+    intensity = std::lround((amplitude - 1) * INTENSITY_MAX / 254.0);
     if (intensity > INTENSITY_MAX) {
         intensity = INTENSITY_MAX;
     }
-    LOG(DEBUG) << "setting intensity: " << intensity;
+    LOG(DEBUG) << "Setting intensity: " << intensity;
 
     return writeNode(VIBRATOR_TIMEOUT_PATH, intensity);
 }
 
-Return<void> Vibrator::perform(V1_0::Effect effect, EffectStrength strength, perform_cb _hidl_cb) {
-    return perform<decltype(effect)>(effect, strength, _hidl_cb);
+ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) {
+    if (mEnabled) {
+        LOG(WARNING) << "Setting external control while the vibrator is enabled is "
+                        "unsupported!";
+        return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     }
 
-// Methods from ::android::hardware::vibrator::V1_1::IVibrator follow.
+    LOG(INFO) << "ExternalControl: " << mExternalControl << " -> " << enabled;
+    mExternalControl = enabled;
+    return ndk::ScopedAStatus::ok();
+}
 
-Return<void> Vibrator::perform_1_1(V1_1::Effect_1_1 effect, EffectStrength strength,
-                                   perform_cb _hidl_cb) {
-    return perform<decltype(effect)>(effect, strength, _hidl_cb);
+ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-// Methods from ::android::hardware::vibrator::V1_2::IVibrator follow.
+ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-Return<void> Vibrator::perform_1_2(V1_2::Effect effect, EffectStrength strength,
-                                   perform_cb _hidl_cb) {
-    return perform<decltype(effect)>(effect, strength, _hidl_cb);
+ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive>* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-// Methods from ::android::hardware::vibrator::V1_3::IVibrator follow.
+ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-Return<bool> Vibrator::supportsExternalControl() {
-    return true;
+ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-Return<Status> Vibrator::setExternalControl(bool enabled) {
-    if (mEnabled) {
-        LOG(WARNING) << "Setting external control while the vibrator is enabled is "
-                        "unsupported!";
-        return Status::UNSUPPORTED_OPERATION;
+ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-    LOG(INFO) << "ExternalControl: " << mExternalControl << " -> " << enabled;
-    mExternalControl = enabled;
-    return Status::OK;
+ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-Return<void> Vibrator::perform_1_3(Effect effect, EffectStrength strength, perform_cb _hidl_cb) {
-    return perform<decltype(effect)>(effect, strength, _hidl_cb);
+ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-// Private methods follow.
+ndk::ScopedAStatus Vibrator::getResonantFrequency(float* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-Return<void> Vibrator::perform(Effect effect, EffectStrength strength, perform_cb _hidl_cb) {
-    Status status = Status::OK;
-    uint8_t amplitude;
-    uint32_t ms;
+ndk::ScopedAStatus Vibrator::getQFactor(float* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-    LOG(DEBUG) << "perform effect: " << toString(effect)
-               << ", strength: " << toString(strength);
+ndk::ScopedAStatus Vibrator::getFrequencyResolution(float* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-    amplitude = strengthToAmplitude(strength, &status);
-    if (status != Status::OK) {
-        _hidl_cb(status, 0);
-        return Void();
+ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
-    setAmplitude(amplitude);
 
-    ms = effectToMs(effect, &status);
-    if (status != Status::OK) {
-        _hidl_cb(status, 0);
-        return Void();
+ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float>* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
-    status = activate(ms);
 
-    _hidl_cb(status, ms);
+ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
+}
 
-    return Void();
+ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-template <typename T>
-Return<void> Vibrator::perform(T effect, EffectStrength strength, perform_cb _hidl_cb) {
-    auto validRange = hidl_enum_range<T>();
-    if (effect < *validRange.begin() || effect > *std::prev(validRange.end())) {
-        _hidl_cb(Status::UNSUPPORTED_OPERATION, 0);
-        return Void();
+ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_aidl_return*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
-    return perform(static_cast<Effect>(effect), strength, _hidl_cb);
+
+ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
+    return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
 }
 
-Status Vibrator::activate(uint32_t timeoutMs) {
+ndk::ScopedAStatus Vibrator::activate(uint32_t timeoutMs) {
     std::lock_guard<std::mutex> lock{mMutex};
-    if (!mIsTimedOutVibriator) {
-        return Status::UNSUPPORTED_OPERATION;
+    if (!mIsTimedOutVibrator) {
+        return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     }
 
     /* We mostly get values that are 20ms and lower, but
@@ -202,24 +240,24 @@ Status Vibrator::activate(uint32_t timeoutMs) {
     return writeNode(VIBRATOR_TIMEOUT_PATH, timeoutMs);
 }
 
-uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, Status* status) {
-    *status = Status::OK;
+uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status) {
+    *status = ndk::ScopedAStatus::ok();
 
     switch (strength) {
         case EffectStrength::LIGHT:
-            return 78;
+            return 64;
         case EffectStrength::MEDIUM:
             return 128;
         case EffectStrength::STRONG:
-            return 204;
+            return 255;
     }
 
-    *status = Status::UNSUPPORTED_OPERATION;
+    *status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     return 0;
 }
 
-uint32_t Vibrator::effectToMs(Effect effect, Status* status) {
-    *status = Status::OK;
+uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus* status) {
+    *status = ndk::ScopedAStatus::ok();
 
     switch (effect) {
         case Effect::CLICK:
@@ -251,12 +289,11 @@ uint32_t Vibrator::effectToMs(Effect effect, Status* status) {
             return 300;
     }
 
-    *status = Status::UNSUPPORTED_OPERATION;
+    *status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
     return 0;
 }
 
-}  // namespace implementation
-}  // namespace V1_3
 } // namespace vibrator
 } // namespace hardware
 } // namespace android
+} // namespace aidl

vibrator/Vibrator.h

@@ -1,94 +1,75 @@
 /*
- * Copyright (C) 2020 The LineageOS Project
+ * Copyright (C) 2022 The LineageOS 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.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-#ifndef ANDROID_HARDWARE_VIBRATOR_V1_3_VIBRATOR_H
-#define ANDROID_HARDWARE_VIBRATOR_V1_3_VIBRATOR_H
-
-#include <android/hardware/vibrator/1.3/IVibrator.h>
-#include <hidl/Status.h>
+#pragma once
 
-#include <fstream>
+#include <aidl/android/hardware/vibrator/BnVibrator.h>
 
 #define INTENSITY_MIN 40
 #define INTENSITY_MAX 10000
 #define INTENSITY_DEFAULT INTENSITY_MAX
 
-#define CLICK_TIMING_MS 20
-
 #define VIBRATOR_TIMEOUT_PATH "/sys/class/timed_output/vibrator/enable"
 #define VIBRATOR_INTENSITY_PATH "/sys/class/timed_output/vibrator/intensity"
 
+using ::aidl::android::hardware::vibrator::IVibratorCallback;
+using ::aidl::android::hardware::vibrator::Braking;
+using ::aidl::android::hardware::vibrator::Effect;
+using ::aidl::android::hardware::vibrator::EffectStrength;
+using ::aidl::android::hardware::vibrator::CompositeEffect;
+using ::aidl::android::hardware::vibrator::CompositePrimitive;
+using ::aidl::android::hardware::vibrator::PrimitivePwle;
+
+namespace aidl {
 namespace android {
 namespace hardware {
 namespace vibrator {
-namespace V1_3 {
-namespace implementation {
-
-using android::hardware::vibrator::V1_0::EffectStrength;
-using android::hardware::vibrator::V1_0::Status;
 
-class Vibrator : public IVibrator {
+class Vibrator : public BnVibrator {
 public:
     Vibrator();
-
-    // Methods from ::android::hardware::vibrator::V1_0::IVibrator follow.
-    Return<Status> on(uint32_t timeoutMs) override;
-    Return<Status> off() override;
-    Return<bool> supportsAmplitudeControl() override;
-    Return<Status> setAmplitude(uint8_t amplitude) override;
-    Return<void> perform(V1_0::Effect effect, EffectStrength strength,
-                         perform_cb _hidl_cb) override;
-
-    // Methods from ::android::hardware::vibrator::V1_1::IVibrator follow.
-    Return<void> perform_1_1(V1_1::Effect_1_1 effect, EffectStrength strength,
-                             perform_cb _hidl_cb) override;
-
-    // Methods from ::android::hardware::vibrator::V1_2::IVibrator follow.
-    Return<void> perform_1_2(V1_2::Effect effect, EffectStrength strength,
-                             perform_cb _hidl_cb) override;
-
-    // Methods from ::android::hardware::vibrator::V1_3::IVibrator follow.
-    Return<bool> supportsExternalControl() override;
-    Return<Status> setExternalControl(bool enabled) override;
-    Return<void> perform_1_3(Effect effect, EffectStrength strength, perform_cb _hidl_cb) override;
+    ndk::ScopedAStatus getCapabilities(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus off() override;
+    ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) override;
+    ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getSupportedEffects(std::vector<Effect>* _aidl_return) override;
+    ndk::ScopedAStatus setAmplitude(float amplitude) override;
+    ndk::ScopedAStatus setExternalControl(bool enabled) override;
+    ndk::ScopedAStatus getCompositionDelayMax(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getCompositionSizeMax(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getSupportedPrimitives(std::vector<CompositePrimitive>* _aidl_return) override;
+    ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t* _aidl_return) override;
+    ndk::ScopedAStatus compose(const std::vector<CompositeEffect>& composite, const std::shared_ptr<IVibratorCallback>& callback) override;
+    ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector<Effect>* _aidl_return) override;
+    ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override;
+    ndk::ScopedAStatus alwaysOnDisable(int32_t id) override;
+    ndk::ScopedAStatus getResonantFrequency(float* _aidl_return) override;
+    ndk::ScopedAStatus getQFactor(float* _aidl_return) override;
+    ndk::ScopedAStatus getFrequencyResolution(float* _aidl_return) override;
+    ndk::ScopedAStatus getFrequencyMinimum(float* _aidl_return) override;
+    ndk::ScopedAStatus getBandwidthAmplitudeMap(std::vector<float>* _aidl_return) override;
+    ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t* _aidl_return) override;
+    ndk::ScopedAStatus getSupportedBraking(std::vector<Braking>* _aidl_return) override;
+    ndk::ScopedAStatus composePwle(const std::vector<PrimitivePwle>& composite, const std::shared_ptr<IVibratorCallback>& callback) override;
 
 private:
-    Return<void> perform(Effect effect, EffectStrength strength, perform_cb _hidl_cb);
-    template <typename T>
-    Return<void> perform(T effect, EffectStrength strength, perform_cb _hidl_cb);
-    Status enable(bool enabled);
-    Status activate(uint32_t ms);
-
-    static uint32_t effectToMs(Effect effect, Status* status);
-    static uint8_t strengthToAmplitude(EffectStrength strength, Status* status);
+    ndk::ScopedAStatus activate(uint32_t ms);
+    static uint32_t effectToMs(Effect effect, ndk::ScopedAStatus* status);
+    static uint8_t strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status);
 
     bool mEnabled{false};
-    uint8_t mAmplitude{UINT8_MAX};
     bool mExternalControl{false};
     std::mutex mMutex;
-    timer_t mTimer{nullptr};
 
-    bool mIsTimedOutVibriator;
-    bool mhasTimedOutIntensity;
+    bool mIsTimedOutVibrator;
+    bool mHasTimedOutIntensity;
 };
 
-}  // namespace implementation
-}  // namespace V1_3
 } // namespace vibrator
 } // namespace hardware
 } // namespace android
-
-#endif  // ANDROID_HARDWARE_VIBRATOR_V1_3_VIBRATOR_H
+} // namespace aidl

vibrator/android.hardware.vibrator-service.sm7125.rc

@@ -0,0 +1,5 @@
+service vendor.vibrator-default /vendor/bin/hw/android.hardware.vibrator-service.sm7125
+    class hal
+    user system
+    group system
+    shutdown critical

vibrator/android.hardware.vibrator-service.sm7125.xml

@@ -0,0 +1,6 @@
+<manifest version="1.0" type="device">
+    <hal format="aidl">
+        <name>android.hardware.vibrator</name>
+        <fqname>IVibrator/default</fqname>
+    </hal>
+</manifest>

vibrator/android.hardware.vibrator@1.3-service.sm7125.rc

@@ -1,4 +0,0 @@
-service vendor.vibrator-1-3 /vendor/bin/hw/android.hardware.vibrator@1.3-service.sm7125
-    class hal
-    user system
-    group system

vibrator/android.hardware.vibrator@1.3-service.sm7125.xml

@@ -1,11 +0,0 @@
-<manifest version="1.0" type="device">
-    <hal format="hidl">
-        <name>android.hardware.vibrator</name>
-        <transport>hwbinder</transport>
-        <version>1.3</version>
-        <interface>
-            <name>IVibrator</name>
-            <instance>default</instance>
-        </interface>
-    </hal>
-</manifest>

vibrator/service.cpp

@@ -1,65 +1,25 @@
 /*
- * Copyright (C) 2020 The LineageOS Project
+ * Copyright (C) 2022 The LineageOS 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.
+ * SPDX-License-Identifier: Apache-2.0
  */
 
-#define LOG_TAG "vibrator@1.3-sm7125"
-
-#include <android-base/logging.h>
-#include <android/hardware/vibrator/1.3/IVibrator.h>
-#include <hidl/HidlSupport.h>
-#include <hidl/HidlTransportSupport.h>
-#include <utils/Errors.h>
-#include <utils/StrongPointer.h>
-
 #include "Vibrator.h"
 
-using android::hardware::configureRpcThreadpool;
-using android::hardware::joinRpcThreadpool;
-using android::hardware::vibrator::V1_3::IVibrator;
-using android::hardware::vibrator::V1_3::implementation::Vibrator;
+#include <android/binder_manager.h>
+#include <android/binder_process.h>
+#include <android-base/logging.h>
 
-using android::OK;
-using android::sp;
-using android::status_t;
+using ::aidl::android::hardware::vibrator::Vibrator;
 
 int main() {
-    status_t status;
-    sp<IVibrator> vibrator;
-
-    LOG(INFO) << "Vibrator HAL service is starting.";
-
-    vibrator = new Vibrator();
-    if (vibrator == nullptr) {
-        LOG(ERROR) << "Can not create an instance of Vibrator HAL IVibrator, "
-                      "exiting.";
-        goto shutdown;
-    }
-
-    configureRpcThreadpool(1, true);
-
-    status = vibrator->registerAsService();
-    if (status != OK) {
-        LOG(ERROR) << "Could not register service for Vibrator HAL";
-        goto shutdown;
-    }
+    ABinderProcess_setThreadPoolMaxThreadCount(0);
+    std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<Vibrator>();
 
-    LOG(INFO) << "Vibrator HAL service is Ready.";
-    joinRpcThreadpool();
+    const std::string instance = std::string() + Vibrator::descriptor + "/default";
+    binder_status_t status = AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
+    CHECK(status == STATUS_OK);
 
-shutdown:
-    // In normal operation, we don't expect the thread pool to shutdown
-    LOG(ERROR) << "Vibrator HAL failed to join thread pool.";
-    return 1;
+    ABinderProcess_joinThreadPool();
+    return EXIT_FAILURE; // should not reach
 }