jenna
/
device_samsung_sm7125-common
1
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity

sm7125: vibrator: Update to hardware/samsung AIDL implementation

Browse Source 
Change-Id: I6e912e74bebf10a6f15acb347135a763bf473383
fourteen-wip
Simon1511 3 years ago
parent 6e61ea855e
commit 6ea5a20871
10 changed files with 238 additions and 277 deletions
Show all changes Ignore whitespace when comparing lines Ignore changes in amount of whitespace Ignore changes in whitespace at EOL
Show Stats Download Patch File Download Diff File
  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

2
common.mk
Unescape View File

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

2
sepolicy/vendor/file_contexts vendored
Unescape View File

@ -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\.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.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/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\.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 /(vendor|system/vendor)/bin/hw/android\.hardware\.power-service\.samsung-libperfmgr u:object_r:hal_power_default_exec:s0

37
vibrator/Android.bp
Unescape View File

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

263
vibrator/Vibrator.cpp
Unescape View File

@ -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"); * SPDX-License-Identifier: Apache-2.0
* 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 "vibrator@1.3-sm7125"
#include "Vibrator.h" #include "Vibrator.h"
#include <android-base/logging.h> #include <android-base/logging.h>
#include <android-base/stringprintf.h>
#include <hardware/hardware.h>
#include <hardware/vibrator.h>
#include <cinttypes>
#include <cmath> #include <cmath>
#include <fstream> #include <fstream>
#include <iostream> #include <iostream>
#include <thread>
namespace aidl {
namespace android { namespace android {
namespace hardware { namespace hardware {
namespace vibrator { namespace vibrator {
namespace V1_3 {
namespace implementation {
/* /*
* Write value to path and close file. * Write value to path and close file.
*/ */
template <typename T> 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); std::ofstream node(path);
if (!node) { if (!node) {
LOG(ERROR) << "Failed to open: " << path; LOG(ERROR) << "Failed to open: " << path;
return Status::UNKNOWN_ERROR; return ndk::ScopedAStatus::fromStatus(STATUS_UNKNOWN_ERROR);
} }
LOG(DEBUG) << "writeNode node: " << path << " value: " << value; 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; node << value << std::endl;
if (!node) { if (!node) {
LOG(ERROR) << "Failed to write: " << value; 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) { static bool nodeExists(const std::string& path) {
@ -62,134 +46,188 @@ static bool nodeExists(const std::string& path) {
} }
Vibrator::Vibrator() { Vibrator::Vibrator() {
bool ok; mIsTimedOutVibrator = nodeExists(VIBRATOR_TIMEOUT_PATH);
mHasTimedOutIntensity = nodeExists(VIBRATOR_INTENSITY_PATH);
}
ok = nodeExists(VIBRATOR_TIMEOUT_PATH); ndk::ScopedAStatus Vibrator::getCapabilities(int32_t* _aidl_return) {
if (ok) { *_aidl_return = IVibrator::CAP_ON_CALLBACK | IVibrator::CAP_PERFORM_CALLBACK |
mIsTimedOutVibriator = true; IVibrator::CAP_EXTERNAL_CONTROL /*| IVibrator::CAP_COMPOSE_EFFECTS |
} IVibrator::CAP_ALWAYS_ON_CONTROL*/;
ok = nodeExists(VIBRATOR_INTENSITY_PATH); if (mHasTimedOutIntensity) {
if (ok) { *_aidl_return = *_aidl_return | IVibrator::CAP_AMPLITUDE_CONTROL |
mhasTimedOutIntensity = true; 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) { ndk::ScopedAStatus Vibrator::on(int32_t timeoutMs, const std::shared_ptr<IVibratorCallback>& callback) {
return activate(timeoutMs); 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() { ndk::ScopedAStatus Vibrator::perform(Effect effect, EffectStrength strength, const std::shared_ptr<IVibratorCallback>& callback, int32_t* _aidl_return) {
return activate(0); 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() { ndk::ScopedAStatus Vibrator::getSupportedEffects(std::vector<Effect>* _aidl_return) {
return true; *_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; uint32_t intensity;
if (amplitude == 0) { 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) { if (intensity > INTENSITY_MAX) {
intensity = INTENSITY_MAX; intensity = INTENSITY_MAX;
} }
LOG(DEBUG) << "setting intensity: " << intensity; LOG(DEBUG) << "Setting intensity: " << intensity;
return writeNode(VIBRATOR_TIMEOUT_PATH, intensity); return writeNode(VIBRATOR_TIMEOUT_PATH, intensity);
} }
Return<void> Vibrator::perform(V1_0::Effect effect, EffectStrength strength, perform_cb _hidl_cb) { ndk::ScopedAStatus Vibrator::setExternalControl(bool enabled) {
return perform<decltype(effect)>(effect, strength, _hidl_cb); 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, ndk::ScopedAStatus Vibrator::getCompositionSizeMax(int32_t* /*_aidl_return*/) {
perform_cb _hidl_cb) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
return perform<decltype(effect)>(effect, strength, _hidl_cb);
} }
// 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, ndk::ScopedAStatus Vibrator::getPrimitiveDuration(CompositePrimitive /*primitive*/, int32_t* /*_aidl_return*/) {
perform_cb _hidl_cb) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
return perform<decltype(effect)>(effect, strength, _hidl_cb);
} }
// 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() { ndk::ScopedAStatus Vibrator::getSupportedAlwaysOnEffects(std::vector<Effect>* /*_aidl_return*/) {
return true; return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
Return<Status> Vibrator::setExternalControl(bool enabled) { ndk::ScopedAStatus Vibrator::alwaysOnEnable(int32_t /*id*/, Effect /*effect*/, EffectStrength /*strength*/) {
if (mEnabled) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
LOG(WARNING) << "Setting external control while the vibrator is enabled is " }
"unsupported!";
return Status::UNSUPPORTED_OPERATION;
}
LOG(INFO) << "ExternalControl: " << mExternalControl << " -> " << enabled; ndk::ScopedAStatus Vibrator::alwaysOnDisable(int32_t /*id*/) {
mExternalControl = enabled; return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
return Status::OK;
} }
Return<void> Vibrator::perform_1_3(Effect effect, EffectStrength strength, perform_cb _hidl_cb) { ndk::ScopedAStatus Vibrator::getResonantFrequency(float* /*_aidl_return*/) {
return perform<decltype(effect)>(effect, strength, _hidl_cb); 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) { ndk::ScopedAStatus Vibrator::getFrequencyResolution(float* /*_aidl_return*/) {
Status status = Status::OK; return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
uint8_t amplitude; }
uint32_t ms;
LOG(DEBUG) << "perform effect: " << toString(effect) ndk::ScopedAStatus Vibrator::getFrequencyMinimum(float* /*_aidl_return*/) {
<< ", strength: " << toString(strength); return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
}
amplitude = strengthToAmplitude(strength, &status); ndk::ScopedAStatus Vibrator::getBandwidthAmplitudeMap(std::vector<float>* /*_aidl_return*/) {
if (status != Status::OK) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
_hidl_cb(status, 0); }
return Void();
}
setAmplitude(amplitude);
ms = effectToMs(effect, &status); ndk::ScopedAStatus Vibrator::getPwlePrimitiveDurationMax(int32_t* /*_aidl_return*/) {
if (status != Status::OK) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
_hidl_cb(status, 0); }
return Void();
}
status = activate(ms);
_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> ndk::ScopedAStatus Vibrator::composePwle(const std::vector<PrimitivePwle>& /*composite*/, const std::shared_ptr<IVibratorCallback>& /*callback*/) {
Return<void> Vibrator::perform(T effect, EffectStrength strength, perform_cb _hidl_cb) { return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
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);
} }
Status Vibrator::activate(uint32_t timeoutMs) { ndk::ScopedAStatus Vibrator::activate(uint32_t timeoutMs) {
std::lock_guard<std::mutex> lock{mMutex}; std::lock_guard<std::mutex> lock{mMutex};
if (!mIsTimedOutVibriator) { if (!mIsTimedOutVibrator) {
return Status::UNSUPPORTED_OPERATION; return ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
} }
/* We mostly get values that are 20ms and lower, but /* 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); return writeNode(VIBRATOR_TIMEOUT_PATH, timeoutMs);
} }
uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, Status* status) { uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, ndk::ScopedAStatus* status) {
*status = Status::OK; *status = ndk::ScopedAStatus::ok();
switch (strength) { switch (strength) {
case EffectStrength::LIGHT: case EffectStrength::LIGHT:
return 78; return 64;
case EffectStrength::MEDIUM: case EffectStrength::MEDIUM:
return 128; return 128;
case EffectStrength::STRONG: case EffectStrength::STRONG:
return 204; return 255;
} }
*status = Status::UNSUPPORTED_OPERATION; *status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
return 0; return 0;
} }
uint32_t Vibrator::effectToMs(Effect effect, Status* status) { uint32_t Vibrator::effectToMs(Effect effect, ndk::ScopedAStatus* status) {
*status = Status::OK; *status = ndk::ScopedAStatus::ok();
switch (effect) { switch (effect) {
case Effect::CLICK: case Effect::CLICK:
@ -251,12 +289,11 @@ uint32_t Vibrator::effectToMs(Effect effect, Status* status) {
return 300; return 300;
} }
*status = Status::UNSUPPORTED_OPERATION; *status = ndk::ScopedAStatus::fromExceptionCode(EX_UNSUPPORTED_OPERATION);
return 0; return 0;
} }
} // namespace implementation } // namespace vibrator
} // namespace V1_3 } // namespace hardware
} // namespace vibrator } // namespace android
} // namespace hardware } // namespace aidl
} // namespace android

119
vibrator/Vibrator.h
Unescape View File

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

5
vibrator/android.hardware.vibrator-service.sm7125.rc
Unescape View File

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

6
vibrator/android.hardware.vibrator-service.sm7125.xml
Unescape View File

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

4
vibrator/android.hardware.vibrator@1.3-service.sm7125.rc
Unescape View File

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

11
vibrator/android.hardware.vibrator@1.3-service.sm7125.xml
Unescape View File

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

66
vibrator/service.cpp
Unescape View File

@ -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"); * SPDX-License-Identifier: Apache-2.0
* 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 "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" #include "Vibrator.h"
using android::hardware::configureRpcThreadpool; #include <android/binder_manager.h>
using android::hardware::joinRpcThreadpool; #include <android/binder_process.h>
using android::hardware::vibrator::V1_3::IVibrator; #include <android-base/logging.h>
using android::hardware::vibrator::V1_3::implementation::Vibrator;
using android::OK; using ::aidl::android::hardware::vibrator::Vibrator;
using android::sp;
using android::status_t;
int main() { int main() {
status_t status; ABinderProcess_setThreadPoolMaxThreadCount(0);
sp<IVibrator> vibrator; std::shared_ptr<Vibrator> vibrator = ndk::SharedRefBase::make<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;
}
LOG(INFO) << "Vibrator HAL service is Ready."; const std::string instance = std::string() + Vibrator::descriptor + "/default";
joinRpcThreadpool(); binder_status_t status = AServiceManager_addService(vibrator->asBinder().get(), instance.c_str());
CHECK(status == STATUS_OK);
shutdown: ABinderProcess_joinThreadPool();
// In normal operation, we don't expect the thread pool to shutdown return EXIT_FAILURE; // should not reach
LOG(ERROR) << "Vibrator HAL failed to join thread pool.";
return 1;
} }

Write Preview
Loading…
Cancel
Save