inputflinger/tests/FakeEventHub.cpp

/*
 * 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.
 */

#include "FakeEventHub.h"

#include <android-base/thread_annotations.h>
#include <gtest/gtest.h>
#include <linux/input-event-codes.h>

#include "TestConstants.h"

namespace android {

const std::string FakeEventHub::BATTERY_DEVPATH = "/sys/devices/mydevice/power_supply/mybattery";

FakeEventHub::~FakeEventHub() {
    for (size_t i = 0; i < mDevices.size(); i++) {
        delete mDevices.valueAt(i);
    }
}

void FakeEventHub::addDevice(int32_t deviceId, const std::string& name,
                             ftl::Flags<InputDeviceClass> classes, int bus) {
    Device* device = new Device(classes);
    device->identifier.name = name;
    device->identifier.bus = bus;
    mDevices.add(deviceId, device);

    enqueueEvent(ARBITRARY_TIME, READ_TIME, deviceId, EventHubInterface::DEVICE_ADDED, 0, 0);
}

void FakeEventHub::removeDevice(int32_t deviceId) {
    delete mDevices.valueFor(deviceId);
    mDevices.removeItem(deviceId);

    enqueueEvent(ARBITRARY_TIME, READ_TIME, deviceId, EventHubInterface::DEVICE_REMOVED, 0, 0);
}

bool FakeEventHub::isDeviceEnabled(int32_t deviceId) const {
    Device* device = getDevice(deviceId);
    if (device == nullptr) {
        ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
        return false;
    }
    return device->enabled;
}

status_t FakeEventHub::enableDevice(int32_t deviceId) {
    status_t result;
    Device* device = getDevice(deviceId);
    if (device == nullptr) {
        ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
        return BAD_VALUE;
    }
    if (device->enabled) {
        ALOGW("Duplicate call to %s, device %" PRId32 " already enabled", __func__, deviceId);
        return OK;
    }
    result = device->enable();
    return result;
}

status_t FakeEventHub::disableDevice(int32_t deviceId) {
    Device* device = getDevice(deviceId);
    if (device == nullptr) {
        ALOGE("Incorrect device id=%" PRId32 " provided to %s", deviceId, __func__);
        return BAD_VALUE;
    }
    if (!device->enabled) {
        ALOGW("Duplicate call to %s, device %" PRId32 " already disabled", __func__, deviceId);
        return OK;
    }
    return device->disable();
}

void FakeEventHub::finishDeviceScan() {
    enqueueEvent(ARBITRARY_TIME, READ_TIME, 0, EventHubInterface::FINISHED_DEVICE_SCAN, 0, 0);
}

void FakeEventHub::addConfigurationProperty(int32_t deviceId, const char* key, const char* value) {
    getDevice(deviceId)->configuration.addProperty(key, value);
}

void FakeEventHub::addConfigurationMap(int32_t deviceId, const PropertyMap* configuration) {
    getDevice(deviceId)->configuration.addAll(configuration);
}

void FakeEventHub::addAbsoluteAxis(int32_t deviceId, int axis, int32_t minValue, int32_t maxValue,
                                   int flat, int fuzz, int resolution) {
    Device* device = getDevice(deviceId);

    RawAbsoluteAxisInfo info;
    info.valid = true;
    info.minValue = minValue;
    info.maxValue = maxValue;
    info.flat = flat;
    info.fuzz = fuzz;
    info.resolution = resolution;
    device->absoluteAxes.add(axis, info);
}

void FakeEventHub::addRelativeAxis(int32_t deviceId, int32_t axis) {
    getDevice(deviceId)->relativeAxes.add(axis, true);
}

void FakeEventHub::setKeyCodeState(int32_t deviceId, int32_t keyCode, int32_t state) {
    getDevice(deviceId)->keyCodeStates.replaceValueFor(keyCode, state);
}

void FakeEventHub::setRawLayoutInfo(int32_t deviceId, RawLayoutInfo info) {
    getDevice(deviceId)->layoutInfo = info;
}

void FakeEventHub::setScanCodeState(int32_t deviceId, int32_t scanCode, int32_t state) {
    getDevice(deviceId)->scanCodeStates.replaceValueFor(scanCode, state);
}

void FakeEventHub::setSwitchState(int32_t deviceId, int32_t switchCode, int32_t state) {
    getDevice(deviceId)->switchStates.replaceValueFor(switchCode, state);
}

void FakeEventHub::setAbsoluteAxisValue(int32_t deviceId, int32_t axis, int32_t value) {
    getDevice(deviceId)->absoluteAxisValue.replaceValueFor(axis, value);
}

void FakeEventHub::addKey(int32_t deviceId, int32_t scanCode, int32_t usageCode, int32_t keyCode,
                          uint32_t flags) {
    Device* device = getDevice(deviceId);
    KeyInfo info;
    info.keyCode = keyCode;
    info.flags = flags;
    if (scanCode) {
        device->keysByScanCode.add(scanCode, info);
    }
    if (usageCode) {
        device->keysByUsageCode.add(usageCode, info);
    }
}

void FakeEventHub::addKeyCodeMapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode) {
    getDevice(deviceId)->keyCodeMapping.insert_or_assign(fromKeyCode, toKeyCode);
}

void FakeEventHub::addKeyRemapping(int32_t deviceId, int32_t fromKeyCode, int32_t toKeyCode) const {
    Device* device = getDevice(deviceId);
    device->keyRemapping.insert_or_assign(fromKeyCode, toKeyCode);
}

void FakeEventHub::addLed(int32_t deviceId, int32_t led, bool initialState) {
    getDevice(deviceId)->leds.add(led, initialState);
}

void FakeEventHub::addSensorAxis(int32_t deviceId, int32_t absCode,
                                 InputDeviceSensorType sensorType, int32_t sensorDataIndex) {
    SensorInfo info;
    info.sensorType = sensorType;
    info.sensorDataIndex = sensorDataIndex;
    getDevice(deviceId)->sensorsByAbsCode.emplace(absCode, info);
}

void FakeEventHub::setMscEvent(int32_t deviceId, int32_t mscEvent) {
    typename BitArray<MSC_MAX>::Buffer buffer;
    buffer[mscEvent / 32] = 1 << mscEvent % 32;
    getDevice(deviceId)->mscBitmask.loadFromBuffer(buffer);
}

void FakeEventHub::addRawLightInfo(int32_t rawId, RawLightInfo&& info) {
    mRawLightInfos.emplace(rawId, std::move(info));
}

void FakeEventHub::fakeLightBrightness(int32_t rawId, int32_t brightness) {
    mLightBrightness.emplace(rawId, brightness);
}

void FakeEventHub::fakeLightIntensities(int32_t rawId,
                                        const std::unordered_map<LightColor, int32_t> intensities) {
    mLightIntensities.emplace(rawId, std::move(intensities));
}

bool FakeEventHub::getLedState(int32_t deviceId, int32_t led) {
    return getDevice(deviceId)->leds.valueFor(led);
}

std::vector<std::string>& FakeEventHub::getExcludedDevices() {
    return mExcludedDevices;
}

void FakeEventHub::addVirtualKeyDefinition(int32_t deviceId,
                                           const VirtualKeyDefinition& definition) {
    getDevice(deviceId)->virtualKeys.push_back(definition);
}

void FakeEventHub::enqueueEvent(nsecs_t when, nsecs_t readTime, int32_t deviceId, int32_t type,
                                int32_t code, int32_t value) {
    std::scoped_lock<std::mutex> lock(mLock);
    RawEvent event;
    event.when = when;
    event.readTime = readTime;
    event.deviceId = deviceId;
    event.type = type;
    event.code = code;
    event.value = value;
    mEvents.push_back(event);

    if (type == EV_ABS) {
        setAbsoluteAxisValue(deviceId, code, value);
    }
}

void FakeEventHub::setVideoFrames(
        std::unordered_map<int32_t /*deviceId*/, std::vector<TouchVideoFrame>> videoFrames) {
    mVideoFrames = std::move(videoFrames);
}

void FakeEventHub::assertQueueIsEmpty() {
    std::unique_lock<std::mutex> lock(mLock);
    base::ScopedLockAssertion assumeLocked(mLock);
    const bool queueIsEmpty =
            mEventsCondition.wait_for(lock, WAIT_TIMEOUT,
                                      [this]() REQUIRES(mLock) { return mEvents.size() == 0; });
    if (!queueIsEmpty) {
        FAIL() << "Timed out waiting for EventHub queue to be emptied.";
    }
}

FakeEventHub::Device* FakeEventHub::getDevice(int32_t deviceId) const {
    ssize_t index = mDevices.indexOfKey(deviceId);
    return index >= 0 ? mDevices.valueAt(index) : nullptr;
}

ftl::Flags<InputDeviceClass> FakeEventHub::getDeviceClasses(int32_t deviceId) const {
    Device* device = getDevice(deviceId);
    return device ? device->classes : ftl::Flags<InputDeviceClass>(0);
}

InputDeviceIdentifier FakeEventHub::getDeviceIdentifier(int32_t deviceId) const {
    Device* device = getDevice(deviceId);
    return device ? device->identifier : InputDeviceIdentifier();
}

int32_t FakeEventHub::getDeviceControllerNumber(int32_t) const {
    return 0;
}

std::optional<PropertyMap> FakeEventHub::getConfiguration(int32_t deviceId) const {
    Device* device = getDevice(deviceId);
    if (device == nullptr) {
        return {};
    }
    return device->configuration;
}

status_t FakeEventHub::getAbsoluteAxisInfo(int32_t deviceId, int axis,
                                           RawAbsoluteAxisInfo* outAxisInfo) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->absoluteAxes.indexOfKey(axis);
        if (index >= 0) {
            *outAxisInfo = device->absoluteAxes.valueAt(index);
            return OK;
        }
    }
    outAxisInfo->clear();
    return -1;
}

bool FakeEventHub::hasRelativeAxis(int32_t deviceId, int axis) const {
    Device* device = getDevice(deviceId);
    if (device) {
        return device->relativeAxes.indexOfKey(axis) >= 0;
    }
    return false;
}

bool FakeEventHub::hasInputProperty(int32_t, int) const {
    return false;
}

bool FakeEventHub::hasMscEvent(int32_t deviceId, int mscEvent) const {
    Device* device = getDevice(deviceId);
    if (device) {
        return mscEvent >= 0 && mscEvent <= MSC_MAX ? device->mscBitmask.test(mscEvent) : false;
    }
    return false;
}

status_t FakeEventHub::mapKey(int32_t deviceId, int32_t scanCode, int32_t usageCode,
                              int32_t metaState, int32_t* outKeycode, int32_t* outMetaState,
                              uint32_t* outFlags) const {
    Device* device = getDevice(deviceId);
    if (device) {
        const KeyInfo* key = getKey(device, scanCode, usageCode);
        if (key) {
            if (outKeycode) {
                auto it = device->keyRemapping.find(key->keyCode);
                *outKeycode = it != device->keyRemapping.end() ? it->second : key->keyCode;
            }
            if (outFlags) {
                *outFlags = key->flags;
            }
            if (outMetaState) {
                *outMetaState = metaState;
            }
            return OK;
        }
    }
    return NAME_NOT_FOUND;
}

const FakeEventHub::KeyInfo* FakeEventHub::getKey(Device* device, int32_t scanCode,
                                                  int32_t usageCode) const {
    if (usageCode) {
        ssize_t index = device->keysByUsageCode.indexOfKey(usageCode);
        if (index >= 0) {
            return &device->keysByUsageCode.valueAt(index);
        }
    }
    if (scanCode) {
        ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
        if (index >= 0) {
            return &device->keysByScanCode.valueAt(index);
        }
    }
    return nullptr;
}

status_t FakeEventHub::mapAxis(int32_t, int32_t, AxisInfo*) const {
    return NAME_NOT_FOUND;
}

base::Result<std::pair<InputDeviceSensorType, int32_t>> FakeEventHub::mapSensor(
        int32_t deviceId, int32_t absCode) const {
    Device* device = getDevice(deviceId);
    if (!device) {
        return Errorf("Sensor device not found.");
    }
    auto it = device->sensorsByAbsCode.find(absCode);
    if (it == device->sensorsByAbsCode.end()) {
        return Errorf("Sensor map not found.");
    }
    const SensorInfo& info = it->second;
    return std::make_pair(info.sensorType, info.sensorDataIndex);
}

void FakeEventHub::setExcludedDevices(const std::vector<std::string>& devices) {
    mExcludedDevices = devices;
}

std::vector<RawEvent> FakeEventHub::getEvents(int) {
    std::scoped_lock lock(mLock);

    std::vector<RawEvent> buffer;
    std::swap(buffer, mEvents);

    mEventsCondition.notify_all();
    return buffer;
}

std::vector<TouchVideoFrame> FakeEventHub::getVideoFrames(int32_t deviceId) {
    auto it = mVideoFrames.find(deviceId);
    if (it != mVideoFrames.end()) {
        std::vector<TouchVideoFrame> frames = std::move(it->second);
        mVideoFrames.erase(deviceId);
        return frames;
    }
    return {};
}

int32_t FakeEventHub::getScanCodeState(int32_t deviceId, int32_t scanCode) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->scanCodeStates.indexOfKey(scanCode);
        if (index >= 0) {
            return device->scanCodeStates.valueAt(index);
        }
    }
    return AKEY_STATE_UNKNOWN;
}

std::optional<RawLayoutInfo> FakeEventHub::getRawLayoutInfo(int32_t deviceId) const {
    Device* device = getDevice(deviceId);
    return device ? device->layoutInfo : std::nullopt;
}

int32_t FakeEventHub::getKeyCodeState(int32_t deviceId, int32_t keyCode) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->keyCodeStates.indexOfKey(keyCode);
        if (index >= 0) {
            return device->keyCodeStates.valueAt(index);
        }
    }
    return AKEY_STATE_UNKNOWN;
}

int32_t FakeEventHub::getSwitchState(int32_t deviceId, int32_t sw) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->switchStates.indexOfKey(sw);
        if (index >= 0) {
            return device->switchStates.valueAt(index);
        }
    }
    return AKEY_STATE_UNKNOWN;
}

status_t FakeEventHub::getAbsoluteAxisValue(int32_t deviceId, int32_t axis,
                                            int32_t* outValue) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->absoluteAxisValue.indexOfKey(axis);
        if (index >= 0) {
            *outValue = device->absoluteAxisValue.valueAt(index);
            return OK;
        }
    }
    *outValue = 0;
    return -1;
}

void FakeEventHub::setMtSlotValues(int32_t deviceId, int32_t axis,
                                   const std::vector<int32_t>& values) {
    Device* device = getDevice(deviceId);
    if (!device) {
        FAIL() << "Missing device";
    }
    device->mtSlotValues[axis] = values;
}

base::Result<std::vector<int32_t>> FakeEventHub::getMtSlotValues(int32_t deviceId, int32_t axis,
                                                                 size_t slotCount) const {
    Device* device = getDevice(deviceId);
    if (!device) {
        ADD_FAILURE() << "Missing device";
        return base::ResultError("Missing device", UNKNOWN_ERROR);
    }
    const auto& mtSlotValuesIterator = device->mtSlotValues.find(axis);
    if (mtSlotValuesIterator == device->mtSlotValues.end()) {
        return base::ResultError("axis not supported", NAME_NOT_FOUND);
    }
    const auto& mtSlotValues = mtSlotValuesIterator->second;
    if (mtSlotValues.size() != slotCount) {
        ADD_FAILURE() << "MtSlot values specified for " << mtSlotValues.size()
                      << " slots but expected for " << slotCount << " Slots";
        return base::ResultError("Slot count mismatch", NAME_NOT_FOUND);
    }
    std::vector<int32_t> outValues(slotCount + 1);
    outValues[0] = axis;
    std::copy(mtSlotValues.begin(), mtSlotValues.end(), outValues.begin() + 1);
    return std::move(outValues);
}

int32_t FakeEventHub::getKeyCodeForKeyLocation(int32_t deviceId, int32_t locationKeyCode) const {
    Device* device = getDevice(deviceId);
    if (!device) {
        return AKEYCODE_UNKNOWN;
    }
    auto it = device->keyCodeMapping.find(locationKeyCode);
    return it != device->keyCodeMapping.end() ? it->second : locationKeyCode;
}

// Return true if the device has non-empty key layout.
bool FakeEventHub::markSupportedKeyCodes(int32_t deviceId, const std::vector<int32_t>& keyCodes,
                                         uint8_t* outFlags) const {
    Device* device = getDevice(deviceId);
    if (!device) return false;

    bool result = device->keysByScanCode.size() > 0 || device->keysByUsageCode.size() > 0;
    for (size_t i = 0; i < keyCodes.size(); i++) {
        for (size_t j = 0; j < device->keysByScanCode.size(); j++) {
            if (keyCodes[i] == device->keysByScanCode.valueAt(j).keyCode) {
                outFlags[i] = 1;
            }
        }
        for (size_t j = 0; j < device->keysByUsageCode.size(); j++) {
            if (keyCodes[i] == device->keysByUsageCode.valueAt(j).keyCode) {
                outFlags[i] = 1;
            }
        }
    }
    return result;
}

bool FakeEventHub::hasScanCode(int32_t deviceId, int32_t scanCode) const {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->keysByScanCode.indexOfKey(scanCode);
        return index >= 0;
    }
    return false;
}

bool FakeEventHub::hasKeyCode(int32_t deviceId, int32_t keyCode) const {
    Device* device = getDevice(deviceId);
    if (!device) {
        return false;
    }
    for (size_t i = 0; i < device->keysByScanCode.size(); i++) {
        if (keyCode == device->keysByScanCode.valueAt(i).keyCode) {
            return true;
        }
    }
    for (size_t j = 0; j < device->keysByUsageCode.size(); j++) {
        if (keyCode == device->keysByUsageCode.valueAt(j).keyCode) {
            return true;
        }
    }
    return false;
}

bool FakeEventHub::hasLed(int32_t deviceId, int32_t led) const {
    Device* device = getDevice(deviceId);
    return device && device->leds.indexOfKey(led) >= 0;
}

void FakeEventHub::setLedState(int32_t deviceId, int32_t led, bool on) {
    Device* device = getDevice(deviceId);
    if (device) {
        ssize_t index = device->leds.indexOfKey(led);
        if (index >= 0) {
            device->leds.replaceValueAt(led, on);
        } else {
            ADD_FAILURE() << "Attempted to set the state of an LED that the EventHub declared "
                             "was not present.  led="
                          << led;
        }
    }
}

void FakeEventHub::getVirtualKeyDefinitions(
        int32_t deviceId, std::vector<VirtualKeyDefinition>& outVirtualKeys) const {
    outVirtualKeys.clear();

    Device* device = getDevice(deviceId);
    if (device) {
        outVirtualKeys = device->virtualKeys;
    }
}

const std::shared_ptr<KeyCharacterMap> FakeEventHub::getKeyCharacterMap(int32_t) const {
    return nullptr;
}

bool FakeEventHub::setKeyboardLayoutOverlay(int32_t, std::shared_ptr<KeyCharacterMap>) {
    return false;
}

std::vector<int32_t> FakeEventHub::getVibratorIds(int32_t deviceId) const {
    return mVibrators;
}

std::optional<int32_t> FakeEventHub::getBatteryCapacity(int32_t, int32_t) const {
    return BATTERY_CAPACITY;
}

std::optional<int32_t> FakeEventHub::getBatteryStatus(int32_t, int32_t) const {
    return BATTERY_STATUS;
}

std::vector<int32_t> FakeEventHub::getRawBatteryIds(int32_t deviceId) const {
    return {DEFAULT_BATTERY};
}

std::optional<RawBatteryInfo> FakeEventHub::getRawBatteryInfo(int32_t deviceId,
                                                              int32_t batteryId) const {
    if (batteryId != DEFAULT_BATTERY) return {};
    static const auto BATTERY_INFO = RawBatteryInfo{.id = DEFAULT_BATTERY,
                                                    .name = "default battery",
                                                    .flags = InputBatteryClass::CAPACITY,
                                                    .path = BATTERY_DEVPATH};
    return BATTERY_INFO;
}

std::vector<int32_t> FakeEventHub::getRawLightIds(int32_t deviceId) const {
    std::vector<int32_t> ids;
    for (const auto& [rawId, info] : mRawLightInfos) {
        ids.push_back(rawId);
    }
    return ids;
}

std::optional<RawLightInfo> FakeEventHub::getRawLightInfo(int32_t deviceId, int32_t lightId) const {
    auto it = mRawLightInfos.find(lightId);
    if (it == mRawLightInfos.end()) {
        return std::nullopt;
    }
    return it->second;
}

void FakeEventHub::setLightBrightness(int32_t deviceId, int32_t lightId, int32_t brightness) {
    mLightBrightness.emplace(lightId, brightness);
}

void FakeEventHub::setLightIntensities(int32_t deviceId, int32_t lightId,
                                       std::unordered_map<LightColor, int32_t> intensities) {
    mLightIntensities.emplace(lightId, intensities);
};

std::optional<int32_t> FakeEventHub::getLightBrightness(int32_t deviceId, int32_t lightId) const {
    auto lightIt = mLightBrightness.find(lightId);
    if (lightIt == mLightBrightness.end()) {
        return std::nullopt;
    }
    return lightIt->second;
}

std::optional<std::unordered_map<LightColor, int32_t>> FakeEventHub::getLightIntensities(
        int32_t deviceId, int32_t lightId) const {
    auto lightIt = mLightIntensities.find(lightId);
    if (lightIt == mLightIntensities.end()) {
        return std::nullopt;
    }
    return lightIt->second;
};

void FakeEventHub::setSysfsRootPath(int32_t deviceId, std::string sysfsRootPath) const {
    Device* device = getDevice(deviceId);
    if (device == nullptr) {
        return;
    }
    device->sysfsRootPath = sysfsRootPath;
}

void FakeEventHub::sysfsNodeChanged(const std::string& sysfsNodePath) {
    int32_t foundDeviceId = -1;
    Device* foundDevice = nullptr;
    for (size_t i = 0; i < mDevices.size(); i++) {
        Device* d = mDevices.valueAt(i);
        if (sysfsNodePath.find(d->sysfsRootPath) != std::string::npos) {
            foundDeviceId = mDevices.keyAt(i);
            foundDevice = d;
        }
    }
    if (foundDevice == nullptr) {
        return;
    }
    // If device sysfs changed -> reopen the device
    if (!mRawLightInfos.empty() && !foundDevice->classes.test(InputDeviceClass::LIGHT)) {
        InputDeviceIdentifier identifier = foundDevice->identifier;
        ftl::Flags<InputDeviceClass> classes = foundDevice->classes;
        removeDevice(foundDeviceId);
        addDevice(foundDeviceId, identifier.name, classes | InputDeviceClass::LIGHT,
                  identifier.bus);
    }
}

} // namespace android