Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2019 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 | #include <aidl/Gtest.h> |
| 17 | #include <aidl/Vintf.h> |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 18 | #include <aidl/android/hardware/vibrator/BnVibratorCallback.h> |
| 19 | #include <aidl/android/hardware/vibrator/IVibrator.h> |
| 20 | #include <aidl/android/hardware/vibrator/IVibratorManager.h> |
| 21 | |
| 22 | #include <android/binder_manager.h> |
| 23 | #include <android/binder_process.h> |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 24 | #include <android/persistable_bundle_aidl.h> |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 25 | |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 26 | #include <cmath> |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 27 | #include <cstdlib> |
| 28 | #include <ctime> |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 29 | #include <future> |
| 30 | |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 31 | #include "persistable_bundle_utils.h" |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 32 | #include "test_utils.h" |
| 33 | |
| 34 | using aidl::android::hardware::vibrator::ActivePwle; |
| 35 | using aidl::android::hardware::vibrator::BnVibratorCallback; |
| 36 | using aidl::android::hardware::vibrator::Braking; |
| 37 | using aidl::android::hardware::vibrator::BrakingPwle; |
| 38 | using aidl::android::hardware::vibrator::CompositeEffect; |
| 39 | using aidl::android::hardware::vibrator::CompositePrimitive; |
| 40 | using aidl::android::hardware::vibrator::Effect; |
| 41 | using aidl::android::hardware::vibrator::EffectStrength; |
| 42 | using aidl::android::hardware::vibrator::IVibrator; |
| 43 | using aidl::android::hardware::vibrator::IVibratorManager; |
| 44 | using aidl::android::hardware::vibrator::PrimitivePwle; |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 45 | using aidl::android::hardware::vibrator::VendorEffect; |
| 46 | using aidl::android::os::PersistableBundle; |
Harpreet \"Eli\" Sangha | b075a6a | 2020-04-10 15:11:58 +0900 | [diff] [blame] | 47 | using std::chrono::high_resolution_clock; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 48 | |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 49 | using namespace ::std::chrono_literals; |
| 50 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 51 | const std::vector<Effect> kEffects{ndk::enum_range<Effect>().begin(), |
| 52 | ndk::enum_range<Effect>().end()}; |
| 53 | const std::vector<EffectStrength> kEffectStrengths{ndk::enum_range<EffectStrength>().begin(), |
| 54 | ndk::enum_range<EffectStrength>().end()}; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 55 | |
| 56 | const std::vector<Effect> kInvalidEffects = { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 57 | static_cast<Effect>(static_cast<int32_t>(kEffects.front()) - 1), |
| 58 | static_cast<Effect>(static_cast<int32_t>(kEffects.back()) + 1), |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 59 | }; |
| 60 | |
| 61 | const std::vector<EffectStrength> kInvalidEffectStrengths = { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 62 | static_cast<EffectStrength>(static_cast<int8_t>(kEffectStrengths.front()) - 1), |
| 63 | static_cast<EffectStrength>(static_cast<int8_t>(kEffectStrengths.back()) + 1), |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 64 | }; |
| 65 | |
Steven Moreland | 1c26978 | 2020-01-09 11:16:05 -0800 | [diff] [blame] | 66 | const std::vector<CompositePrimitive> kCompositePrimitives{ |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 67 | ndk::enum_range<CompositePrimitive>().begin(), ndk::enum_range<CompositePrimitive>().end()}; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 68 | |
Lais Andrade | 7e64377 | 2021-07-09 14:59:44 +0100 | [diff] [blame] | 69 | const std::vector<CompositePrimitive> kRequiredPrimitives = { |
| 70 | CompositePrimitive::CLICK, CompositePrimitive::LIGHT_TICK, |
| 71 | CompositePrimitive::QUICK_RISE, CompositePrimitive::SLOW_RISE, |
| 72 | CompositePrimitive::QUICK_FALL, |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 73 | }; |
| 74 | |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 75 | const std::vector<CompositePrimitive> kInvalidPrimitives = { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 76 | static_cast<CompositePrimitive>(static_cast<int32_t>(kCompositePrimitives.front()) - 1), |
| 77 | static_cast<CompositePrimitive>(static_cast<int32_t>(kCompositePrimitives.back()) + 1), |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 78 | }; |
| 79 | |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 80 | // Timeout to wait for vibration callback completion. |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 81 | static constexpr std::chrono::milliseconds VIBRATION_CALLBACK_TIMEOUT = 100ms; |
| 82 | |
| 83 | static std::vector<std::string> findVibratorManagerNames() { |
| 84 | std::vector<std::string> names; |
| 85 | constexpr auto callback = [](const char* instance, void* context) { |
| 86 | auto fullName = std::string(IVibratorManager::descriptor) + "/" + instance; |
| 87 | static_cast<std::vector<std::string>*>(context)->emplace_back(fullName); |
| 88 | }; |
| 89 | AServiceManager_forEachDeclaredInstance(IVibratorManager::descriptor, |
| 90 | static_cast<void*>(&names), callback); |
| 91 | return names; |
| 92 | } |
| 93 | |
| 94 | static std::vector<std::string> findUnmanagedVibratorNames() { |
| 95 | std::vector<std::string> names; |
| 96 | constexpr auto callback = [](const char* instance, void* context) { |
| 97 | auto fullName = std::string(IVibrator::descriptor) + "/" + instance; |
| 98 | static_cast<std::vector<std::string>*>(context)->emplace_back(fullName); |
| 99 | }; |
| 100 | AServiceManager_forEachDeclaredInstance(IVibrator::descriptor, static_cast<void*>(&names), |
| 101 | callback); |
| 102 | return names; |
| 103 | } |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 104 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 105 | class CompletionCallback : public BnVibratorCallback { |
| 106 | public: |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 107 | CompletionCallback(const std::function<void()> &callback) : mCallback(callback) {} |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 108 | ndk::ScopedAStatus onComplete() override { |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 109 | mCallback(); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 110 | return ndk::ScopedAStatus::ok(); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 111 | } |
| 112 | |
| 113 | private: |
| 114 | std::function<void()> mCallback; |
| 115 | }; |
| 116 | |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 117 | class VibratorAidl : public testing::TestWithParam<std::tuple<int32_t, int32_t>> { |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 118 | public: |
| 119 | virtual void SetUp() override { |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 120 | int32_t managerIdx = std::get<0>(GetParam()); |
| 121 | int32_t vibratorId = std::get<1>(GetParam()); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 122 | |
| 123 | if (managerIdx < 0) { |
| 124 | // Testing a unmanaged vibrator, using vibratorId as index from registered HALs |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 125 | std::vector<std::string> vibratorNames = findUnmanagedVibratorNames(); |
| 126 | ASSERT_LT(vibratorId, vibratorNames.size()); |
| 127 | vibrator = IVibrator::fromBinder(ndk::SpAIBinder( |
| 128 | AServiceManager_waitForService(vibratorNames[vibratorId].c_str()))); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 129 | } else { |
| 130 | // Testing a managed vibrator, using vibratorId to retrieve it from the manager |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 131 | std::vector<std::string> managerNames = findVibratorManagerNames(); |
| 132 | ASSERT_LT(managerIdx, managerNames.size()); |
| 133 | auto vibratorManager = IVibratorManager::fromBinder(ndk::SpAIBinder( |
| 134 | AServiceManager_waitForService(managerNames[managerIdx].c_str()))); |
| 135 | EXPECT_OK(vibratorManager->getVibrator(vibratorId, &vibrator)) |
| 136 | << "\n For vibrator id: " << vibratorId; |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 137 | } |
| 138 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 139 | ASSERT_NE(vibrator, nullptr); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 140 | EXPECT_OK(vibrator->getCapabilities(&capabilities)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 143 | virtual void TearDown() override { |
| 144 | // Reset vibrator state between tests. |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 145 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 146 | } |
| 147 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 148 | std::shared_ptr<IVibrator> vibrator; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 149 | int32_t capabilities; |
| 150 | }; |
| 151 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 152 | static float getResonantFrequencyHz(const std::shared_ptr<IVibrator>& vibrator, |
| 153 | int32_t capabilities) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 154 | float resonantFrequencyHz; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 155 | ndk::ScopedAStatus status = vibrator->getResonantFrequency(&resonantFrequencyHz); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 156 | if (capabilities & IVibrator::CAP_GET_RESONANT_FREQUENCY) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 157 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 158 | EXPECT_GT(resonantFrequencyHz, 0); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 159 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 160 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 161 | } |
| 162 | return resonantFrequencyHz; |
| 163 | } |
| 164 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 165 | static float getFrequencyResolutionHz(const std::shared_ptr<IVibrator>& vibrator, |
| 166 | int32_t capabilities) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 167 | float freqResolutionHz; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 168 | ndk::ScopedAStatus status = vibrator->getFrequencyResolution(&freqResolutionHz); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 169 | if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 170 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 171 | EXPECT_GT(freqResolutionHz, 0); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 172 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 173 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 174 | } |
| 175 | return freqResolutionHz; |
| 176 | } |
| 177 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 178 | static float getFrequencyMinimumHz(const std::shared_ptr<IVibrator>& vibrator, |
| 179 | int32_t capabilities) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 180 | float freqMinimumHz; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 181 | ndk::ScopedAStatus status = vibrator->getFrequencyMinimum(&freqMinimumHz); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 182 | if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 183 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 184 | |
| 185 | float resonantFrequencyHz = getResonantFrequencyHz(vibrator, capabilities); |
| 186 | |
| 187 | EXPECT_GT(freqMinimumHz, 0); |
| 188 | EXPECT_LE(freqMinimumHz, resonantFrequencyHz); |
| 189 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 190 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 191 | } |
| 192 | return freqMinimumHz; |
| 193 | } |
| 194 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 195 | static float getFrequencyMaximumHz(const std::shared_ptr<IVibrator>& vibrator, |
| 196 | int32_t capabilities) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 197 | std::vector<float> bandwidthAmplitudeMap; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 198 | ndk::ScopedAStatus status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 199 | if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 200 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 201 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 202 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 203 | } |
| 204 | |
chasewu | 70da3cc | 2022-03-15 15:16:04 +0800 | [diff] [blame] | 205 | float freqMaximumHz = ((bandwidthAmplitudeMap.size() - 1) * |
| 206 | getFrequencyResolutionHz(vibrator, capabilities)) + |
| 207 | getFrequencyMinimumHz(vibrator, capabilities); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 208 | return freqMaximumHz; |
| 209 | } |
| 210 | |
| 211 | static float getAmplitudeMin() { |
| 212 | return 0.0; |
| 213 | } |
| 214 | |
| 215 | static float getAmplitudeMax() { |
| 216 | return 1.0; |
| 217 | } |
| 218 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 219 | static ActivePwle composeValidActivePwle(const std::shared_ptr<IVibrator>& vibrator, |
| 220 | int32_t capabilities) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 221 | float frequencyHz; |
| 222 | if (capabilities & IVibrator::CAP_GET_RESONANT_FREQUENCY) { |
| 223 | frequencyHz = getResonantFrequencyHz(vibrator, capabilities); |
| 224 | } else if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
| 225 | frequencyHz = getFrequencyMinimumHz(vibrator, capabilities); |
| 226 | } else { |
| 227 | frequencyHz = 150.0; // default value commonly used |
| 228 | } |
| 229 | |
| 230 | ActivePwle active; |
| 231 | active.startAmplitude = (getAmplitudeMin() + getAmplitudeMax()) / 2; |
| 232 | active.startFrequency = frequencyHz; |
| 233 | active.endAmplitude = (getAmplitudeMin() + getAmplitudeMax()) / 2; |
| 234 | active.endFrequency = frequencyHz; |
chasewu | 22cb901 | 2022-03-31 23:23:27 +0800 | [diff] [blame] | 235 | vibrator->getPwlePrimitiveDurationMax(&(active.duration)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 236 | |
| 237 | return active; |
| 238 | } |
| 239 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 240 | TEST_P(VibratorAidl, OnThenOffBeforeTimeout) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 241 | EXPECT_OK(vibrator->on(2000, nullptr /*callback*/)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 242 | sleep(1); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 243 | EXPECT_OK(vibrator->off()); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 244 | } |
| 245 | |
| 246 | TEST_P(VibratorAidl, OnWithCallback) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 247 | if (!(capabilities & IVibrator::CAP_ON_CALLBACK)) |
| 248 | return; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 249 | |
| 250 | std::promise<void> completionPromise; |
| 251 | std::future<void> completionFuture{completionPromise.get_future()}; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 252 | auto callback = ndk::SharedRefBase::make<CompletionCallback>( |
| 253 | [&completionPromise] { completionPromise.set_value(); }); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 254 | uint32_t durationMs = 250; |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 255 | auto timeout = std::chrono::milliseconds(durationMs) + VIBRATION_CALLBACK_TIMEOUT; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 256 | EXPECT_OK(vibrator->on(durationMs, callback)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 257 | EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 258 | EXPECT_OK(vibrator->off()); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 259 | } |
| 260 | |
| 261 | TEST_P(VibratorAidl, OnCallbackNotSupported) { |
Fenglin Wu | 15b01dc | 2020-11-23 10:03:10 +0800 | [diff] [blame] | 262 | if (!(capabilities & IVibrator::CAP_ON_CALLBACK)) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 263 | auto callback = ndk::SharedRefBase::make<CompletionCallback>([] {}); |
| 264 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->on(250, callback)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 265 | } |
| 266 | } |
| 267 | |
| 268 | TEST_P(VibratorAidl, ValidateEffect) { |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 269 | std::vector<Effect> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 270 | EXPECT_OK(vibrator->getSupportedEffects(&supported)); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 271 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 272 | for (Effect effect : kEffects) { |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 273 | bool isEffectSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 274 | std::find(supported.begin(), supported.end(), effect) != supported.end(); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 275 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 276 | for (EffectStrength strength : kEffectStrengths) { |
| 277 | int32_t lengthMs = 0; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 278 | ndk::ScopedAStatus status = |
| 279 | vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 280 | |
| 281 | if (isEffectSupported) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 282 | EXPECT_OK(std::move(status)) |
| 283 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 284 | EXPECT_GT(lengthMs, 0); |
Steven Moreland | f335388 | 2019-11-07 17:02:43 -0800 | [diff] [blame] | 285 | usleep(lengthMs * 1000); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 286 | EXPECT_OK(vibrator->off()); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 287 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 288 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) |
| 289 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 290 | } |
| 291 | } |
| 292 | } |
| 293 | } |
| 294 | |
| 295 | TEST_P(VibratorAidl, ValidateEffectWithCallback) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 296 | if (!(capabilities & IVibrator::CAP_PERFORM_CALLBACK)) |
| 297 | return; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 298 | |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 299 | std::vector<Effect> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 300 | EXPECT_OK(vibrator->getSupportedEffects(&supported)); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 301 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 302 | for (Effect effect : kEffects) { |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 303 | bool isEffectSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 304 | std::find(supported.begin(), supported.end(), effect) != supported.end(); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 305 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 306 | for (EffectStrength strength : kEffectStrengths) { |
| 307 | std::promise<void> completionPromise; |
| 308 | std::future<void> completionFuture{completionPromise.get_future()}; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 309 | auto callback = ndk::SharedRefBase::make<CompletionCallback>( |
| 310 | [&completionPromise] { completionPromise.set_value(); }); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 311 | int lengthMs = 0; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 312 | ndk::ScopedAStatus status = vibrator->perform(effect, strength, callback, &lengthMs); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 313 | |
| 314 | if (isEffectSupported) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 315 | EXPECT_OK(std::move(status)) |
| 316 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 317 | EXPECT_GT(lengthMs, 0); |
| 318 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 319 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) |
| 320 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | 2932b22 | 2019-11-05 14:30:17 -0800 | [diff] [blame] | 321 | } |
| 322 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 323 | if (lengthMs <= 0) continue; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 324 | |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 325 | auto timeout = std::chrono::milliseconds(lengthMs) + VIBRATION_CALLBACK_TIMEOUT; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 326 | EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 327 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 328 | EXPECT_OK(vibrator->off()); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 329 | } |
| 330 | } |
| 331 | } |
| 332 | |
| 333 | TEST_P(VibratorAidl, ValidateEffectWithCallbackNotSupported) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 334 | if (capabilities & IVibrator::CAP_PERFORM_CALLBACK) |
| 335 | return; |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 336 | |
| 337 | for (Effect effect : kEffects) { |
| 338 | for (EffectStrength strength : kEffectStrengths) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 339 | auto callback = ndk::SharedRefBase::make<CompletionCallback>([] {}); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 340 | int lengthMs; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 341 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->perform(effect, strength, callback, &lengthMs)) |
| 342 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 343 | } |
| 344 | } |
| 345 | } |
| 346 | |
| 347 | TEST_P(VibratorAidl, InvalidEffectsUnsupported) { |
| 348 | for (Effect effect : kInvalidEffects) { |
Steven Moreland | f335388 | 2019-11-07 17:02:43 -0800 | [diff] [blame] | 349 | for (EffectStrength strength : kEffectStrengths) { |
| 350 | int32_t lengthMs; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 351 | EXPECT_UNKNOWN_OR_UNSUPPORTED( |
| 352 | vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs)) |
| 353 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | f335388 | 2019-11-07 17:02:43 -0800 | [diff] [blame] | 354 | } |
| 355 | } |
| 356 | for (Effect effect : kEffects) { |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 357 | for (EffectStrength strength : kInvalidEffectStrengths) { |
| 358 | int32_t lengthMs; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 359 | EXPECT_UNKNOWN_OR_UNSUPPORTED( |
| 360 | vibrator->perform(effect, strength, nullptr /*callback*/, &lengthMs)) |
| 361 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 362 | } |
| 363 | } |
| 364 | } |
| 365 | |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 366 | TEST_P(VibratorAidl, PerformVendorEffectSupported) { |
| 367 | if ((capabilities & IVibrator::CAP_PERFORM_VENDOR_EFFECTS) == 0) return; |
| 368 | |
| 369 | float scale = 0.5f; |
| 370 | for (EffectStrength strength : kEffectStrengths) { |
| 371 | PersistableBundle vendorData; |
| 372 | ::aidl::android::hardware::vibrator::testing::fillBasicData(&vendorData); |
| 373 | |
| 374 | PersistableBundle nestedData; |
| 375 | ::aidl::android::hardware::vibrator::testing::fillBasicData(&nestedData); |
| 376 | vendorData.putPersistableBundle("test_nested_bundle", nestedData); |
| 377 | |
| 378 | VendorEffect effect; |
| 379 | effect.vendorData = vendorData; |
| 380 | effect.strength = strength; |
| 381 | effect.scale = scale; |
| 382 | scale *= 1.5f; |
| 383 | |
| 384 | auto callback = ndk::SharedRefBase::make<CompletionCallback>([] {}); |
| 385 | ndk::ScopedAStatus status = vibrator->performVendorEffect(effect, callback); |
| 386 | |
| 387 | // No expectations on the actual status, the effect might be refused with illegal argument |
| 388 | // or the vendor might return a service-specific error code. |
| 389 | EXPECT_TRUE(status.getExceptionCode() != EX_UNSUPPORTED_OPERATION && |
| 390 | status.getStatus() != STATUS_UNKNOWN_TRANSACTION) |
| 391 | << status << "\n For vendor effect with strength" << toString(strength) |
| 392 | << " and scale " << effect.scale; |
| 393 | |
| 394 | if (status.isOk()) { |
| 395 | // Generic vendor data should not trigger vibrations, but if it does trigger one |
| 396 | // then we make sure the vibrator is reset by triggering off(). |
| 397 | EXPECT_OK(vibrator->off()); |
| 398 | } |
| 399 | } |
| 400 | } |
| 401 | |
| 402 | TEST_P(VibratorAidl, PerformVendorEffectStability) { |
| 403 | if ((capabilities & IVibrator::CAP_PERFORM_VENDOR_EFFECTS) == 0) return; |
| 404 | |
| 405 | // Run some iterations of performVendorEffect with randomized vendor data to check basic |
| 406 | // stability of the implementation. |
| 407 | uint8_t iterations = 200; |
| 408 | |
| 409 | for (EffectStrength strength : kEffectStrengths) { |
| 410 | float scale = 0.5f; |
| 411 | for (uint8_t i = 0; i < iterations; i++) { |
| 412 | PersistableBundle vendorData; |
| 413 | ::aidl::android::hardware::vibrator::testing::fillRandomData(&vendorData); |
| 414 | |
| 415 | VendorEffect effect; |
| 416 | effect.vendorData = vendorData; |
| 417 | effect.strength = strength; |
| 418 | effect.scale = scale; |
| 419 | scale *= 2; |
| 420 | |
| 421 | auto callback = ndk::SharedRefBase::make<CompletionCallback>([] {}); |
| 422 | ndk::ScopedAStatus status = vibrator->performVendorEffect(effect, callback); |
| 423 | |
| 424 | // No expectations on the actual status, the effect might be refused with illegal |
| 425 | // argument or the vendor might return a service-specific error code. |
| 426 | EXPECT_TRUE(status.getExceptionCode() != EX_UNSUPPORTED_OPERATION && |
| 427 | status.getStatus() != STATUS_UNKNOWN_TRANSACTION) |
| 428 | << status << "\n For random vendor effect with strength " << toString(strength) |
| 429 | << " and scale " << effect.scale; |
| 430 | |
| 431 | if (status.isOk()) { |
| 432 | // Random vendor data should not trigger vibrations, but if it does trigger one |
| 433 | // then we make sure the vibrator is reset by triggering off(). |
| 434 | EXPECT_OK(vibrator->off()); |
| 435 | } |
| 436 | } |
| 437 | } |
| 438 | } |
| 439 | |
| 440 | TEST_P(VibratorAidl, PerformVendorEffectEmptyVendorData) { |
| 441 | if ((capabilities & IVibrator::CAP_PERFORM_VENDOR_EFFECTS) == 0) return; |
| 442 | |
| 443 | for (EffectStrength strength : kEffectStrengths) { |
| 444 | VendorEffect effect; |
| 445 | effect.strength = strength; |
| 446 | effect.scale = 1.0f; |
| 447 | |
| 448 | ndk::ScopedAStatus status = vibrator->performVendorEffect(effect, nullptr /*callback*/); |
| 449 | |
| 450 | EXPECT_TRUE(status.getExceptionCode() == EX_SERVICE_SPECIFIC) |
| 451 | << status << "\n For vendor effect with strength " << toString(strength) |
| 452 | << " and scale " << effect.scale; |
| 453 | } |
| 454 | } |
| 455 | |
| 456 | TEST_P(VibratorAidl, PerformVendorEffectInvalidScale) { |
| 457 | if ((capabilities & IVibrator::CAP_PERFORM_VENDOR_EFFECTS) == 0) return; |
| 458 | |
| 459 | VendorEffect effect; |
| 460 | effect.strength = EffectStrength::MEDIUM; |
| 461 | |
| 462 | effect.scale = 0.0f; |
| 463 | EXPECT_ILLEGAL_ARGUMENT(vibrator->performVendorEffect(effect, nullptr /*callback*/)); |
| 464 | |
| 465 | effect.scale = -1.0f; |
| 466 | EXPECT_ILLEGAL_ARGUMENT(vibrator->performVendorEffect(effect, nullptr /*callback*/)); |
| 467 | } |
| 468 | |
| 469 | TEST_P(VibratorAidl, PerformVendorEffectUnsupported) { |
| 470 | if (capabilities & IVibrator::CAP_PERFORM_VENDOR_EFFECTS) return; |
| 471 | |
| 472 | for (EffectStrength strength : kEffectStrengths) { |
| 473 | VendorEffect effect; |
| 474 | effect.strength = strength; |
| 475 | effect.scale = 1.0f; |
| 476 | |
| 477 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->performVendorEffect(effect, nullptr /*callback*/)) |
| 478 | << "\n For vendor effect with strength " << toString(strength); |
| 479 | } |
| 480 | } |
| 481 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 482 | TEST_P(VibratorAidl, ChangeVibrationAmplitude) { |
| 483 | if (capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 484 | EXPECT_OK(vibrator->setAmplitude(0.1f)); |
| 485 | EXPECT_OK(vibrator->on(2000, nullptr /*callback*/)); |
| 486 | EXPECT_OK(vibrator->setAmplitude(0.5f)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 487 | sleep(1); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 488 | EXPECT_OK(vibrator->setAmplitude(1.0f)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 489 | sleep(1); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 490 | EXPECT_OK(vibrator->off()); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 491 | } |
| 492 | } |
| 493 | |
| 494 | TEST_P(VibratorAidl, AmplitudeOutsideRangeFails) { |
| 495 | if (capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 496 | EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(-1)); |
| 497 | EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(0)); |
| 498 | EXPECT_ILLEGAL_ARGUMENT(vibrator->setAmplitude(1.1)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 499 | } |
| 500 | } |
| 501 | |
| 502 | TEST_P(VibratorAidl, AmplitudeReturnsUnsupportedMatchingCapabilities) { |
| 503 | if ((capabilities & IVibrator::CAP_AMPLITUDE_CONTROL) == 0) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 504 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setAmplitude(1)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 505 | } |
| 506 | } |
| 507 | |
| 508 | TEST_P(VibratorAidl, ChangeVibrationExternalControl) { |
| 509 | if (capabilities & IVibrator::CAP_EXTERNAL_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 510 | EXPECT_OK(vibrator->setExternalControl(true)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 511 | sleep(1); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 512 | EXPECT_OK(vibrator->setExternalControl(false)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 513 | sleep(1); |
| 514 | } |
| 515 | } |
| 516 | |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 517 | TEST_P(VibratorAidl, ExternalAmplitudeControl) { |
| 518 | const bool supportsExternalAmplitudeControl = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 519 | (capabilities & IVibrator::CAP_EXTERNAL_AMPLITUDE_CONTROL) > 0; |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 520 | |
| 521 | if (capabilities & IVibrator::CAP_EXTERNAL_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 522 | EXPECT_OK(vibrator->setExternalControl(true)); |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 523 | |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 524 | if (supportsExternalAmplitudeControl) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 525 | EXPECT_OK(vibrator->setAmplitude(0.5)); |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 526 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 527 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setAmplitude(0.5)); |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 528 | } |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 529 | |
| 530 | EXPECT_OK(vibrator->setExternalControl(false)); |
Steven Moreland | c0b92d5 | 2019-11-05 13:31:41 -0800 | [diff] [blame] | 531 | } else { |
| 532 | EXPECT_FALSE(supportsExternalAmplitudeControl); |
| 533 | } |
| 534 | } |
| 535 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 536 | TEST_P(VibratorAidl, ExternalControlUnsupportedMatchingCapabilities) { |
| 537 | if ((capabilities & IVibrator::CAP_EXTERNAL_CONTROL) == 0) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 538 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->setExternalControl(true)); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 539 | } |
| 540 | } |
| 541 | |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 542 | TEST_P(VibratorAidl, GetSupportedPrimitives) { |
| 543 | if (capabilities & IVibrator::CAP_COMPOSE_EFFECTS) { |
| 544 | std::vector<CompositePrimitive> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 545 | EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 546 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 547 | for (CompositePrimitive primitive : kCompositePrimitives) { |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 548 | bool isPrimitiveSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 549 | std::find(supported.begin(), supported.end(), primitive) != supported.end(); |
Lais Andrade | 7e64377 | 2021-07-09 14:59:44 +0100 | [diff] [blame] | 550 | bool isPrimitiveRequired = |
| 551 | std::find(kRequiredPrimitives.begin(), kRequiredPrimitives.end(), primitive) != |
| 552 | kRequiredPrimitives.end(); |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 553 | |
Lais Andrade | 7e64377 | 2021-07-09 14:59:44 +0100 | [diff] [blame] | 554 | EXPECT_TRUE(isPrimitiveSupported || !isPrimitiveRequired) << toString(primitive); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 555 | } |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 556 | } |
| 557 | } |
| 558 | |
| 559 | TEST_P(VibratorAidl, GetPrimitiveDuration) { |
| 560 | if (capabilities & IVibrator::CAP_COMPOSE_EFFECTS) { |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 561 | std::vector<CompositePrimitive> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 562 | EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 563 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 564 | for (CompositePrimitive primitive : kCompositePrimitives) { |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 565 | bool isPrimitiveSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 566 | std::find(supported.begin(), supported.end(), primitive) != supported.end(); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 567 | int32_t duration; |
| 568 | |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 569 | if (isPrimitiveSupported) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 570 | EXPECT_OK(vibrator->getPrimitiveDuration(primitive, &duration)) |
| 571 | << "\n For primitive: " << toString(primitive) << " " << duration; |
Lais Andrade | f1b4dd3 | 2021-11-03 16:47:32 +0000 | [diff] [blame] | 572 | if (primitive != CompositePrimitive::NOOP) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 573 | ASSERT_GT(duration, 0) |
| 574 | << "\n For primitive: " << toString(primitive) << " " << duration; |
Lais Andrade | f1b4dd3 | 2021-11-03 16:47:32 +0000 | [diff] [blame] | 575 | } |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 576 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 577 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->getPrimitiveDuration(primitive, &duration)) |
| 578 | << "\n For primitive: " << toString(primitive); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 579 | } |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 580 | } |
| 581 | } |
| 582 | } |
| 583 | |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 584 | TEST_P(VibratorAidl, ComposeValidPrimitives) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 585 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 586 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
| 587 | } |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 588 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 589 | std::vector<CompositePrimitive> supported; |
| 590 | int32_t maxDelay, maxSize; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 591 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 592 | EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); |
| 593 | EXPECT_OK(vibrator->getCompositionDelayMax(&maxDelay)); |
| 594 | EXPECT_OK(vibrator->getCompositionSizeMax(&maxSize)); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 595 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 596 | std::vector<CompositeEffect> composite; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 597 | |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 598 | for (int i = 0; i < supported.size(); i++) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 599 | CompositePrimitive primitive = supported[i]; |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 600 | float t = static_cast<float>(i + 1) / supported.size(); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 601 | CompositeEffect effect; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 602 | |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 603 | effect.delayMs = maxDelay * t; |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 604 | effect.primitive = primitive; |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 605 | effect.scale = t; |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 606 | |
| 607 | if (composite.size() == maxSize) { |
| 608 | break; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 609 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 610 | } |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 611 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 612 | if (composite.size() != 0) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 613 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 614 | EXPECT_OK(vibrator->off()); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 615 | } |
| 616 | } |
| 617 | |
| 618 | TEST_P(VibratorAidl, ComposeUnsupportedPrimitives) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 619 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 620 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
| 621 | } |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 622 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 623 | std::vector<CompositePrimitive> unsupported(kInvalidPrimitives); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 624 | std::vector<CompositePrimitive> supported; |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 625 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 626 | EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 627 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 628 | for (CompositePrimitive primitive : kCompositePrimitives) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 629 | bool isPrimitiveSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 630 | std::find(supported.begin(), supported.end(), primitive) != supported.end(); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 631 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 632 | if (!isPrimitiveSupported) { |
| 633 | unsupported.push_back(primitive); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 634 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 635 | } |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 636 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 637 | for (CompositePrimitive primitive : unsupported) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 638 | std::vector<CompositeEffect> composite(1); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 639 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 640 | for (CompositeEffect& effect : composite) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 641 | effect.delayMs = 0; |
| 642 | effect.primitive = primitive; |
| 643 | effect.scale = 1.0f; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 644 | } |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 645 | EXPECT_UNKNOWN_OR_UNSUPPORTED(vibrator->compose(composite, nullptr)); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 646 | } |
| 647 | } |
| 648 | |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 649 | TEST_P(VibratorAidl, ComposeScaleBoundary) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 650 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 651 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 652 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 653 | |
| 654 | std::vector<CompositeEffect> composite(1); |
| 655 | CompositeEffect& effect = composite[0]; |
| 656 | |
| 657 | effect.delayMs = 0; |
| 658 | effect.primitive = CompositePrimitive::CLICK; |
| 659 | |
| 660 | effect.scale = std::nextafter(0.0f, -1.0f); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 661 | EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 662 | |
| 663 | effect.scale = 0.0f; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 664 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 665 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 666 | |
| 667 | effect.scale = 1.0f; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 668 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 669 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 670 | |
| 671 | effect.scale = std::nextafter(1.0f, 2.0f); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 672 | EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 673 | } |
| 674 | |
| 675 | TEST_P(VibratorAidl, ComposeDelayBoundary) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 676 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 677 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 678 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 679 | |
| 680 | int32_t maxDelay; |
| 681 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 682 | EXPECT_OK(vibrator->getCompositionDelayMax(&maxDelay)); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 683 | |
| 684 | std::vector<CompositeEffect> composite(1); |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 685 | CompositeEffect& effect = composite[0]; |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 686 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 687 | effect.primitive = CompositePrimitive::CLICK; |
| 688 | effect.scale = 1.0f; |
| 689 | |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 690 | effect.delayMs = 0; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 691 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 692 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 693 | |
| 694 | effect.delayMs = 1; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 695 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 696 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 661481e | 2024-02-12 10:33:09 +0000 | [diff] [blame] | 697 | |
| 698 | effect.delayMs = maxDelay; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 699 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 700 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 701 | |
| 702 | effect.delayMs = maxDelay + 1; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 703 | EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 704 | } |
| 705 | |
Harpreet \"Eli\" Sangha | 7aec502 | 2020-03-11 06:00:55 +0900 | [diff] [blame] | 706 | TEST_P(VibratorAidl, ComposeSizeBoundary) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 707 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 708 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 709 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 710 | |
| 711 | int32_t maxSize; |
| 712 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 713 | EXPECT_OK(vibrator->getCompositionSizeMax(&maxSize)); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 714 | |
| 715 | std::vector<CompositeEffect> composite(maxSize); |
| 716 | CompositeEffect effect; |
| 717 | |
| 718 | effect.delayMs = 1; |
| 719 | effect.primitive = CompositePrimitive::CLICK; |
| 720 | effect.scale = 1.0f; |
| 721 | |
| 722 | std::fill(composite.begin(), composite.end(), effect); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 723 | EXPECT_OK(vibrator->compose(composite, nullptr)); |
| 724 | EXPECT_OK(vibrator->off()); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 725 | |
| 726 | composite.emplace_back(effect); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 727 | EXPECT_ILLEGAL_ARGUMENT(vibrator->compose(composite, nullptr)); |
Harpreet \"Eli\" Sangha | f4de5b0 | 2019-10-23 09:25:52 +0900 | [diff] [blame] | 728 | } |
| 729 | |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 730 | TEST_P(VibratorAidl, ComposeCallback) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 731 | if (!(capabilities & IVibrator::CAP_COMPOSE_EFFECTS)) { |
| 732 | GTEST_SKIP() << "CAP_COMPOSE_EFFECTS not supported"; |
| 733 | } |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 734 | |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 735 | std::vector<CompositePrimitive> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 736 | EXPECT_OK(vibrator->getSupportedPrimitives(&supported)); |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 737 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 738 | for (CompositePrimitive primitive : supported) { |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 739 | if (primitive == CompositePrimitive::NOOP) { |
| 740 | continue; |
Harpreet \"Eli\" Sangha | b075a6a | 2020-04-10 15:11:58 +0900 | [diff] [blame] | 741 | } |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 742 | |
| 743 | std::promise<void> completionPromise; |
| 744 | std::future<void> completionFuture{completionPromise.get_future()}; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 745 | auto callback = ndk::SharedRefBase::make<CompletionCallback>( |
| 746 | [&completionPromise] { completionPromise.set_value(); }); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 747 | CompositeEffect effect; |
| 748 | std::vector<CompositeEffect> composite; |
| 749 | int32_t durationMs; |
| 750 | std::chrono::milliseconds duration; |
| 751 | std::chrono::time_point<high_resolution_clock> start, end; |
| 752 | std::chrono::milliseconds elapsed; |
| 753 | |
| 754 | effect.delayMs = 0; |
| 755 | effect.primitive = primitive; |
| 756 | effect.scale = 1.0f; |
| 757 | composite.emplace_back(effect); |
| 758 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 759 | EXPECT_OK(vibrator->getPrimitiveDuration(primitive, &durationMs)) |
| 760 | << "\n For primitive: " << toString(primitive); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 761 | duration = std::chrono::milliseconds(durationMs); |
| 762 | |
| 763 | start = high_resolution_clock::now(); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 764 | EXPECT_OK(vibrator->compose(composite, callback)) |
| 765 | << "\n For primitive: " << toString(primitive); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 766 | |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 767 | EXPECT_EQ(completionFuture.wait_for(duration + VIBRATION_CALLBACK_TIMEOUT), |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 768 | std::future_status::ready) |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 769 | << "\n For primitive: " << toString(primitive); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 770 | end = high_resolution_clock::now(); |
| 771 | |
| 772 | elapsed = std::chrono::duration_cast<std::chrono::milliseconds>(end - start); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 773 | EXPECT_GE(elapsed.count(), duration.count()) |
| 774 | << "\n For primitive: " << toString(primitive); |
Lais Andrade | 38d054e | 2024-02-09 12:42:09 +0000 | [diff] [blame] | 775 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 776 | EXPECT_OK(vibrator->off()) << "\n For primitive: " << toString(primitive); |
Harpreet \"Eli\" Sangha | afa8636 | 2020-01-21 16:15:42 +0900 | [diff] [blame] | 777 | } |
| 778 | } |
| 779 | |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 780 | TEST_P(VibratorAidl, AlwaysOn) { |
| 781 | if (capabilities & IVibrator::CAP_ALWAYS_ON_CONTROL) { |
| 782 | std::vector<Effect> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 783 | EXPECT_OK(vibrator->getSupportedAlwaysOnEffects(&supported)); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 784 | |
| 785 | for (Effect effect : kEffects) { |
| 786 | bool isEffectSupported = |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 787 | std::find(supported.begin(), supported.end(), effect) != supported.end(); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 788 | |
| 789 | for (EffectStrength strength : kEffectStrengths) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 790 | ndk::ScopedAStatus status = vibrator->alwaysOnEnable(0, effect, strength); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 791 | |
| 792 | if (isEffectSupported) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 793 | EXPECT_OK(std::move(status)) |
| 794 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 795 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 796 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)) |
| 797 | << "\n For effect: " << toString(effect) << " " << toString(strength); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 798 | } |
| 799 | } |
| 800 | } |
| 801 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 802 | EXPECT_OK(vibrator->alwaysOnDisable(0)); |
Harpreet \"Eli\" Sangha | 6362409 | 2019-09-09 11:04:54 +0900 | [diff] [blame] | 803 | } |
| 804 | } |
| 805 | |
Vince Leung | 4bae4f9 | 2021-02-03 06:21:58 +0000 | [diff] [blame] | 806 | TEST_P(VibratorAidl, GetResonantFrequency) { |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 807 | getResonantFrequencyHz(vibrator, capabilities); |
Vince Leung | 4bae4f9 | 2021-02-03 06:21:58 +0000 | [diff] [blame] | 808 | } |
| 809 | |
| 810 | TEST_P(VibratorAidl, GetQFactor) { |
| 811 | float qFactor; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 812 | ndk::ScopedAStatus status = vibrator->getQFactor(&qFactor); |
Vince Leung | 4bae4f9 | 2021-02-03 06:21:58 +0000 | [diff] [blame] | 813 | if (capabilities & IVibrator::CAP_GET_Q_FACTOR) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 814 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 815 | ASSERT_GT(qFactor, 0); |
Vince Leung | 4bae4f9 | 2021-02-03 06:21:58 +0000 | [diff] [blame] | 816 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 817 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 4bae4f9 | 2021-02-03 06:21:58 +0000 | [diff] [blame] | 818 | } |
| 819 | } |
| 820 | |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 821 | TEST_P(VibratorAidl, GetFrequencyResolution) { |
| 822 | getFrequencyResolutionHz(vibrator, capabilities); |
| 823 | } |
| 824 | |
| 825 | TEST_P(VibratorAidl, GetFrequencyMinimum) { |
| 826 | getFrequencyMinimumHz(vibrator, capabilities); |
| 827 | } |
| 828 | |
| 829 | TEST_P(VibratorAidl, GetBandwidthAmplitudeMap) { |
| 830 | std::vector<float> bandwidthAmplitudeMap; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 831 | ndk::ScopedAStatus status = vibrator->getBandwidthAmplitudeMap(&bandwidthAmplitudeMap); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 832 | if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 833 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 834 | ASSERT_FALSE(bandwidthAmplitudeMap.empty()); |
| 835 | |
| 836 | int minMapSize = (getResonantFrequencyHz(vibrator, capabilities) - |
| 837 | getFrequencyMinimumHz(vibrator, capabilities)) / |
| 838 | getFrequencyResolutionHz(vibrator, capabilities); |
| 839 | ASSERT_GT(bandwidthAmplitudeMap.size(), minMapSize); |
| 840 | |
| 841 | for (float e : bandwidthAmplitudeMap) { |
| 842 | ASSERT_GE(e, 0.0); |
| 843 | ASSERT_LE(e, 1.0); |
| 844 | } |
| 845 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 846 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 847 | } |
| 848 | } |
| 849 | |
| 850 | TEST_P(VibratorAidl, GetPwlePrimitiveDurationMax) { |
| 851 | int32_t durationMs; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 852 | ndk::ScopedAStatus status = vibrator->getPwlePrimitiveDurationMax(&durationMs); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 853 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 854 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 855 | ASSERT_NE(durationMs, 0); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 856 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 857 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 858 | } |
| 859 | } |
| 860 | |
| 861 | TEST_P(VibratorAidl, GetPwleCompositionSizeMax) { |
| 862 | int32_t maxSize; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 863 | ndk::ScopedAStatus status = vibrator->getPwleCompositionSizeMax(&maxSize); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 864 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 865 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 866 | ASSERT_NE(maxSize, 0); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 867 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 868 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 869 | } |
| 870 | } |
| 871 | |
| 872 | TEST_P(VibratorAidl, GetSupportedBraking) { |
| 873 | std::vector<Braking> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 874 | ndk::ScopedAStatus status = vibrator->getSupportedBraking(&supported); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 875 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
| 876 | bool isDefaultNoneSupported = |
| 877 | std::find(supported.begin(), supported.end(), Braking::NONE) != supported.end(); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 878 | EXPECT_OK(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 879 | ASSERT_TRUE(isDefaultNoneSupported); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 880 | } else { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 881 | EXPECT_UNKNOWN_OR_UNSUPPORTED(std::move(status)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 882 | } |
| 883 | } |
| 884 | |
| 885 | TEST_P(VibratorAidl, ComposeValidPwle) { |
| 886 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
Lais Andrade | 22754c5 | 2021-09-14 12:21:59 +0000 | [diff] [blame] | 887 | ActivePwle firstActive = composeValidActivePwle(vibrator, capabilities); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 888 | |
| 889 | std::vector<Braking> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 890 | EXPECT_OK(vibrator->getSupportedBraking(&supported)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 891 | bool isClabSupported = |
| 892 | std::find(supported.begin(), supported.end(), Braking::CLAB) != supported.end(); |
Lais Andrade | 22754c5 | 2021-09-14 12:21:59 +0000 | [diff] [blame] | 893 | BrakingPwle firstBraking; |
| 894 | firstBraking.braking = isClabSupported ? Braking::CLAB : Braking::NONE; |
| 895 | firstBraking.duration = 100; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 896 | |
Lais Andrade | 22754c5 | 2021-09-14 12:21:59 +0000 | [diff] [blame] | 897 | ActivePwle secondActive = composeValidActivePwle(vibrator, capabilities); |
| 898 | if (capabilities & IVibrator::CAP_FREQUENCY_CONTROL) { |
| 899 | float minFrequencyHz = getFrequencyMinimumHz(vibrator, capabilities); |
| 900 | float maxFrequencyHz = getFrequencyMaximumHz(vibrator, capabilities); |
| 901 | float freqResolutionHz = getFrequencyResolutionHz(vibrator, capabilities); |
| 902 | secondActive.startFrequency = minFrequencyHz + (freqResolutionHz / 2.0f); |
| 903 | secondActive.endFrequency = maxFrequencyHz - (freqResolutionHz / 3.0f); |
| 904 | } |
| 905 | BrakingPwle secondBraking; |
| 906 | secondBraking.braking = Braking::NONE; |
| 907 | secondBraking.duration = 10; |
| 908 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 909 | std::vector<PrimitivePwle> pwleQueue = {firstActive, firstBraking, secondActive, |
| 910 | secondBraking}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 911 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 912 | EXPECT_OK(vibrator->composePwle(pwleQueue, nullptr)); |
| 913 | EXPECT_OK(vibrator->off()); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 914 | } |
| 915 | } |
| 916 | |
| 917 | TEST_P(VibratorAidl, ComposeValidPwleWithCallback) { |
| 918 | if (!((capabilities & IVibrator::CAP_ON_CALLBACK) && |
| 919 | (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS))) |
| 920 | return; |
| 921 | |
| 922 | std::promise<void> completionPromise; |
| 923 | std::future<void> completionFuture{completionPromise.get_future()}; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 924 | auto callback = ndk::SharedRefBase::make<CompletionCallback>( |
| 925 | [&completionPromise] { completionPromise.set_value(); }); |
chasewu | 22cb901 | 2022-03-31 23:23:27 +0800 | [diff] [blame] | 926 | int32_t segmentDurationMaxMs; |
| 927 | vibrator->getPwlePrimitiveDurationMax(&segmentDurationMaxMs); |
| 928 | uint32_t durationMs = segmentDurationMaxMs * 2 + 100; // Sum of 2 active and 1 braking below |
Lais Andrade | c689ba5 | 2024-04-10 11:07:11 +0100 | [diff] [blame] | 929 | auto timeout = std::chrono::milliseconds(durationMs) + VIBRATION_CALLBACK_TIMEOUT; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 930 | |
| 931 | ActivePwle active = composeValidActivePwle(vibrator, capabilities); |
| 932 | |
| 933 | std::vector<Braking> supported; |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 934 | EXPECT_OK(vibrator->getSupportedBraking(&supported)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 935 | bool isClabSupported = |
| 936 | std::find(supported.begin(), supported.end(), Braking::CLAB) != supported.end(); |
| 937 | BrakingPwle braking; |
| 938 | braking.braking = isClabSupported ? Braking::CLAB : Braking::NONE; |
| 939 | braking.duration = 100; |
| 940 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 941 | std::vector<PrimitivePwle> pwleQueue = {active, braking, active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 942 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 943 | EXPECT_OK(vibrator->composePwle(pwleQueue, callback)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 944 | EXPECT_EQ(completionFuture.wait_for(timeout), std::future_status::ready); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 945 | EXPECT_OK(vibrator->off()); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 946 | } |
| 947 | |
| 948 | TEST_P(VibratorAidl, ComposePwleSegmentBoundary) { |
| 949 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
| 950 | std::vector<PrimitivePwle> pwleQueue; |
| 951 | // test empty queue |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 952 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 953 | |
| 954 | ActivePwle active = composeValidActivePwle(vibrator, capabilities); |
| 955 | |
| 956 | PrimitivePwle pwle; |
| 957 | pwle = active; |
| 958 | int segmentCountMax; |
| 959 | vibrator->getPwleCompositionSizeMax(&segmentCountMax); |
| 960 | |
| 961 | // Create PWLE queue with more segments than allowed |
| 962 | for (int i = 0; i < segmentCountMax + 10; i++) { |
| 963 | pwleQueue.emplace_back(std::move(pwle)); |
| 964 | } |
| 965 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 966 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 967 | } |
| 968 | } |
| 969 | |
| 970 | TEST_P(VibratorAidl, ComposePwleAmplitudeParameterBoundary) { |
| 971 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
| 972 | ActivePwle active = composeValidActivePwle(vibrator, capabilities); |
| 973 | active.startAmplitude = getAmplitudeMax() + 1.0; // Amplitude greater than allowed |
| 974 | active.endAmplitude = getAmplitudeMax() + 1.0; // Amplitude greater than allowed |
| 975 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 976 | std::vector<PrimitivePwle> pwleQueueGreater = {active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 977 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 978 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueGreater, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 979 | |
| 980 | active.startAmplitude = getAmplitudeMin() - 1.0; // Amplitude less than allowed |
| 981 | active.endAmplitude = getAmplitudeMin() - 1.0; // Amplitude less than allowed |
| 982 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 983 | std::vector<PrimitivePwle> pwleQueueLess = {active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 984 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 985 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueLess, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 986 | } |
| 987 | } |
| 988 | |
| 989 | TEST_P(VibratorAidl, ComposePwleFrequencyParameterBoundary) { |
| 990 | if ((capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) && |
| 991 | (capabilities & IVibrator::CAP_FREQUENCY_CONTROL)) { |
| 992 | float freqMinimumHz = getFrequencyMinimumHz(vibrator, capabilities); |
| 993 | float freqMaximumHz = getFrequencyMaximumHz(vibrator, capabilities); |
| 994 | float freqResolutionHz = getFrequencyResolutionHz(vibrator, capabilities); |
| 995 | |
| 996 | ActivePwle active = composeValidActivePwle(vibrator, capabilities); |
| 997 | active.startFrequency = |
| 998 | freqMaximumHz + freqResolutionHz; // Frequency greater than allowed |
| 999 | active.endFrequency = freqMaximumHz + freqResolutionHz; // Frequency greater than allowed |
| 1000 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1001 | std::vector<PrimitivePwle> pwleQueueGreater = {active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1002 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1003 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueGreater, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1004 | |
| 1005 | active.startFrequency = freqMinimumHz - freqResolutionHz; // Frequency less than allowed |
| 1006 | active.endFrequency = freqMinimumHz - freqResolutionHz; // Frequency less than allowed |
| 1007 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1008 | std::vector<PrimitivePwle> pwleQueueLess = {active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1009 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1010 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueueLess, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1011 | } |
| 1012 | } |
| 1013 | |
| 1014 | TEST_P(VibratorAidl, ComposePwleSegmentDurationBoundary) { |
| 1015 | if (capabilities & IVibrator::CAP_COMPOSE_PWLE_EFFECTS) { |
| 1016 | ActivePwle active = composeValidActivePwle(vibrator, capabilities); |
| 1017 | |
chasewu | 22cb901 | 2022-03-31 23:23:27 +0800 | [diff] [blame] | 1018 | int32_t segmentDurationMaxMs; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1019 | vibrator->getPwlePrimitiveDurationMax(&segmentDurationMaxMs); |
| 1020 | active.duration = segmentDurationMaxMs + 10; // Segment duration greater than allowed |
| 1021 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1022 | std::vector<PrimitivePwle> pwleQueue = {active}; |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1023 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1024 | EXPECT_ILLEGAL_ARGUMENT(vibrator->composePwle(pwleQueue, nullptr)); |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1025 | } |
| 1026 | } |
| 1027 | |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1028 | std::vector<std::tuple<int32_t, int32_t>> GenerateVibratorMapping() { |
| 1029 | std::vector<std::tuple<int32_t, int32_t>> tuples; |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1030 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1031 | std::vector<std::string> managerNames = findVibratorManagerNames(); |
| 1032 | std::vector<int32_t> vibratorIds; |
| 1033 | for (int i = 0; i < managerNames.size(); i++) { |
| 1034 | auto vibratorManager = IVibratorManager::fromBinder( |
| 1035 | ndk::SpAIBinder(AServiceManager_waitForService(managerNames[i].c_str()))); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1036 | if (vibratorManager->getVibratorIds(&vibratorIds).isOk()) { |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1037 | for (int32_t vibratorId : vibratorIds) { |
| 1038 | tuples.emplace_back(i, vibratorId); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1039 | } |
| 1040 | } |
| 1041 | } |
| 1042 | |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1043 | std::vector<std::string> vibratorNames = findUnmanagedVibratorNames(); |
| 1044 | for (int i = 0; i < vibratorNames.size(); i++) { |
| 1045 | tuples.emplace_back(-1, i); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1046 | } |
| 1047 | |
| 1048 | return tuples; |
| 1049 | } |
| 1050 | |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1051 | std::string PrintGeneratedTest(const testing::TestParamInfo<VibratorAidl::ParamType> &info) { |
| 1052 | const auto &[managerIdx, vibratorId] = info.param; |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1053 | if (managerIdx < 0) { |
| 1054 | return std::string("TOP_LEVEL_VIBRATOR_") + std::to_string(vibratorId); |
| 1055 | } |
| 1056 | return std::string("MANAGER_") + std::to_string(managerIdx) + "_VIBRATOR_ID_" + |
| 1057 | std::to_string(vibratorId); |
| 1058 | } |
| 1059 | |
Dan Shi | ba4d532 | 2020-07-28 13:09:30 -0700 | [diff] [blame] | 1060 | GTEST_ALLOW_UNINSTANTIATED_PARAMETERIZED_TEST(VibratorAidl); |
Lais Andrade | 80b1861 | 2020-10-12 18:44:40 +0000 | [diff] [blame] | 1061 | INSTANTIATE_TEST_SUITE_P(Vibrator, VibratorAidl, testing::ValuesIn(GenerateVibratorMapping()), |
| 1062 | PrintGeneratedTest); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 1063 | |
Vince Leung | 823cf5f | 2021-02-11 02:21:57 +0000 | [diff] [blame] | 1064 | int main(int argc, char **argv) { |
Lais Andrade | a3c332f | 2024-06-20 10:46:06 +0100 | [diff] [blame] | 1065 | // Random values are used in the implementation. |
| 1066 | std::srand(std::time(nullptr)); |
| 1067 | |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 1068 | ::testing::InitGoogleTest(&argc, argv); |
Lais Andrade | 28c81f1 | 2024-06-24 14:32:22 +0100 | [diff] [blame] | 1069 | ABinderProcess_setThreadPoolMaxThreadCount(1); |
| 1070 | ABinderProcess_startThreadPool(); |
Steven Moreland | d44007e | 2019-10-24 18:12:46 -0700 | [diff] [blame] | 1071 | return RUN_ALL_TESTS(); |
| 1072 | } |