sm7125: vibrator: Update to hardware/samsung AIDL implementation

Change-Id: I6e912e74bebf10a6f15acb347135a763bf473383
fourteen-wip
Simon1511 3 years ago
parent 6e61ea855e
commit 6ea5a20871
  1. 2
      common.mk
  2. 2
      sepolicy/vendor/file_contexts
  3. 37
      vibrator/Android.bp
  4. 263
      vibrator/Vibrator.cpp
  5. 119
      vibrator/Vibrator.h
  6. 5
      vibrator/android.hardware.vibrator-service.sm7125.rc
  7. 6
      vibrator/android.hardware.vibrator-service.sm7125.xml
  8. 4
      vibrator/android.hardware.vibrator@1.3-service.sm7125.rc
  9. 11
      vibrator/android.hardware.vibrator@1.3-service.sm7125.xml
  10. 66
      vibrator/service.cpp

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

@ -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

@ -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,
}

@ -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*/;
ok = nodeExists(VIBRATOR_INTENSITY_PATH);
if (ok) {
mhasTimedOutIntensity = true;
if (mHasTimedOutIntensity) {
*_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
IVibrator::CAP_EXTERNAL_AMPLITUDE_CONTROL;
}
return ndk::ScopedAStatus::ok();
}
// Methods from ::android::hardware::vibrator::V1_0::IVibrator follow.
ndk::ScopedAStatus Vibrator::off() {
return activate(0);
}
Return<Status> Vibrator::on(uint32_t timeoutMs) {
return activate(timeoutMs);
ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) {
ndk::ScopedAStatus status = 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;
}
Return<Status> Vibrator::off() {
return activate(0);
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<bool> Vibrator::supportsAmplitudeControl() {
return true;
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();
}
Return<Status> Vibrator::setAmplitude(uint8_t amplitude) {
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);
}
LOG(INFO) << "ExternalControl: " << mExternalControl << " -> " << enabled;
mExternalControl = enabled;
return ndk::ScopedAStatus::ok();
}
// Methods from ::android::hardware::vibrator::V1_1::IVibrator follow.
ndk::ScopedAStatus Vibrator::getCompositionDelayMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
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::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
// Methods from ::android::hardware::vibrator::V1_2::IVibrator follow.
ndk::ScopedAStatus Vibrator::getSupportedPrimitives(std::vector<CompositePrimitive>* /*_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::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
// Methods from ::android::hardware::vibrator::V1_3::IVibrator follow.
ndk::ScopedAStatus Vibrator::compose(const std::vector<CompositeEffect>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
Return<bool> Vibrator::supportsExternalControl() {
return true;
ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*_aidl_return*/) {
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::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
LOG(INFO) << "ExternalControl: " << mExternalControl << " -> " << enabled;
mExternalControl = enabled;
return Status::OK;
ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) {
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::getResonantFrequency(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
// Private methods follow.
ndk::ScopedAStatus Vibrator::getQFactor(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::getFrequencyResolution(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
LOG(DEBUG) << "perform effect: " << toString(effect)
<< ", strength: " << toString(strength);
ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
amplitude = strengthToAmplitude(strength, &status);
if (status != Status::OK) {
_hidl_cb(status, 0);
return Void();
}
setAmplitude(amplitude);
ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float>* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
ms = effectToMs(effect, &status);
if (status != Status::OK) {
_hidl_cb(status, 0);
return Void();
}
status = activate(ms);
ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
_hidl_cb(status, ms);
ndk::ScopedAStatus Vibrator::getPwleCompositionSizeMax(int32_t* /*_aidl_return*/) {
return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
return Void();
ndk::ScopedAStatus Vibrator::getSupportedBraking(std::vector<Braking>* /*_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();
}
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 vibrator
} // namespace hardware
} // namespace android
} // namespace aidl

@ -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
#pragma once
#include <android/hardware/vibrator/1.3/IVibrator.h>
#include <hidl/Status.h>
#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 {
public:
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;
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 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:
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 vibrator
} // namespace hardware
} // namespace android
} // namespace aidl

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

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

@ -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

@ -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>

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

Loading…
Cancel
Save