services/inputflinger/tests/FakeEventHub.h

/*
 * Copyright 2022 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 <condition_variable>
#include <mutex>
#include <optional>
#include <unordered_map>
#include <vector>

#include <EventHub.h>
#include <InputDevice.h>
#include <ftl/flags.h>
#include <input/PropertyMap.h>
#include <input/VirtualKeyMap.h>
#include <utils/Errors.h>
#include <utils/KeyedVector.h>

namespace android {

class FakeEventHub : public EventHubInterface {
    struct KeyInfo {
        int32_t keyCode;
        uint32_t flags;
    };

    struct SensorInfo {
        InputDeviceSensorType sensorType;
        int32_t sensorDataIndex;
    };

    struct Device {
        InputDeviceIdentifier identifier;
        ftl::Flags<InputDeviceClass> classes;
        PropertyMap configuration;
        KeyedVector<int, RawAbsoluteAxisInfo> absoluteAxes;
        KeyedVector<int, bool> relativeAxes;
        KeyedVector<int32_t, int32_t> keyCodeStates;
        KeyedVector<int32_t, int32_t> scanCodeStates;
        KeyedVector<int32_t, int32_t> switchStates;
        KeyedVector<int32_t, int32_t> absoluteAxisValue;
        KeyedVector<int32_t, KeyInfo> keysByScanCode;
        KeyedVector<int32_t, KeyInfo> keysByUsageCode;
        std::map<int32_t, int32_t> keyRemapping;
        KeyedVector<int32_t, bool> leds;
        // fake mapping which would normally come from keyCharacterMap
        std::unordered_map<int32_t, int32_t> keyCodeMapping;
        std::unordered_map<int32_t, SensorInfo> sensorsByAbsCode;
        BitArray<MSC_MAX> mscBitmask;
        std::vector<VirtualKeyDefinition> virtualKeys;
        bool enabled;
        std::optional<RawLayoutInfo> layoutInfo;
        std::string sysfsRootPath;
        std::unordered_map<int32_t, std::vector<int32_t>> mtSlotValues;

        status_t enable() {
            enabled = true;
            return OK;
        }

        status_t disable() {
            enabled = false;
            return OK;
        }

        explicit Device(ftl::Flags<InputDeviceClass> classes) : classes(classes), enabled(true) {}
    };

    std::mutex mLock;
    std::condition_variable mEventsCondition;

    KeyedVector<int32_t, Device*> mDevices;
    std::vector<std::string> mExcludedDevices;
    std::vector<RawEvent> mEvents GUARDED_BY(mLock);
    std::unordered_map<int32_t /*deviceId*/, std::vector<TouchVideoFrame>> mVideoFrames;
    std::vector<int32_t> mVibrators = {0, 1};
    std::unordered_map<int32_t, RawLightInfo> mRawLightInfos;
    // Simulates a device light brightness, from light id to light brightness.
    std::unordered_map<int32_t /* lightId */, int32_t /* brightness*/> mLightBrightness;
    // Simulates a device light intensities, from light id to light intensities map.
    std::unordered_map<int32_t /* lightId */, std::unordered_map<LightColor, int32_t>>
            mLightIntensities;

public:
    static constexpr int32_t DEFAULT_BATTERY = 1;
    static constexpr int32_t BATTERY_STATUS = 4;
    static constexpr int32_t BATTERY_CAPACITY = 66;
    static const std::string BATTERY_DEVPATH;

    virtual ~FakeEventHub();
    FakeEventHub() {}

    void addDevice(int32_t deviceId, const std::string& name, ftl::Flags<InputDeviceClass> classes,
                   int bus = 0);
    void removeDevice(int32_t deviceId);

    bool isDeviceEnabled(int32_t deviceId) const override;
    status_t enableDevice(int32_t deviceId) override;
    status_t disableDevice(int32_t deviceId) override;

    void addConfigurationProperty(int32_t deviceId, const char* key, const char* value);
    void addConfigurationMap(int32_t deviceId, const PropertyMap* configuration);

    void addAbsoluteAxis(int32_t deviceId, int axis, int32_t minValue, int32_t maxValue, int flat,
                         int fuzz, int resolution = 0);
    void addRelativeAxis(int32_t deviceId, int32_t axis);
    void setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value);

    void setRawLayoutInfo(int32_t deviceId, RawLayoutInfo info);

    void setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state);
    void setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state);
    void setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state);

    void addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t keyCode,
                uint32_t flags);
    void addKeyCodeMapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode);
    void setKeyRemapping(int32_t deviceId, const std::map<int32_t, int32_t>& keyRemapping) const;
    void addVirtualKeyDefinition(int32_t deviceId, const VirtualKeyDefinition& definition);

    void addSensorAxis(int32_t deviceId, int32_t absCode, InputDeviceSensorType sensorType,
                       int32_t sensorDataIndex);

    void setMscEvent(int32_t deviceId, int32_t mscEvent);

    void addLed(int32_t deviceId, int32_t led, bool initialState);
    void addRawLightInfo(int32_t rawId, RawLightInfo&& info);
    void fakeLightBrightness(int32_t rawId, int32_t brightness);
    void fakeLightIntensities(int32_t rawId,
                              const std::unordered_map<LightColor, int32_t> intensities);
    bool getLedState(int32_t deviceId, int32_t led);

    std::vector<std::string>& getExcludedDevices();

    void setVideoFrames(
            std::unordered_map<int32_t /*deviceId*/, std::vector<TouchVideoFrame>> videoFrames);

    void enqueueEvent(nsecs_t when, nsecs_t readTime, int32_t deviceId, int32_t type, int32_t code,
                      int32_t value);
    void assertQueueIsEmpty();
    void setSysfsRootPath(int32_t deviceId, std::string sysfsRootPath) const;
    // Populate fake slot values to be returned by the getter, size of the values should be equal to
    // the slot count
    void setMtSlotValues(int32_t deviceId, int32_t axis, const std::vector<int32_t>& values);
    base::Result<std::vector<int32_t>> getMtSlotValues(int32_t deviceId, int32_t axis,
                                                       size_t slotCount) const override;

private:
    Device* getDevice(int32_t deviceId) const;

    ftl::Flags<InputDeviceClass> getDeviceClasses(int32_t deviceId) const override;
    InputDeviceIdentifier getDeviceIdentifier(int32_t deviceId) const override;
    int32_t getDeviceControllerNumber(int32_t) const override;
    std::optional<PropertyMap> getConfiguration(int32_t deviceId) const override;
    std::optional<RawAbsoluteAxisInfo> getAbsoluteAxisInfo(int32_t deviceId,
                                                           int axis) const override;
    bool hasRelativeAxis(int32_t deviceId, int axis) const override;
    bool hasInputProperty(int32_t, int) const override;
    bool hasMscEvent(int32_t deviceId, int mscEvent) const override final;
    status_t mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t metaState,
                    int32_t* outKeycode, int32_t* outMetaState, uint32_t* outFlags) const override;
    const KeyInfo* getKey(Device* device, int32_t scanCode, int32_t usageCode) const;

    status_t mapAxis(int32_t, int32_t, AxisInfo*) const override;
    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(
            int32_t deviceId, int32_t absCode) const override;
    void setExcludedDevices(const std::vector<std::string>& devices) override;
    std::vector<RawEvent> getEvents(int) override;
    std::vector<TouchVideoFrame> getVideoFrames(int32_t deviceId) override;
    int32_t getScanCodeState(int32_t deviceId, int32_t scanCode) const override;
    std::optional<RawLayoutInfo> getRawLayoutInfo(int32_t deviceId) const override;
    int32_t getKeyCodeState(int32_t deviceId, int32_t keyCode) const override;
    int32_t getSwitchState(int32_t deviceId, int32_t sw) const override;
    std::optional<int32_t> getAbsoluteAxisValue(int32_t deviceId, int32_t axis) const override;
    int32_t getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKeyCode) const override;

    // Return true if the device has non-empty key layout.
    bool markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,
                               uint8_t* outFlags) const override;
    bool hasScanCode(int32_t deviceId, int32_t scanCode) const override;
    bool hasKeyCode(int32_t deviceId, int32_t keyCode) const override;
    bool hasLed(int32_t deviceId, int32_t led) const override;
    void setLedState(int32_t deviceId, int32_t led, bool on) override;
    void getVirtualKeyDefinitions(int32_t deviceId,
                                  std::vector<VirtualKeyDefinition>& outVirtualKeys) const override;
    const std::shared_ptr<KeyCharacterMap> getKeyCharacterMap(int32_t) const override;
    bool setKeyboardLayoutOverlay(int32_t, std::shared_ptr<KeyCharacterMap>) override;

    void vibrate(int32_t, const VibrationElement&) override {}
    void cancelVibrate(int32_t) override {}
    std::vector<int32_t> getVibratorIds(int32_t deviceId) const override;

    std::optional<int32_t> getBatteryCapacity(int32_t, int32_t) const override;
    std::optional<int32_t> getBatteryStatus(int32_t, int32_t) const override;
    std::vector<int32_t> getRawBatteryIds(int32_t deviceId) const override;
    std::optional<RawBatteryInfo> getRawBatteryInfo(int32_t deviceId,
                                                    int32_t batteryId) const override;

    std::vector<int32_t> getRawLightIds(int32_t deviceId) const override;
    std::optional<RawLightInfo> getRawLightInfo(int32_t deviceId, int32_t lightId) const override;
    void setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) override;
    void setLightIntensities(int32_t deviceId, int32_t lightId,
                             std::unordered_map<LightColor, int32_t> intensities) override;
    std::optional<int32_t> getLightBrightness(int32_t deviceId, int32_t lightId) const override;
    std::optional<std::unordered_map<LightColor, int32_t>> getLightIntensities(
            int32_t deviceId, int32_t lightId) const override;
    void sysfsNodeChanged(const std::string& sysfsNodePath) override;
    void dump(std::string&) const override {}
    void monitor() const override {}
    void requestReopenDevices() override {}
    void wake() override {}
};

} // namespace android