/* * Copyright (C) 2017 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. */ #pragma once #include #include namespace aidl { namespace android { namespace hardware { namespace vibrator { class Vibrator : public BnVibrator { public: // APIs for interfacing with the kernel driver. class HwApi { public: virtual ~HwApi() = default; // Stores the COMP, BEMF, and GAIN calibration values to use. // virtual bool setAutocal(std::string value) = 0; // Stores the open-loop LRA frequency to be used. virtual bool setOlLraPeriod(uint32_t value) = 0; // Activates/deactivates the vibrator for durations specified by // setDuration(). virtual bool setActivate(bool value) = 0; // Specifies the vibration duration in milliseconds. virtual bool setDuration(uint32_t value) = 0; // Specifies the active state of the vibrator // (true = enabled, false = disabled). virtual bool setState(bool value) = 0; // Reports whether setRtpInput() is supported. virtual bool hasRtpInput() = 0; // Specifies the playback amplitude of the haptic waveforms in RTP mode. // Negative numbers indicates braking. virtual bool setRtpInput(int8_t value) = 0; // Specifies the mode of operation. // rtp - RTP Mode // waveform - Waveform Sequencer Mode // diag - Diagnostics Routine // autocal - Automatic Level Calibration Routine virtual bool setMode(std::string value) = 0; // Specifies a waveform sequence in index-count pairs. // [ ...] virtual bool setSequencer(std::string value) = 0; // Specifies the scaling of effects in Waveform mode. // 0 - 100% // 1 - 75% // 2 - 50% // 3 - 25% virtual bool setScale(uint8_t value) = 0; // Selects either closed loop or open loop mode. // (true = open, false = closed). virtual bool setCtrlLoop(bool value) = 0; // Specifies waveform index to be played in low-power trigger mode. // 0 - Disabled // 1+ - Waveform Index virtual bool setLpTriggerEffect(uint32_t value) = 0; // Specifies scale to be used in low-power trigger mode. // See setScale(). virtual bool setLpTriggerScale(uint8_t value) = 0; // Specifies which shape to use for driving the LRA when in open loop // mode. // 0 - Square Wave // 1 - Sine Wave virtual bool setLraWaveShape(uint32_t value) = 0; // Specifies the maximum voltage for automatic overdrive and automatic // braking periods. virtual bool setOdClamp(uint32_t value) = 0; // Emit diagnostic information to the given file. virtual void debug(int fd) = 0; }; // APIs for obtaining calibration/configuration data from persistent memory. class HwCal { public: virtual ~HwCal() = default; // Obtains the COMP, BEMF, and GAIN calibration values to use. virtual bool getAutocal(std::string *value) = 0; // Obtains the open-loop LRA frequency to be used. virtual bool getLraPeriod(uint32_t *value) = 0; // Obtains threshold in ms, above which close-loop should be used. virtual bool getCloseLoopThreshold(uint32_t *value) = 0; // Obtains dynamic/static configuration choice. virtual bool getDynamicConfig(bool *value) = 0; // Obtains LRA frequency shift for long (steady) vibrations. virtual bool getLongFrequencyShift(uint32_t *value) = 0; // Obtains maximum voltage for short (effect) vibrations virtual bool getShortVoltageMax(uint32_t *value) = 0; // Obtains maximum voltage for long (steady) vibrations virtual bool getLongVoltageMax(uint32_t *value) = 0; // Obtains the duration for the click effect virtual bool getClickDuration(uint32_t *value) = 0; // Obtains the duration for the tick effect virtual bool getTickDuration(uint32_t *value) = 0; // Obtains the duration for the double-click effect virtual bool getDoubleClickDuration(uint32_t *value) = 0; // Obtains the duration for the heavy-click effect virtual bool getHeavyClickDuration(uint32_t *value) = 0; // Emit diagnostic information to the given file. virtual void debug(int fd) = 0; }; private: enum class LoopControl : bool { CLOSE = false, OPEN = true, }; enum class WaveShape : uint32_t { SQUARE = 0, SINE = 1, }; struct VibrationConfig { WaveShape shape; uint32_t odClamp; uint32_t olLraPeriod; }; public: Vibrator(std::unique_ptr hwapi, std::unique_ptr hwcal); ndk::ScopedAStatus getCapabilities(int32_t *_aidl_return) override; ndk::ScopedAStatus off() override; ndk::ScopedAStatus on(int32_t timeoutMs, const std::shared_ptr &callback) override; ndk::ScopedAStatus perform(Effect effect, EffectStrength strength, const std::shared_ptr &callback, int32_t *_aidl_return) override; ndk::ScopedAStatus getSupportedEffects(std::vector *_aidl_return) override; ndk::ScopedAStatus setAmplitude(float amplitude) override; ndk::ScopedAStatus setExternalControl(bool enabled) override; ndk::ScopedAStatus getCompositionDelayMax(int32_t *maxDelayMs); ndk::ScopedAStatus getCompositionSizeMax(int32_t *maxSize); ndk::ScopedAStatus getSupportedPrimitives(std::vector *supported) override; ndk::ScopedAStatus getPrimitiveDuration(CompositePrimitive primitive, int32_t *durationMs) override; ndk::ScopedAStatus compose(const std::vector &composite, const std::shared_ptr &callback) override; ndk::ScopedAStatus getSupportedAlwaysOnEffects(std::vector *_aidl_return) override; ndk::ScopedAStatus alwaysOnEnable(int32_t id, Effect effect, EffectStrength strength) override; ndk::ScopedAStatus alwaysOnDisable(int32_t id) override; ndk::ScopedAStatus getResonantFrequency(float *resonantFreqHz) override; ndk::ScopedAStatus getQFactor(float *qFactor) override; ndk::ScopedAStatus getFrequencyResolution(float *freqResolutionHz) override; ndk::ScopedAStatus getFrequencyMinimum(float *freqMinimumHz) override; ndk::ScopedAStatus getBandwidthAmplitudeMap(std::vector *_aidl_return) override; ndk::ScopedAStatus getPwlePrimitiveDurationMax(int32_t *durationMs) override; ndk::ScopedAStatus getPwleCompositionSizeMax(int32_t *maxSize) override; ndk::ScopedAStatus getSupportedBraking(std::vector *supported) override; ndk::ScopedAStatus composePwle(const std::vector &composite, const std::shared_ptr &callback) override; binder_status_t dump(int fd, const char **args, uint32_t numArgs) override; private: ndk::ScopedAStatus on(uint32_t timeoutMs, const char mode[], const std::unique_ptr &config); ndk::ScopedAStatus getEffectDetails(Effect effect, uint8_t *outIndex, uint32_t *outTimeMs); ndk::ScopedAStatus performEffect(Effect effect, EffectStrength strength, int32_t *outTimeMs); std::unique_ptr mHwApi; std::unique_ptr mHwCal; uint32_t mCloseLoopThreshold; std::unique_ptr mSteadyConfig; std::unique_ptr mEffectConfig; uint32_t mClickDuration; uint32_t mTickDuration; uint32_t mDoubleClickDuration; uint32_t mHeavyClickDuration; }; } // namespace vibrator } // namespace hardware } // namespace android } // namespace aidl