1 /*
2 * Copyright (C) 2009 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 * http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17 #define LOG_TAG "VibratorService"
18
19 #include <android/hardware/vibrator/1.0/IVibrator.h>
20 #include <android/hardware/vibrator/1.0/types.h>
21 #include <android/hardware/vibrator/1.0/IVibrator.h>
22 #include <android/hardware/vibrator/1.1/types.h>
23 #include <android/hardware/vibrator/1.2/IVibrator.h>
24 #include <android/hardware/vibrator/1.2/types.h>
25
26 #include "jni.h"
27 #include <nativehelper/JNIHelp.h>
28 #include "android_runtime/AndroidRuntime.h"
29
30 #include <utils/misc.h>
31 #include <utils/Log.h>
32 #include <hardware/vibrator.h>
33
34 #include <inttypes.h>
35 #include <stdio.h>
36
37 using android::hardware::Return;
38 using android::hardware::vibrator::V1_0::EffectStrength;
39 using android::hardware::vibrator::V1_0::Status;
40 using android::hardware::vibrator::V1_1::Effect_1_1;
41
42 namespace V1_0 = android::hardware::vibrator::V1_0;
43 namespace V1_1 = android::hardware::vibrator::V1_1;
44 namespace V1_2 = android::hardware::vibrator::V1_2;
45
46 namespace android {
47
48 static constexpr int NUM_TRIES = 2;
49
50 // Creates a Return<R> with STATUS::EX_NULL_POINTER.
51 template<class R>
NullptrStatus()52 inline Return<R> NullptrStatus() {
53 using ::android::hardware::Status;
54 return Return<R>{Status::fromExceptionCode(Status::EX_NULL_POINTER)};
55 }
56
57 // Helper used to transparently deal with the vibrator HAL becoming unavailable.
58 template<class R, class I, class... Args0, class... Args1>
halCall(Return<R> (I::* fn)(Args0...),Args1 &&...args1)59 Return<R> halCall(Return<R> (I::* fn)(Args0...), Args1&&... args1) {
60 // Assume that if getService returns a nullptr, HAL is not available on the
61 // device.
62 static sp<I> sHal = I::getService();
63 static bool sAvailable = sHal != nullptr;
64
65 if (!sAvailable) {
66 return NullptrStatus<R>();
67 }
68
69 // Return<R> doesn't have a default constructor, so make a Return<R> with
70 // STATUS::EX_NONE.
71 using ::android::hardware::Status;
72 Return<R> ret{Status::fromExceptionCode(Status::EX_NONE)};
73
74 // Note that ret is guaranteed to be changed after this loop.
75 for (int i = 0; i < NUM_TRIES; ++i) {
76 ret = (sHal == nullptr) ? NullptrStatus<R>()
77 : (*sHal.*fn)(std::forward<Args1>(args1)...);
78
79 if (ret.isOk()) {
80 break;
81 }
82
83 ALOGE("Failed to issue command to vibrator HAL. Retrying.");
84 // Restoring connection to the HAL.
85 sHal = I::tryGetService();
86 }
87 return ret;
88 }
89
90 template<class R>
isValidEffect(jlong effect)91 bool isValidEffect(jlong effect) {
92 if (effect < 0) {
93 return false;
94 }
95 R val = static_cast<R>(effect);
96 auto iter = hardware::hidl_enum_iterator<R>();
97 return val >= *iter.begin() && val < *std::prev(iter.end());
98 }
99
vibratorInit(JNIEnv,jobject)100 static void vibratorInit(JNIEnv /* env */, jobject /* clazz */)
101 {
102 halCall(&V1_0::IVibrator::ping).isOk();
103 }
104
vibratorExists(JNIEnv *,jobject)105 static jboolean vibratorExists(JNIEnv* /* env */, jobject /* clazz */)
106 {
107 return halCall(&V1_0::IVibrator::ping).isOk() ? JNI_TRUE : JNI_FALSE;
108 }
109
vibratorOn(JNIEnv *,jobject,jlong timeout_ms)110 static void vibratorOn(JNIEnv* /* env */, jobject /* clazz */, jlong timeout_ms)
111 {
112 Status retStatus = halCall(&V1_0::IVibrator::on, timeout_ms).withDefault(Status::UNKNOWN_ERROR);
113 if (retStatus != Status::OK) {
114 ALOGE("vibratorOn command failed (%" PRIu32 ").", static_cast<uint32_t>(retStatus));
115 }
116 }
117
vibratorOff(JNIEnv *,jobject)118 static void vibratorOff(JNIEnv* /* env */, jobject /* clazz */)
119 {
120 Status retStatus = halCall(&V1_0::IVibrator::off).withDefault(Status::UNKNOWN_ERROR);
121 if (retStatus != Status::OK) {
122 ALOGE("vibratorOff command failed (%" PRIu32 ").", static_cast<uint32_t>(retStatus));
123 }
124 }
125
vibratorSupportsAmplitudeControl(JNIEnv *,jobject)126 static jlong vibratorSupportsAmplitudeControl(JNIEnv*, jobject) {
127 return halCall(&V1_0::IVibrator::supportsAmplitudeControl).withDefault(false);
128 }
129
vibratorSetAmplitude(JNIEnv *,jobject,jint amplitude)130 static void vibratorSetAmplitude(JNIEnv*, jobject, jint amplitude) {
131 Status status = halCall(&V1_0::IVibrator::setAmplitude, static_cast<uint32_t>(amplitude))
132 .withDefault(Status::UNKNOWN_ERROR);
133 if (status != Status::OK) {
134 ALOGE("Failed to set vibrator amplitude (%" PRIu32 ").",
135 static_cast<uint32_t>(status));
136 }
137 }
138
vibratorPerformEffect(JNIEnv *,jobject,jlong effect,jint strength)139 static jlong vibratorPerformEffect(JNIEnv*, jobject, jlong effect, jint strength) {
140 Status status;
141 uint32_t lengthMs;
142 auto callback = [&status, &lengthMs](Status retStatus, uint32_t retLengthMs) {
143 status = retStatus;
144 lengthMs = retLengthMs;
145 };
146 EffectStrength effectStrength(static_cast<EffectStrength>(strength));
147
148 Return<void> ret;
149 if (isValidEffect<V1_0::Effect>(effect)) {
150 ret = halCall(&V1_0::IVibrator::perform, static_cast<V1_0::Effect>(effect),
151 effectStrength, callback);
152 } else if (isValidEffect<Effect_1_1>(effect)) {
153 ret = halCall(&V1_1::IVibrator::perform_1_1, static_cast<Effect_1_1>(effect),
154 effectStrength, callback);
155 } else if (isValidEffect<V1_2::Effect>(effect)) {
156 ret = halCall(&V1_2::IVibrator::perform_1_2, static_cast<V1_2::Effect>(effect),
157 effectStrength, callback);
158 } else {
159 ALOGW("Unable to perform haptic effect, invalid effect ID (%" PRId32 ")",
160 static_cast<int32_t>(effect));
161 return -1;
162 }
163
164 if (!ret.isOk()) {
165 ALOGW("Failed to perform effect (%" PRId32 ")", static_cast<int32_t>(effect));
166 return -1;
167 }
168
169 if (status == Status::OK) {
170 return lengthMs;
171 } else if (status != Status::UNSUPPORTED_OPERATION) {
172 // Don't warn on UNSUPPORTED_OPERATION, that's a normal event and just means the motor
173 // doesn't have a pre-defined waveform to perform for it, so we should just give the
174 // opportunity to fall back to the framework waveforms.
175 ALOGE("Failed to perform haptic effect: effect=%" PRId64 ", strength=%" PRId32
176 ", error=%" PRIu32 ").", static_cast<int64_t>(effect),
177 static_cast<int32_t>(strength), static_cast<uint32_t>(status));
178 }
179
180 return -1;
181 }
182
183 static const JNINativeMethod method_table[] = {
184 { "vibratorExists", "()Z", (void*)vibratorExists },
185 { "vibratorInit", "()V", (void*)vibratorInit },
186 { "vibratorOn", "(J)V", (void*)vibratorOn },
187 { "vibratorOff", "()V", (void*)vibratorOff },
188 { "vibratorSupportsAmplitudeControl", "()Z", (void*)vibratorSupportsAmplitudeControl},
189 { "vibratorSetAmplitude", "(I)V", (void*)vibratorSetAmplitude},
190 { "vibratorPerformEffect", "(JJ)J", (void*)vibratorPerformEffect}
191 };
192
register_android_server_VibratorService(JNIEnv * env)193 int register_android_server_VibratorService(JNIEnv *env)
194 {
195 return jniRegisterNativeMethods(env, "com/android/server/VibratorService",
196 method_table, NELEM(method_table));
197 }
198
199 };
200