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

Commit b1a00841 authored by Harry Cutts's avatar Harry Cutts
Browse files

Move methods from TouchCursorInputMapperCommon.h into a cpp file 

These methods are currently all used by two other files, but I want to
use one of them in TouchpadInputMapper.cpp. This means that I get
compilation errors saying the others are unused. Moving the method
definitions into a cpp file fixes this.

Bug: b/251196347
Test: builds without errors
Change-Id: Idc8b7bf2c8a1cb202e3122bcf5ff8552abbc9ca5
parent 30e8c3f1

services/inputflinger/reader/Android.bp

+1 −0
Original line number Diff line number Diff line
@@ -50,6 +50,7 @@ filegroup { 
        "mapper/SensorInputMapper.cpp",

        "mapper/SingleTouchInputMapper.cpp",

        "mapper/SwitchInputMapper.cpp",

        "mapper/TouchCursorInputMapperCommon.cpp",

        "mapper/TouchInputMapper.cpp",

        "mapper/TouchpadInputMapper.cpp",

        "mapper/VibratorInputMapper.cpp",

services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.cpp

0 → 100644
+127 −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.

 */



#include <input/DisplayViewport.h>

#include <stdint.h>

#include <ui/Rotation.h>



#include "EventHub.h"

#include "InputListener.h"

#include "InputReaderContext.h"



namespace android {



namespace {



[[nodiscard]] std::list<NotifyArgs> synthesizeButtonKey(

        InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime,

        int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,

        int32_t lastButtonState, int32_t currentButtonState, int32_t buttonState, int32_t keyCode) {

    std::list<NotifyArgs> out;

    if ((action == AKEY_EVENT_ACTION_DOWN && !(lastButtonState & buttonState) &&

         (currentButtonState & buttonState)) ||

        (action == AKEY_EVENT_ACTION_UP && (lastButtonState & buttonState) &&

         !(currentButtonState & buttonState))) {

        out.push_back(NotifyKeyArgs(context->getNextId(), when, readTime, deviceId, source,

                                    displayId, policyFlags, action, 0, keyCode, 0,

                                    context->getGlobalMetaState(), when));

    }

    return out;

}



} // namespace



ui::Rotation getInverseRotation(ui::Rotation orientation) {

    switch (orientation) {

        case ui::ROTATION_90:

            return ui::ROTATION_270;

        case ui::ROTATION_270:

            return ui::ROTATION_90;

        default:

            return orientation;

    }

}



void rotateDelta(ui::Rotation orientation, float* deltaX, float* deltaY) {

    float temp;

    switch (orientation) {

        case ui::ROTATION_90:

            temp = *deltaX;

            *deltaX = *deltaY;

            *deltaY = -temp;

            break;



        case ui::ROTATION_180:

            *deltaX = -*deltaX;

            *deltaY = -*deltaY;

            break;



        case ui::ROTATION_270:

            temp = *deltaX;

            *deltaX = -*deltaY;

            *deltaY = temp;

            break;



        default:

            break;

    }

}



bool isPointerDown(int32_t buttonState) {

    return buttonState &

            (AMOTION_EVENT_BUTTON_PRIMARY | AMOTION_EVENT_BUTTON_SECONDARY |

             AMOTION_EVENT_BUTTON_TERTIARY);

}



[[nodiscard]] std::list<NotifyArgs> synthesizeButtonKeys(

        InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime,

        int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,

        int32_t lastButtonState, int32_t currentButtonState) {

    std::list<NotifyArgs> out;

    out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId,

                               policyFlags, lastButtonState, currentButtonState,

                               AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK);

    out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId,

                               policyFlags, lastButtonState, currentButtonState,

                               AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD);

    return out;

}



std::tuple<nsecs_t /*eventTime*/, nsecs_t /*readTime*/> applyBluetoothTimestampSmoothening(

        const InputDeviceIdentifier& identifier, nsecs_t currentEventTime, nsecs_t readTime,

        nsecs_t lastEventTime) {

    if (identifier.bus != BUS_BLUETOOTH) {

        return {currentEventTime, readTime};

    }



    // Assume the fastest rate at which a Bluetooth touch device can report input events is one

    // every 4 milliseconds, or 250 Hz. Timestamps for successive events from a Bluetooth device

    // will be separated by at least this amount.

    constexpr static nsecs_t MIN_BLUETOOTH_TIMESTAMP_DELTA = ms2ns(4);

    // We define a maximum smoothing time delta so that we don't generate events too far into the

    // future.

    constexpr static nsecs_t MAX_BLUETOOTH_SMOOTHING_DELTA = ms2ns(32);

    const nsecs_t smoothenedEventTime =

            std::min(std::max(currentEventTime, lastEventTime + MIN_BLUETOOTH_TIMESTAMP_DELTA),

                     currentEventTime + MAX_BLUETOOTH_SMOOTHING_DELTA);

    // If we are modifying the event time, treat this event as a synthetically generated event for

    // latency tracking purposes and use the event time as the read time (zero read latency).

    const nsecs_t smoothenedReadTime =

            smoothenedEventTime != currentEventTime ? currentEventTime : readTime;

    return {smoothenedEventTime, smoothenedReadTime};

}



} // namespace android

services/inputflinger/reader/mapper/TouchCursorInputMapperCommon.h

+7 −90
Original line number Diff line number Diff line
@@ -26,81 +26,18 @@ 


namespace android {



// --- Static Definitions ---

ui::Rotation getInverseRotation(ui::Rotation orientation);



static ui::Rotation getInverseRotation(ui::Rotation orientation) {

    switch (orientation) {

        case ui::ROTATION_90:

            return ui::ROTATION_270;

        case ui::ROTATION_270:

            return ui::ROTATION_90;

        default:

            return orientation;

    }

}



static void rotateDelta(ui::Rotation orientation, float* deltaX, float* deltaY) {

    float temp;

    switch (orientation) {

        case ui::ROTATION_90:

            temp = *deltaX;

            *deltaX = *deltaY;

            *deltaY = -temp;

            break;



        case ui::ROTATION_180:

            *deltaX = -*deltaX;

            *deltaY = -*deltaY;

            break;



        case ui::ROTATION_270:

            temp = *deltaX;

            *deltaX = -*deltaY;

            *deltaY = temp;

            break;



        default:

            break;

    }

}

void rotateDelta(ui::Rotation orientation, float* deltaX, float* deltaY);



// Returns true if the pointer should be reported as being down given the specified

// button states.  This determines whether the event is reported as a touch event.

static bool isPointerDown(int32_t buttonState) {

    return buttonState &

            (AMOTION_EVENT_BUTTON_PRIMARY | AMOTION_EVENT_BUTTON_SECONDARY |

             AMOTION_EVENT_BUTTON_TERTIARY);

}

bool isPointerDown(int32_t buttonState);



[[nodiscard]] static std::list<NotifyArgs> synthesizeButtonKey(

[[nodiscard]] std::list<NotifyArgs> synthesizeButtonKeys(

        InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime,

        int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,

        int32_t lastButtonState, int32_t currentButtonState, int32_t buttonState, int32_t keyCode) {

    std::list<NotifyArgs> out;

    if ((action == AKEY_EVENT_ACTION_DOWN && !(lastButtonState & buttonState) &&

         (currentButtonState & buttonState)) ||

        (action == AKEY_EVENT_ACTION_UP && (lastButtonState & buttonState) &&

         !(currentButtonState & buttonState))) {

        out.push_back(NotifyKeyArgs(context->getNextId(), when, readTime, deviceId, source,

                                    displayId, policyFlags, action, 0, keyCode, 0,

                                    context->getGlobalMetaState(), when));

    }

    return out;

}



[[nodiscard]] static std::list<NotifyArgs> synthesizeButtonKeys(

        InputReaderContext* context, int32_t action, nsecs_t when, nsecs_t readTime,

        int32_t deviceId, uint32_t source, int32_t displayId, uint32_t policyFlags,

        int32_t lastButtonState, int32_t currentButtonState) {

    std::list<NotifyArgs> out;

    out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId,

                               policyFlags, lastButtonState, currentButtonState,

                               AMOTION_EVENT_BUTTON_BACK, AKEYCODE_BACK);

    out += synthesizeButtonKey(context, action, when, readTime, deviceId, source, displayId,

                               policyFlags, lastButtonState, currentButtonState,

                               AMOTION_EVENT_BUTTON_FORWARD, AKEYCODE_FORWARD);

    return out;

}

        int32_t lastButtonState, int32_t currentButtonState);



// For devices connected over Bluetooth, although they may produce events at a consistent rate,

// the events might end up reaching Android in a "batched" manner through the Bluetooth
@@ -111,28 +48,8 @@ static bool isPointerDown(int32_t buttonState) { 
// coordinates result in extremely large instantaneous velocities, which can negatively impact

// user experience. To avoid this, we augment the timestamps so that subsequent event timestamps

// differ by at least a minimum delta value.

static std::tuple<nsecs_t /*eventTime*/, nsecs_t /*readTime*/> applyBluetoothTimestampSmoothening(

std::tuple<nsecs_t /*eventTime*/, nsecs_t /*readTime*/> applyBluetoothTimestampSmoothening(

        const InputDeviceIdentifier& identifier, nsecs_t currentEventTime, nsecs_t readTime,

        nsecs_t lastEventTime) {

    if (identifier.bus != BUS_BLUETOOTH) {

        return {currentEventTime, readTime};

    }



    // Assume the fastest rate at which a Bluetooth touch device can report input events is one

    // every 4 milliseconds, or 250 Hz. Timestamps for successive events from a Bluetooth device

    // will be separated by at least this amount.

    constexpr static nsecs_t MIN_BLUETOOTH_TIMESTAMP_DELTA = ms2ns(4);

    // We define a maximum smoothing time delta so that we don't generate events too far into the

    // future.

    constexpr static nsecs_t MAX_BLUETOOTH_SMOOTHING_DELTA = ms2ns(32);

    const nsecs_t smoothenedEventTime =

            std::min(std::max(currentEventTime, lastEventTime + MIN_BLUETOOTH_TIMESTAMP_DELTA),

                     currentEventTime + MAX_BLUETOOTH_SMOOTHING_DELTA);

    // If we are modifying the event time, treat this event as a synthetically generated event for

    // latency tracking purposes and use the event time as the read time (zero read latency).

    const nsecs_t smoothenedReadTime =

            smoothenedEventTime != currentEventTime ? currentEventTime : readTime;

    return {smoothenedEventTime, smoothenedReadTime};

}

        nsecs_t lastEventTime);



} // namespace android