Donate to e Foundation | Murena handsets with /e/OS | Own a part of Murena! Learn more

Commit dd8b2eed authored by TreeHugger Robot's avatar TreeHugger Robot Committed by Android (Google) Code Review
Browse files

Merge "Add SensorManager support in inputflinger."

parents 1104d392 f59a2f48

include/android/input.h

+2 −0
Original line number Diff line number Diff line
@@ -856,6 +856,8 @@ enum { 
    AINPUT_SOURCE_TOUCH_NAVIGATION = 0x00200000 | AINPUT_SOURCE_CLASS_NONE,

    /** joystick */

    AINPUT_SOURCE_JOYSTICK = 0x01000000 | AINPUT_SOURCE_CLASS_JOYSTICK,

    /** sensor */

    AINPUT_SOURCE_SENSOR = 0x02000000 | AINPUT_SOURCE_CLASS_JOYSTICK,

    /** rotary encoder */

    AINPUT_SOURCE_ROTARY_ENCODER = 0x00400000 | AINPUT_SOURCE_CLASS_NONE,

include/input/InputDevice.h

+103 −0
Original line number Diff line number Diff line
@@ -17,8 +17,10 @@ 
#ifndef _LIBINPUT_INPUT_DEVICE_H

#define _LIBINPUT_INPUT_DEVICE_H



#include <android/sensor.h>

#include <input/Input.h>

#include <input/KeyCharacterMap.h>

#include <unordered_map>

#include <vector>



namespace android {
@@ -63,6 +65,97 @@ struct InputDeviceIdentifier { 
    std::string getCanonicalName() const;

};



/* Types of input device sensors. Keep sync with core/java/android/hardware/Sensor.java */

enum class InputDeviceSensorType : int32_t {

    ACCELEROMETER = ASENSOR_TYPE_ACCELEROMETER,

    MAGNETIC_FIELD = ASENSOR_TYPE_MAGNETIC_FIELD,

    ORIENTATION = 3,

    GYROSCOPE = ASENSOR_TYPE_GYROSCOPE,

    LIGHT = ASENSOR_TYPE_LIGHT,

    PRESSURE = ASENSOR_TYPE_PRESSURE,

    TEMPERATURE = 7,

    PROXIMITY = ASENSOR_TYPE_PROXIMITY,

    GRAVITY = ASENSOR_TYPE_GRAVITY,

    LINEAR_ACCELERATION = ASENSOR_TYPE_LINEAR_ACCELERATION,

    ROTATION_VECTOR = ASENSOR_TYPE_ROTATION_VECTOR,

    RELATIVE_HUMIDITY = ASENSOR_TYPE_RELATIVE_HUMIDITY,

    AMBIENT_TEMPERATURE = ASENSOR_TYPE_AMBIENT_TEMPERATURE,

    MAGNETIC_FIELD_UNCALIBRATED = ASENSOR_TYPE_MAGNETIC_FIELD_UNCALIBRATED,

    GAME_ROTATION_VECTOR = ASENSOR_TYPE_GAME_ROTATION_VECTOR,

    GYROSCOPE_UNCALIBRATED = ASENSOR_TYPE_GYROSCOPE_UNCALIBRATED,

    SIGNIFICANT_MOTION = ASENSOR_TYPE_SIGNIFICANT_MOTION,

};



enum class InputDeviceSensorAccuracy : int32_t {

    ACCURACY_NONE = 0,

    ACCURACY_LOW = 1,

    ACCURACY_MEDIUM = 2,

    ACCURACY_HIGH = 3,

};



enum class InputDeviceSensorReportingMode : int32_t {

    CONTINUOUS = 0,

    ON_CHANGE = 1,

    ONE_SHOT = 2,

    SPECIAL_TRIGGER = 3,

};



struct InputDeviceSensorInfo {

    explicit InputDeviceSensorInfo(std::string name, std::string vendor, int32_t version,

                                   InputDeviceSensorType type, InputDeviceSensorAccuracy accuracy,

                                   float maxRange, float resolution, float power, int32_t minDelay,

                                   int32_t fifoReservedEventCount, int32_t fifoMaxEventCount,

                                   std::string stringType, int32_t maxDelay, int32_t flags,

                                   int32_t id)

          : name(name),

            vendor(vendor),

            version(version),

            type(type),

            accuracy(accuracy),

            maxRange(maxRange),

            resolution(resolution),

            power(power),

            minDelay(minDelay),

            fifoReservedEventCount(fifoReservedEventCount),

            fifoMaxEventCount(fifoMaxEventCount),

            stringType(stringType),

            maxDelay(maxDelay),

            flags(flags),

            id(id) {}

    // Name string of the sensor.

    std::string name;

    // Vendor string of this sensor.

    std::string vendor;

    // Version of the sensor's module.

    int32_t version;

    // Generic type of this sensor.

    InputDeviceSensorType type;

    // The current accuracy of sensor event.

    InputDeviceSensorAccuracy accuracy;

    // Maximum range of the sensor in the sensor's unit.

    float maxRange;

    // Resolution of the sensor in the sensor's unit.

    float resolution;

    // The power in mA used by this sensor while in use.

    float power;

    // The minimum delay allowed between two events in microsecond or zero if this sensor only

    // returns a value when the data it's measuring changes.

    int32_t minDelay;

    // Number of events reserved for this sensor in the batch mode FIFO.

    int32_t fifoReservedEventCount;

    // Maximum number of events of this sensor that could be batched.

    int32_t fifoMaxEventCount;

    // The type of this sensor as a string.

    std::string stringType;

    // The delay between two sensor events corresponding to the lowest frequency that this sensor

    // supports.

    int32_t maxDelay;

    // Sensor flags

    int32_t flags;

    // Sensor id, same as the input device ID it belongs to.

    int32_t id;

};



/*

 * Describes the characteristics and capabilities of an input device.

 */
@@ -104,6 +197,7 @@ public: 
    void addMotionRange(int32_t axis, uint32_t source,

            float min, float max, float flat, float fuzz, float resolution);

    void addMotionRange(const MotionRange& range);

    void addSensorInfo(const InputDeviceSensorInfo& info);



    inline void setKeyboardType(int32_t keyboardType) { mKeyboardType = keyboardType; }

    inline int32_t getKeyboardType() const { return mKeyboardType; }
@@ -122,10 +216,17 @@ public: 
    inline void setButtonUnderPad(bool hasButton) { mHasButtonUnderPad = hasButton; }

    inline bool hasButtonUnderPad() const { return mHasButtonUnderPad; }



    inline void setHasSensor(bool hasSensor) { mHasSensor = hasSensor; }

    inline bool hasSensor() const { return mHasSensor; }



    inline const std::vector<MotionRange>& getMotionRanges() const {

        return mMotionRanges;

    }



    const InputDeviceSensorInfo* getSensorInfo(InputDeviceSensorType type);



    const std::vector<InputDeviceSensorType> getSensorTypes();



private:

    int32_t mId;

    int32_t mGeneration;
@@ -139,8 +240,10 @@ private: 
    std::shared_ptr<KeyCharacterMap> mKeyCharacterMap;

    bool mHasVibrator;

    bool mHasButtonUnderPad;

    bool mHasSensor;



    std::vector<MotionRange> mMotionRanges;

    std::unordered_map<InputDeviceSensorType, InputDeviceSensorInfo> mSensors;

};



/* Types of input device configuration files. */

include/input/KeyCharacterMap.h

+2 −0
Original line number Diff line number Diff line
@@ -142,6 +142,8 @@ public: 
    void writeToParcel(Parcel* parcel) const;

#endif



    bool operator==(const KeyCharacterMap& other) const;



    KeyCharacterMap(const KeyCharacterMap& other);



    virtual ~KeyCharacterMap();

include/input/KeyLayoutMap.h

+10 −0
Original line number Diff line number Diff line
@@ -24,6 +24,8 @@ 
#include <utils/RefBase.h>

#include <utils/Tokenizer.h>



#include <input/InputDevice.h>



namespace android {



struct AxisInfo {
@@ -76,6 +78,8 @@ public: 


    status_t mapAxis(int32_t scanCode, AxisInfo* outAxisInfo) const;

    const std::string getLoadFileName() const;

    // Return pair of sensor type and sensor data index, for the input device abs code

    base::Result<std::pair<InputDeviceSensorType, int32_t>> mapSensor(int32_t absCode);



    virtual ~KeyLayoutMap();
@@ -89,12 +93,17 @@ private: 
        int32_t ledCode;

    };



    struct Sensor {

        InputDeviceSensorType sensorType;

        int32_t sensorDataIndex;

    };



    KeyedVector<int32_t, Key> mKeysByScanCode;

    KeyedVector<int32_t, Key> mKeysByUsageCode;

    KeyedVector<int32_t, AxisInfo> mAxes;

    KeyedVector<int32_t, Led> mLedsByScanCode;

    KeyedVector<int32_t, Led> mLedsByUsageCode;

    std::unordered_map<int32_t, Sensor> mSensorsByAbsCode;

    std::string mLoadFileName;



    KeyLayoutMap();
@@ -114,6 +123,7 @@ private: 
        status_t parseKey();

        status_t parseAxis();

        status_t parseLed();

        status_t parseSensor();

    };

};

libs/input/InputDevice.cpp

+30 −1
Original line number Diff line number Diff line
@@ -23,6 +23,7 @@ 
#include <android-base/stringprintf.h>

#include <input/InputDevice.h>

#include <input/InputEventLabels.h>

#include <input/NamedEnum.h>



using android::base::StringPrintf;
@@ -166,7 +167,9 @@ InputDeviceInfo::InputDeviceInfo(const InputDeviceInfo& other) 
        mKeyCharacterMap(other.mKeyCharacterMap),

        mHasVibrator(other.mHasVibrator),

        mHasButtonUnderPad(other.mHasButtonUnderPad),

        mMotionRanges(other.mMotionRanges) {}

        mHasSensor(other.mHasSensor),

        mMotionRanges(other.mMotionRanges),

        mSensors(other.mSensors) {}



InputDeviceInfo::~InputDeviceInfo() {

}
@@ -185,7 +188,9 @@ void InputDeviceInfo::initialize(int32_t id, int32_t generation, int32_t control 
    mKeyboardType = AINPUT_KEYBOARD_TYPE_NONE;

    mHasVibrator = false;

    mHasButtonUnderPad = false;

    mHasSensor = false;

    mMotionRanges.clear();

    mSensors.clear();

}



const InputDeviceInfo::MotionRange* InputDeviceInfo::getMotionRange(
@@ -214,4 +219,28 @@ void InputDeviceInfo::addMotionRange(const MotionRange& range) { 
    mMotionRanges.push_back(range);

}



void InputDeviceInfo::addSensorInfo(const InputDeviceSensorInfo& info) {

    if (mSensors.find(info.type) != mSensors.end()) {

        ALOGW("Sensor type %s already exists, will be replaced by new sensor added.",

              NamedEnum::string(info.type).c_str());

    }

    mSensors.insert_or_assign(info.type, info);

}



const std::vector<InputDeviceSensorType> InputDeviceInfo::getSensorTypes() {

    std::vector<InputDeviceSensorType> types;

    for (const auto& [type, info] : mSensors) {

        types.push_back(type);

    }

    return types;

}



const InputDeviceSensorInfo* InputDeviceInfo::getSensorInfo(InputDeviceSensorType type) {

    auto it = mSensors.find(type);

    if (it == mSensors.end()) {

        return nullptr;

    }

    return &it->second;

}



} // namespace android