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
PRODUCT_PACKAGES += \
android.hardware.vibrator@1.3-service.sm7125
android.hardware.vibrator-service.sm7125
# Tether
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.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

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");
// 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,
}

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");
* 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

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");
* 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

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");
* 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
}

Write Preview
Loading…
Cancel
Save