tequilaOS/platform_hardware_interfaces
2
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity

Remove vibrator@1.4 from VNDK. am: 1784b9a3cf

Browse source 
am: 4b159da70a

Change-Id: I3a39dfe9ca210c8367298929693d15ae249c469e
This commit is contained in:
Steven Moreland 2019-11-12 14:05:01 -08:00 committed by android-build-merger
commit 693dc6646d
9 changed files with 1 additions and 495 deletions
Show stats Download patch file Download diff file Expand all files Collapse all files

2
compatibility_matrices/compatibility_matrix.current.xml
View file

@ -476,7 +476,7 @@
</hal>
<hal format="hidl" optional="true">
<name>android.hardware.vibrator</name>
<version>1.0-4</version>
<version>1.0-3</version>
<interface>
<name>IVibrator</name>
<instance>default</instance>

3
vibrator/1.4/Android.bp
View file

@ -3,9 +3,6 @@
hidl_interface {
name: "android.hardware.vibrator@1.4",
root: "android.hardware",
vndk: {
enabled: true,
},
srcs: [
"types.hal",
"IVibrator.hal",

34
vibrator/1.x/example/Android.bp
View file

@ -1,34 +0,0 @@
//
// Copyright (C) 2019 The Android Open Source Project
//
// Licensed under the Apache License, Version 2.0 (the "License");
// you may not use this file except in compliance with the License.
// You may obtain a copy of the License at
//
// http://www.apache.org/licenses/LICENSE-2.0
//
// Unless required by applicable law or agreed to in writing, software
// distributed under the License is distributed on an "AS IS" BASIS,
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
// See the License for the specific language governing permissions and
// limitations under the License.
cc_binary {
name: "android.hardware.vibrator@1.x-service.example",
vendor: true,
relative_install_path: "hw",
init_rc: ["android.hardware.vibrator@1.x-service.example.rc"],
vintf_fragments: ["android.hardware.vibrator@1.x-service.example.xml"],
srcs: ["service.cpp", "Vibrator.cpp"],
cflags: ["-Wall", "-Werror"],
shared_libs: [
"libhidlbase",
"liblog",
"libutils",
"android.hardware.vibrator@1.0",
"android.hardware.vibrator@1.1",
"android.hardware.vibrator@1.2",
"android.hardware.vibrator@1.3",
"android.hardware.vibrator@1.4",
],
}

2
vibrator/1.x/example/OWNERS
View file

@ -1,2 +0,0 @@
eliptus@google.com
michaelwr@google.com

303
vibrator/1.x/example/Vibrator.cpp
View file

@ -1,303 +0,0 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "VibratorService"
#include <log/log.h>
#include "Vibrator.h"
namespace android {
namespace hardware {
namespace vibrator {
namespace V1_4 {
namespace implementation {
static constexpr uint32_t MS_PER_S = 1000;
static constexpr uint32_t NS_PER_MS = 1000000;
Vibrator::Vibrator() {
sigevent se{};
se.sigev_notify = SIGEV_THREAD;
se.sigev_value.sival_ptr = this;
se.sigev_notify_function = timerCallback;
se.sigev_notify_attributes = nullptr;
if (timer_create(CLOCK_REALTIME, &se, &mTimer) < 0) {
ALOGE("Can not create timer!%s", strerror(errno));
}
}
// Methods from ::android::hardware::vibrator::V1_0::IVibrator follow.
Return<Status> Vibrator::on(uint32_t timeoutMs) {
return activate(timeoutMs);
}
Return<Status> Vibrator::off() {
return activate(0);
}
Return<bool> Vibrator::supportsAmplitudeControl() {
return true;
}
Return<Status> Vibrator::setAmplitude(uint8_t amplitude) {
if (!amplitude) {
return Status::BAD_VALUE;
}
ALOGI("Amplitude: %u -> %u\n", mAmplitude, amplitude);
mAmplitude = amplitude;
return Status::OK;
}
Return<void> Vibrator::perform(V1_0::Effect effect, EffectStrength strength, perform_cb _hidl_cb) {
return perform<decltype(effect)>(effect, strength, _hidl_cb);
}
// Methods from ::android::hardware::vibrator::V1_1::IVibrator follow.
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);
}
// Methods from ::android::hardware::vibrator::V1_2::IVibrator follow.
Return<void> Vibrator::perform_1_2(V1_2::Effect effect, EffectStrength strength,
perform_cb _hidl_cb) {
return perform<decltype(effect)>(effect, strength, _hidl_cb);
}
// Methods from ::android::hardware::vibrator::V1_3::IVibrator follow.
Return<bool> Vibrator::supportsExternalControl() {
return true;
}
Return<Status> Vibrator::setExternalControl(bool enabled) {
if (mEnabled) {
ALOGW("Setting external control while the vibrator is enabled is unsupported!");
return Status::UNSUPPORTED_OPERATION;
} else {
ALOGI("ExternalControl: %s -> %s\n", mExternalControl ? "true" : "false",
enabled ? "true" : "false");
mExternalControl = enabled;
return Status::OK;
}
}
Return<void> Vibrator::perform_1_3(V1_3::Effect effect, EffectStrength strength,
perform_cb _hidl_cb) {
return perform<decltype(effect)>(effect, strength, _hidl_cb);
}
// Methods from ::android::hardware::vibrator::V1_4::IVibrator follow.
Return<hidl_bitfield<Capabilities>> Vibrator::getCapabilities() {
return Capabilities::ON_COMPLETION_CALLBACK | Capabilities::PERFORM_COMPLETION_CALLBACK;
}
Return<Status> Vibrator::on_1_4(uint32_t timeoutMs, const sp<IVibratorCallback>& callback) {
mCallback = callback;
return on(timeoutMs);
}
Return<void> Vibrator::perform_1_4(V1_3::Effect effect, EffectStrength strength,
const sp<IVibratorCallback>& callback, perform_cb _hidl_cb) {
mCallback = callback;
return perform<decltype(effect)>(effect, strength, _hidl_cb);
}
// Private methods follow.
Return<void> Vibrator::perform(Effect effect, EffectStrength strength, perform_cb _hidl_cb) {
uint8_t amplitude;
uint32_t ms;
Status status = Status::OK;
ALOGI("Perform: Effect %s\n", effectToName(effect).c_str());
amplitude = strengthToAmplitude(strength, &status);
if (status != Status::OK) {
_hidl_cb(status, 0);
return Void();
}
setAmplitude(amplitude);
ms = effectToMs(effect, &status);
if (status != Status::OK) {
_hidl_cb(status, 0);
return Void();
}
status = activate(ms);
_hidl_cb(status, ms);
return Void();
}
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);
}
Status Vibrator::enable(bool enabled) {
if (mExternalControl) {
ALOGW("Enabling/disabling while the vibrator is externally controlled is unsupported!");
return Status::UNSUPPORTED_OPERATION;
} else {
ALOGI("Enabled: %s -> %s\n", mEnabled ? "true" : "false", enabled ? "true" : "false");
if (mEnabled && !enabled) {
if (auto callback = mCallback) {
mCallback = nullptr;
if (auto ret = callback->onComplete(); !ret.isOk()) {
ALOGE("Failed completion callback: %s", ret.description().c_str());
}
}
}
mEnabled = enabled;
return Status::OK;
}
}
Status Vibrator::activate(uint32_t ms) {
std::lock_guard<std::mutex> lock{mMutex};
Status status = Status::OK;
if (ms > 0) {
status = enable(true);
if (status != Status::OK) {
return status;
}
}
itimerspec ts{};
ts.it_value.tv_sec = ms / MS_PER_S;
ts.it_value.tv_nsec = ms % MS_PER_S * NS_PER_MS;
if (timer_settime(mTimer, 0, &ts, nullptr) < 0) {
ALOGE("Can not set timer!");
status = Status::UNKNOWN_ERROR;
}
if ((status != Status::OK) || !ms) {
Status _status;
_status = enable(false);
if (status == Status::OK) {
status = _status;
}
}
return status;
}
void Vibrator::timeout() {
std::lock_guard<std::mutex> lock{mMutex};
itimerspec ts{};
if (timer_gettime(mTimer, &ts) < 0) {
ALOGE("Can not read timer!");
}
if (ts.it_value.tv_sec == 0 && ts.it_value.tv_nsec == 0) {
enable(false);
}
}
void Vibrator::timerCallback(union sigval sigval) {
static_cast<Vibrator*>(sigval.sival_ptr)->timeout();
}
const std::string Vibrator::effectToName(Effect effect) {
return toString(effect);
}
uint32_t Vibrator::effectToMs(Effect effect, Status* status) {
switch (effect) {
case Effect::CLICK:
return 10;
case Effect::DOUBLE_CLICK:
return 15;
case Effect::TICK:
case Effect::TEXTURE_TICK:
return 5;
case Effect::THUD:
return 5;
case Effect::POP:
return 5;
case Effect::HEAVY_CLICK:
return 10;
case Effect::RINGTONE_1:
return 30000;
case Effect::RINGTONE_2:
return 30000;
case Effect::RINGTONE_3:
return 30000;
case Effect::RINGTONE_4:
return 30000;
case Effect::RINGTONE_5:
return 30000;
case Effect::RINGTONE_6:
return 30000;
case Effect::RINGTONE_7:
return 30000;
case Effect::RINGTONE_8:
return 30000;
case Effect::RINGTONE_9:
return 30000;
case Effect::RINGTONE_10:
return 30000;
case Effect::RINGTONE_11:
return 30000;
case Effect::RINGTONE_12:
return 30000;
case Effect::RINGTONE_13:
return 30000;
case Effect::RINGTONE_14:
return 30000;
case Effect::RINGTONE_15:
return 30000;
}
*status = Status::UNSUPPORTED_OPERATION;
return 0;
}
uint8_t Vibrator::strengthToAmplitude(EffectStrength strength, Status* status) {
switch (strength) {
case EffectStrength::LIGHT:
return 128;
case EffectStrength::MEDIUM:
return 192;
case EffectStrength::STRONG:
return 255;
}
*status = Status::UNSUPPORTED_OPERATION;
return 0;
}
} // namespace implementation
} // namespace V1_4
} // namespace vibrator
} // namespace hardware
} // namespace android

91
vibrator/1.x/example/Vibrator.h
View file

@ -1,91 +0,0 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#ifndef ANDROID_HARDWARE_VIBRATOR_V1_x_VIBRATOR_H
#define ANDROID_HARDWARE_VIBRATOR_V1_x_VIBRATOR_H
#include <android/hardware/vibrator/1.4/IVibrator.h>
#include <hidl/Status.h>
namespace android {
namespace hardware {
namespace vibrator {
namespace V1_4 {
namespace implementation {
using android::hardware::vibrator::V1_0::EffectStrength;
using android::hardware::vibrator::V1_0::Status;
using android::hardware::vibrator::V1_3::Effect;
class Vibrator : public IVibrator {
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(V1_3::Effect effect, EffectStrength strength,
perform_cb _hidl_cb) override;
// Methods from ::android::hardware::vibrator::V1_4::IVibrator follow.
Return<hidl_bitfield<Capabilities>> getCapabilities() override;
Return<Status> on_1_4(uint32_t timeoutMs, const sp<IVibratorCallback>& callback) override;
Return<void> perform_1_4(V1_3::Effect effect, EffectStrength strength,
const sp<IVibratorCallback>& callback, 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);
void timeout();
static void timerCallback(union sigval sigval);
static const std::string effectToName(Effect effect);
static uint32_t effectToMs(Effect effect, Status* status);
static uint8_t strengthToAmplitude(EffectStrength strength, Status* status);
private:
bool mEnabled{false};
uint8_t mAmplitude{UINT8_MAX};
bool mExternalControl{false};
std::mutex mMutex;
timer_t mTimer{nullptr};
sp<IVibratorCallback> mCallback{nullptr};
};
} // namespace implementation
} // namespace V1_4
} // namespace vibrator
} // namespace hardware
} // namespace android
#endif // ANDROID_HARDWARE_VIBRATOR_V1_x_VIBRATOR_H

4
vibrator/1.x/example/android.hardware.vibrator@1.x-service.example.rc
View file

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

11
vibrator/1.x/example/android.hardware.vibrator@1.x-service.example.xml
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.4</version>
<interface>
<name>IVibrator</name>
<instance>default</instance>
</interface>
</hal>
</manifest>

46
vibrator/1.x/example/service.cpp
View file

@ -1,46 +0,0 @@
/*
* Copyright (C) 2019 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*/
#define LOG_TAG "android.hardware.vibrator@1.x-service.example"
#include <android/hardware/vibrator/1.4/IVibrator.h>
#include <hidl/HidlTransportSupport.h>
#include "Vibrator.h"
using android::hardware::configureRpcThreadpool;
using android::hardware::joinRpcThreadpool;
using android::hardware::vibrator::V1_4::IVibrator;
using android::hardware::vibrator::V1_4::implementation::Vibrator;
using namespace android;
status_t registerVibratorService() {
sp<IVibrator> vibrator = new Vibrator();
return vibrator->registerAsService();
}
int main() {
configureRpcThreadpool(1, true);
status_t status = registerVibratorService();
if (status != OK) {
return status;
}
joinRpcThreadpool();
return 1;
}