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

Commit 78513035 authored by Siarhei Vishniakou's avatar Siarhei Vishniakou
Browse files

Split NotifyArgs into a separate file 

This way, we can pass NotifyArgs without having to learn about
InputListener.

InputListener, however, knows how to route the args.

Bug: 211379801
Test: m libinputreader_arc
Change-Id: Idf653facd26348fb1ebdf48fb53cf004603587a1
parent 7b3b6095

services/inputflinger/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -139,6 +139,7 @@ filegroup { 
        "InputListener.cpp",

        "InputReaderBase.cpp",

        "InputThread.cpp",

        "NotifyArgs.cpp",

        "VibrationElement.cpp",

    ],

}

services/inputflinger/InputListener.cpp

+0 −200
Original line number Diff line number Diff line
@@ -31,206 +31,6 @@ using android::base::StringPrintf; 


namespace android {



// --- NotifyConfigurationChangedArgs ---



NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime)

      : id(id), eventTime(eventTime) {}



// --- NotifyKeyArgs ---



NotifyKeyArgs::NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,

                             uint32_t source, int32_t displayId, uint32_t policyFlags,

                             int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,

                             int32_t metaState, nsecs_t downTime)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        displayId(displayId),

        policyFlags(policyFlags),

        action(action),

        flags(flags),

        keyCode(keyCode),

        scanCode(scanCode),

        metaState(metaState),

        downTime(downTime),

        readTime(readTime) {}



// --- NotifyMotionArgs ---



NotifyMotionArgs::NotifyMotionArgs(

        int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, uint32_t source,

        int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton,

        int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification,

        int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties,

        const PointerCoords* pointerCoords, float xPrecision, float yPrecision,

        float xCursorPosition, float yCursorPosition, nsecs_t downTime,

        const std::vector<TouchVideoFrame>& videoFrames)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        displayId(displayId),

        policyFlags(policyFlags),

        action(action),

        actionButton(actionButton),

        flags(flags),

        metaState(metaState),

        buttonState(buttonState),

        classification(classification),

        edgeFlags(edgeFlags),

        pointerCount(pointerCount),

        xPrecision(xPrecision),

        yPrecision(yPrecision),

        xCursorPosition(xCursorPosition),

        yCursorPosition(yCursorPosition),

        downTime(downTime),

        readTime(readTime),

        videoFrames(videoFrames) {

    for (uint32_t i = 0; i < pointerCount; i++) {

        this->pointerProperties[i].copyFrom(pointerProperties[i]);

        this->pointerCoords[i].copyFrom(pointerCoords[i]);

    }

}



NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other)

      : id(other.id),

        eventTime(other.eventTime),

        deviceId(other.deviceId),

        source(other.source),

        displayId(other.displayId),

        policyFlags(other.policyFlags),

        action(other.action),

        actionButton(other.actionButton),

        flags(other.flags),

        metaState(other.metaState),

        buttonState(other.buttonState),

        classification(other.classification),

        edgeFlags(other.edgeFlags),

        pointerCount(other.pointerCount),

        xPrecision(other.xPrecision),

        yPrecision(other.yPrecision),

        xCursorPosition(other.xCursorPosition),

        yCursorPosition(other.yCursorPosition),

        downTime(other.downTime),

        readTime(other.readTime),

        videoFrames(other.videoFrames) {

    for (uint32_t i = 0; i < pointerCount; i++) {

        pointerProperties[i].copyFrom(other.pointerProperties[i]);

        pointerCoords[i].copyFrom(other.pointerCoords[i]);

    }

}



static inline bool isCursorPositionEqual(float lhs, float rhs) {

    return (isnan(lhs) && isnan(rhs)) || lhs == rhs;

}



bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const {

    bool equal = id == rhs.id && eventTime == rhs.eventTime && readTime == rhs.readTime &&

            deviceId == rhs.deviceId && source == rhs.source && displayId == rhs.displayId &&

            policyFlags == rhs.policyFlags && action == rhs.action &&

            actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState &&

            buttonState == rhs.buttonState && classification == rhs.classification &&

            edgeFlags == rhs.edgeFlags &&

            pointerCount == rhs.pointerCount

            // PointerProperties and PointerCoords are compared separately below

            && xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision &&

            isCursorPositionEqual(xCursorPosition, rhs.xCursorPosition) &&

            isCursorPositionEqual(yCursorPosition, rhs.yCursorPosition) &&

            downTime == rhs.downTime && videoFrames == rhs.videoFrames;

    if (!equal) {

        return false;

    }



    for (size_t i = 0; i < pointerCount; i++) {

        equal =

                pointerProperties[i] == rhs.pointerProperties[i]

                && pointerCoords[i] == rhs.pointerCoords[i];

        if (!equal) {

            return false;

        }

    }

    return true;

}



std::string NotifyMotionArgs::dump() const {

    std::string coords;

    for (uint32_t i = 0; i < pointerCount; i++) {

        if (!coords.empty()) {

            coords += ", ";

        }

        coords += StringPrintf("{%" PRIu32 ": ", i);

        coords +=

                StringPrintf("id=%" PRIu32 " x=%.1f y=%.1f pressure=%.1f", pointerProperties[i].id,

                             pointerCoords[i].getX(), pointerCoords[i].getY(),

                             pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));

        const int32_t toolType = pointerProperties[i].toolType;

        if (toolType != AMOTION_EVENT_TOOL_TYPE_FINGER) {

            coords += StringPrintf(" toolType=%s", motionToolTypeToString(toolType));

        }

        const float major = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR);

        const float minor = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR);

        const float orientation = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);

        if (major != 0 || minor != 0) {

            coords += StringPrintf(" major=%.1f minor=%.1f orientation=%.1f", major, minor,

                                   orientation);

        }

        coords += "}";

    }

    return StringPrintf("NotifyMotionArgs(id=%" PRId32 ", eventTime=%" PRId64 ", deviceId=%" PRId32

                        ", source=%s, action=%s, pointerCount=%" PRIu32

                        " pointers=%s, flags=0x%08x)",

                        id, eventTime, deviceId, inputEventSourceToString(source).c_str(),

                        MotionEvent::actionToString(action).c_str(), pointerCount, coords.c_str(),

                        flags);

}



// --- NotifySwitchArgs ---



NotifySwitchArgs::NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags,

                                   uint32_t switchValues, uint32_t switchMask)

      : id(id),

        eventTime(eventTime),

        policyFlags(policyFlags),

        switchValues(switchValues),

        switchMask(switchMask) {}



// --- NotifySensorArgs ---



NotifySensorArgs::NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,

                                   InputDeviceSensorType sensorType,

                                   InputDeviceSensorAccuracy accuracy, bool accuracyChanged,

                                   nsecs_t hwTimestamp, std::vector<float> values)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        sensorType(sensorType),

        accuracy(accuracy),

        accuracyChanged(accuracyChanged),

        hwTimestamp(hwTimestamp),

        values(std::move(values)) {}



// --- NotifyVibratorStateArgs ---



NotifyVibratorStateArgs::NotifyVibratorStateArgs(int32_t id, nsecs_t eventTime, int32_t deviceId,

                                                 bool isOn)

      : id(id), eventTime(eventTime), deviceId(deviceId), isOn(isOn) {}



NotifyVibratorStateArgs::NotifyVibratorStateArgs(const NotifyVibratorStateArgs& other)

      : id(other.id), eventTime(other.eventTime), deviceId(other.deviceId), isOn(other.isOn) {}



// --- NotifyDeviceResetArgs ---



NotifyDeviceResetArgs::NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId)

      : id(id), eventTime(eventTime), deviceId(deviceId) {}



// --- NotifyPointerCaptureChangedArgs ---



NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs(

        int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request)

      : id(id), eventTime(eventTime), request(request) {}



// --- InputListenerInterface ---



// Helper to std::visit with lambdas.

services/inputflinger/NotifyArgs.cpp

0 → 100644
+228 −0
Original line number Diff line number Diff line 
/*

 * Copyright (C) 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.

 */



#define LOG_TAG "NotifyArgs"



#define ATRACE_TAG ATRACE_TAG_INPUT



#include "NotifyArgs.h"



#include <android-base/stringprintf.h>

#include <android/log.h>

#include <math.h>

#include <utils/Trace.h>



using android::base::StringPrintf;



namespace android {



// --- NotifyConfigurationChangedArgs ---



NotifyConfigurationChangedArgs::NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime)

      : id(id), eventTime(eventTime) {}



// --- NotifyKeyArgs ---



NotifyKeyArgs::NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,

                             uint32_t source, int32_t displayId, uint32_t policyFlags,

                             int32_t action, int32_t flags, int32_t keyCode, int32_t scanCode,

                             int32_t metaState, nsecs_t downTime)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        displayId(displayId),

        policyFlags(policyFlags),

        action(action),

        flags(flags),

        keyCode(keyCode),

        scanCode(scanCode),

        metaState(metaState),

        downTime(downTime),

        readTime(readTime) {}



// --- NotifyMotionArgs ---



NotifyMotionArgs::NotifyMotionArgs(

        int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId, uint32_t source,

        int32_t displayId, uint32_t policyFlags, int32_t action, int32_t actionButton,

        int32_t flags, int32_t metaState, int32_t buttonState, MotionClassification classification,

        int32_t edgeFlags, uint32_t pointerCount, const PointerProperties* pointerProperties,

        const PointerCoords* pointerCoords, float xPrecision, float yPrecision,

        float xCursorPosition, float yCursorPosition, nsecs_t downTime,

        const std::vector<TouchVideoFrame>& videoFrames)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        displayId(displayId),

        policyFlags(policyFlags),

        action(action),

        actionButton(actionButton),

        flags(flags),

        metaState(metaState),

        buttonState(buttonState),

        classification(classification),

        edgeFlags(edgeFlags),

        pointerCount(pointerCount),

        xPrecision(xPrecision),

        yPrecision(yPrecision),

        xCursorPosition(xCursorPosition),

        yCursorPosition(yCursorPosition),

        downTime(downTime),

        readTime(readTime),

        videoFrames(videoFrames) {

    for (uint32_t i = 0; i < pointerCount; i++) {

        this->pointerProperties[i].copyFrom(pointerProperties[i]);

        this->pointerCoords[i].copyFrom(pointerCoords[i]);

    }

}



NotifyMotionArgs::NotifyMotionArgs(const NotifyMotionArgs& other)

      : id(other.id),

        eventTime(other.eventTime),

        deviceId(other.deviceId),

        source(other.source),

        displayId(other.displayId),

        policyFlags(other.policyFlags),

        action(other.action),

        actionButton(other.actionButton),

        flags(other.flags),

        metaState(other.metaState),

        buttonState(other.buttonState),

        classification(other.classification),

        edgeFlags(other.edgeFlags),

        pointerCount(other.pointerCount),

        xPrecision(other.xPrecision),

        yPrecision(other.yPrecision),

        xCursorPosition(other.xCursorPosition),

        yCursorPosition(other.yCursorPosition),

        downTime(other.downTime),

        readTime(other.readTime),

        videoFrames(other.videoFrames) {

    for (uint32_t i = 0; i < pointerCount; i++) {

        pointerProperties[i].copyFrom(other.pointerProperties[i]);

        pointerCoords[i].copyFrom(other.pointerCoords[i]);

    }

}



static inline bool isCursorPositionEqual(float lhs, float rhs) {

    return (isnan(lhs) && isnan(rhs)) || lhs == rhs;

}



bool NotifyMotionArgs::operator==(const NotifyMotionArgs& rhs) const {

    bool equal = id == rhs.id && eventTime == rhs.eventTime && readTime == rhs.readTime &&

            deviceId == rhs.deviceId && source == rhs.source && displayId == rhs.displayId &&

            policyFlags == rhs.policyFlags && action == rhs.action &&

            actionButton == rhs.actionButton && flags == rhs.flags && metaState == rhs.metaState &&

            buttonState == rhs.buttonState && classification == rhs.classification &&

            edgeFlags == rhs.edgeFlags &&

            pointerCount == rhs.pointerCount

            // PointerProperties and PointerCoords are compared separately below

            && xPrecision == rhs.xPrecision && yPrecision == rhs.yPrecision &&

            isCursorPositionEqual(xCursorPosition, rhs.xCursorPosition) &&

            isCursorPositionEqual(yCursorPosition, rhs.yCursorPosition) &&

            downTime == rhs.downTime && videoFrames == rhs.videoFrames;

    if (!equal) {

        return false;

    }



    for (size_t i = 0; i < pointerCount; i++) {

        equal = pointerProperties[i] == rhs.pointerProperties[i] &&

                pointerCoords[i] == rhs.pointerCoords[i];

        if (!equal) {

            return false;

        }

    }

    return true;

}



std::string NotifyMotionArgs::dump() const {

    std::string coords;

    for (uint32_t i = 0; i < pointerCount; i++) {

        if (!coords.empty()) {

            coords += ", ";

        }

        coords += StringPrintf("{%" PRIu32 ": ", i);

        coords +=

                StringPrintf("id=%" PRIu32 " x=%.1f y=%.1f pressure=%.1f", pointerProperties[i].id,

                             pointerCoords[i].getX(), pointerCoords[i].getY(),

                             pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_PRESSURE));

        const int32_t toolType = pointerProperties[i].toolType;

        if (toolType != AMOTION_EVENT_TOOL_TYPE_FINGER) {

            coords += StringPrintf(" toolType=%s", motionToolTypeToString(toolType));

        }

        const float major = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MAJOR);

        const float minor = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_TOUCH_MINOR);

        const float orientation = pointerCoords[i].getAxisValue(AMOTION_EVENT_AXIS_ORIENTATION);

        if (major != 0 || minor != 0) {

            coords += StringPrintf(" major=%.1f minor=%.1f orientation=%.1f", major, minor,

                                   orientation);

        }

        coords += "}";

    }

    return StringPrintf("NotifyMotionArgs(id=%" PRId32 ", eventTime=%" PRId64 ", deviceId=%" PRId32

                        ", source=%s, action=%s, pointerCount=%" PRIu32

                        " pointers=%s, flags=0x%08x)",

                        id, eventTime, deviceId, inputEventSourceToString(source).c_str(),

                        MotionEvent::actionToString(action).c_str(), pointerCount, coords.c_str(),

                        flags);

}



// --- NotifySwitchArgs ---



NotifySwitchArgs::NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags,

                                   uint32_t switchValues, uint32_t switchMask)

      : id(id),

        eventTime(eventTime),

        policyFlags(policyFlags),

        switchValues(switchValues),

        switchMask(switchMask) {}



// --- NotifySensorArgs ---



NotifySensorArgs::NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,

                                   InputDeviceSensorType sensorType,

                                   InputDeviceSensorAccuracy accuracy, bool accuracyChanged,

                                   nsecs_t hwTimestamp, std::vector<float> values)

      : id(id),

        eventTime(eventTime),

        deviceId(deviceId),

        source(source),

        sensorType(sensorType),

        accuracy(accuracy),

        accuracyChanged(accuracyChanged),

        hwTimestamp(hwTimestamp),

        values(std::move(values)) {}



// --- NotifyVibratorStateArgs ---



NotifyVibratorStateArgs::NotifyVibratorStateArgs(int32_t id, nsecs_t eventTime, int32_t deviceId,

                                                 bool isOn)

      : id(id), eventTime(eventTime), deviceId(deviceId), isOn(isOn) {}



// --- NotifyDeviceResetArgs ---



NotifyDeviceResetArgs::NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId)

      : id(id), eventTime(eventTime), deviceId(deviceId) {}



// --- NotifyPointerCaptureChangedArgs ---



NotifyPointerCaptureChangedArgs::NotifyPointerCaptureChangedArgs(

        int32_t id, nsecs_t eventTime, const PointerCaptureRequest& request)

      : id(id), eventTime(eventTime), request(request) {}



} // namespace android

services/inputflinger/include/InputListener.h

+1 −191
Original line number Diff line number Diff line
@@ -21,200 +21,10 @@ 
#include <input/Input.h>

#include <input/InputDevice.h>

#include <input/TouchVideoFrame.h>

#include "NotifyArgs.h"



namespace android {



class InputListenerInterface;



/* Describes a configuration change event. */

struct NotifyConfigurationChangedArgs {

    int32_t id;

    nsecs_t eventTime;



    inline NotifyConfigurationChangedArgs() { }



    NotifyConfigurationChangedArgs(int32_t id, nsecs_t eventTime);



    bool operator==(const NotifyConfigurationChangedArgs& rhs) const = default;



    NotifyConfigurationChangedArgs(const NotifyConfigurationChangedArgs& other) = default;

};



/* Describes a key event. */

struct NotifyKeyArgs {

    int32_t id;

    nsecs_t eventTime;



    int32_t deviceId;

    uint32_t source;

    int32_t displayId;

    uint32_t policyFlags;

    int32_t action;

    int32_t flags;

    int32_t keyCode;

    int32_t scanCode;

    int32_t metaState;

    nsecs_t downTime;

    nsecs_t readTime;



    inline NotifyKeyArgs() { }



    NotifyKeyArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,

                  uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action,

                  int32_t flags, int32_t keyCode, int32_t scanCode, int32_t metaState,

                  nsecs_t downTime);



    bool operator==(const NotifyKeyArgs& rhs) const = default;



    NotifyKeyArgs(const NotifyKeyArgs& other) = default;

};



/* Describes a motion event. */

struct NotifyMotionArgs {

    int32_t id;

    nsecs_t eventTime;



    int32_t deviceId;

    uint32_t source;

    int32_t displayId;

    uint32_t policyFlags;

    int32_t action;

    int32_t actionButton;

    int32_t flags;

    int32_t metaState;

    int32_t buttonState;

    /**

     * Classification of the current touch gesture

     */

    MotionClassification classification;

    int32_t edgeFlags;



    uint32_t pointerCount;

    PointerProperties pointerProperties[MAX_POINTERS];

    PointerCoords pointerCoords[MAX_POINTERS];

    float xPrecision;

    float yPrecision;

    /**

     * Mouse cursor position when this event is reported relative to the origin of the specified

     * display. Only valid if this is a mouse event (originates from a mouse or from a trackpad in

     * gestures enabled mode.

     */

    float xCursorPosition;

    float yCursorPosition;

    nsecs_t downTime;

    nsecs_t readTime;

    std::vector<TouchVideoFrame> videoFrames;



    inline NotifyMotionArgs() { }



    NotifyMotionArgs(int32_t id, nsecs_t eventTime, nsecs_t readTime, int32_t deviceId,

                     uint32_t source, int32_t displayId, uint32_t policyFlags, int32_t action,

                     int32_t actionButton, int32_t flags, int32_t metaState, int32_t buttonState,

                     MotionClassification classification, int32_t edgeFlags, uint32_t pointerCount,

                     const PointerProperties* pointerProperties, const PointerCoords* pointerCoords,

                     float xPrecision, float yPrecision, float xCursorPosition,

                     float yCursorPosition, nsecs_t downTime,

                     const std::vector<TouchVideoFrame>& videoFrames);



    NotifyMotionArgs(const NotifyMotionArgs& other);



    bool operator==(const NotifyMotionArgs& rhs) const;



    std::string dump() const;

};



/* Describes a sensor event. */

struct NotifySensorArgs {

    int32_t id;

    nsecs_t eventTime;



    int32_t deviceId;

    uint32_t source;

    InputDeviceSensorType sensorType;

    InputDeviceSensorAccuracy accuracy;

    bool accuracyChanged;

    nsecs_t hwTimestamp;

    std::vector<float> values;



    inline NotifySensorArgs() {}



    NotifySensorArgs(int32_t id, nsecs_t eventTime, int32_t deviceId, uint32_t source,

                     InputDeviceSensorType sensorType, InputDeviceSensorAccuracy accuracy,

                     bool accuracyChanged, nsecs_t hwTimestamp, std::vector<float> values);



    NotifySensorArgs(const NotifySensorArgs& other) = default;

};



/* Describes a switch event. */

struct NotifySwitchArgs {

    int32_t id;

    nsecs_t eventTime;



    uint32_t policyFlags;

    uint32_t switchValues;

    uint32_t switchMask;



    inline NotifySwitchArgs() { }



    NotifySwitchArgs(int32_t id, nsecs_t eventTime, uint32_t policyFlags, uint32_t switchValues,

                     uint32_t switchMask);



    NotifySwitchArgs(const NotifySwitchArgs& other) = default;



    bool operator==(const NotifySwitchArgs& rhs) const = default;

};



/* Describes a device reset event, such as when a device is added,

 * reconfigured, or removed. */

struct NotifyDeviceResetArgs {

    int32_t id;

    nsecs_t eventTime;



    int32_t deviceId;



    inline NotifyDeviceResetArgs() { }



    NotifyDeviceResetArgs(int32_t id, nsecs_t eventTime, int32_t deviceId);



    NotifyDeviceResetArgs(const NotifyDeviceResetArgs& other) = default;



    bool operator==(const NotifyDeviceResetArgs& rhs) const = default;

};



/* Describes a change in the state of Pointer Capture. */

struct NotifyPointerCaptureChangedArgs {

    // The sequence number of the Pointer Capture request, if enabled.

    int32_t id;

    nsecs_t eventTime;



    PointerCaptureRequest request;



    inline NotifyPointerCaptureChangedArgs() {}



    NotifyPointerCaptureChangedArgs(int32_t id, nsecs_t eventTime, const PointerCaptureRequest&);



    NotifyPointerCaptureChangedArgs(const NotifyPointerCaptureChangedArgs& other) = default;

};



/* Describes a vibrator state event. */

struct NotifyVibratorStateArgs {

    int32_t id;

    nsecs_t eventTime;



    int32_t deviceId;

    bool isOn;



    inline NotifyVibratorStateArgs() {}



    NotifyVibratorStateArgs(int32_t id, nsecs_t eventTIme, int32_t deviceId, bool isOn);



    NotifyVibratorStateArgs(const NotifyVibratorStateArgs& other);

};



using NotifyArgs = std::variant<NotifyConfigurationChangedArgs, NotifyKeyArgs, NotifyMotionArgs,

                                NotifySensorArgs, NotifySwitchArgs, NotifyDeviceResetArgs,

                                NotifyPointerCaptureChangedArgs, NotifyVibratorStateArgs>;



/*

 * The interface used by the InputReader to notify the InputListener about input events.

 */

services/inputflinger/include/NotifyArgs.h

0 → 100644
+216 −0

File added.

Preview size limit exceeded, changes collapsed.