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

Commit 53a7fc36 authored by The Android Automerger's avatar The Android Automerger
Browse files

Merge branch 'master' into honeycomb-release

parents 7de80c22 39c1bb19

include/ui/InputDispatcher.h

+10 −2
Original line number Diff line number Diff line
@@ -304,6 +304,10 @@ public: 
    virtual bool interceptKeyBeforeDispatching(const sp<InputChannel>& inputChannel,

            const KeyEvent* keyEvent, uint32_t policyFlags) = 0;



    /* Allows the policy a chance to perform default processing for an unhandled key. */

    virtual bool dispatchUnhandledKey(const sp<InputChannel>& inputChannel,

            const KeyEvent* keyEvent, uint32_t policyFlags) = 0;



    /* Notifies the policy about switch events.

     */

    virtual void notifySwitch(nsecs_t when,
@@ -609,6 +613,7 @@ private: 
        sp<InputChannel> inputChannel;

        sp<InputApplicationHandle> inputApplicationHandle;

        int32_t userActivityEventType;

        bool handled;

    };



    // Generic queue implementation.
@@ -1030,7 +1035,8 @@ private: 
            EventEntry* eventEntry, const InputTarget* inputTarget,

            bool resumeWithAppendedMotionSample);

    void startDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);

    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);

    void finishDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection,

            bool handled);

    void startNextDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);

    void abortBrokenDispatchCycleLocked(nsecs_t currentTime, const sp<Connection>& connection);

    void drainOutboundQueueLocked(Connection* connection);
@@ -1061,7 +1067,7 @@ private: 
    void onDispatchCycleStartedLocked(

            nsecs_t currentTime, const sp<Connection>& connection);

    void onDispatchCycleFinishedLocked(

            nsecs_t currentTime, const sp<Connection>& connection);

            nsecs_t currentTime, const sp<Connection>& connection, bool handled);

    void onDispatchCycleBrokenLocked(

            nsecs_t currentTime, const sp<Connection>& connection);

    void onANRLocked(
@@ -1073,7 +1079,9 @@ private: 
    void doNotifyInputChannelBrokenLockedInterruptible(CommandEntry* commandEntry);

    void doNotifyANRLockedInterruptible(CommandEntry* commandEntry);

    void doInterceptKeyBeforeDispatchingLockedInterruptible(CommandEntry* commandEntry);

    void doDispatchCycleFinishedLockedInterruptible(CommandEntry* commandEntry);

    void doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry);

    void initializeKeyEvent(KeyEvent* event, const KeyEntry* entry);



    // Statistics gathering.

    void updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,

include/ui/InputTransport.h

+4 −3
Original line number Diff line number Diff line
@@ -250,12 +250,13 @@ public: 
    status_t sendDispatchSignal();



    /* Receives the finished signal from the consumer in reply to the original dispatch signal.

     * Returns whether the consumer handled the message.

     *

     * Returns OK on success.

     * Returns WOULD_BLOCK if there is no signal present.

     * Other errors probably indicate that the channel is broken.

     */

    status_t receiveFinishedSignal();

    status_t receiveFinishedSignal(bool& outHandled);



private:

    sp<InputChannel> mChannel;
@@ -305,12 +306,12 @@ public: 
    status_t consume(InputEventFactoryInterface* factory, InputEvent** outEvent);



    /* Sends a finished signal to the publisher to inform it that the current message is

     * finished processing.

     * finished processing and specifies whether the message was handled by the consumer.

     *

     * Returns OK on success.

     * Errors probably indicate that the channel is broken.

     */

    status_t sendFinishedSignal();

    status_t sendFinishedSignal(bool handled);



    /* Receives the dispatched signal from the publisher.

     *

include/ui/PowerManager.h

+3 −7
Original line number Diff line number Diff line
@@ -22,14 +22,10 @@ namespace android { 


enum {

    POWER_MANAGER_OTHER_EVENT = 0,

    POWER_MANAGER_CHEEK_EVENT = 1,

    POWER_MANAGER_TOUCH_EVENT = 2, // touch events are TOUCH for 300ms, and then either

                                   // up events or LONG_TOUCH events.

    POWER_MANAGER_LONG_TOUCH_EVENT = 3,

    POWER_MANAGER_TOUCH_UP_EVENT = 4,

    POWER_MANAGER_BUTTON_EVENT = 5, // Button and trackball events.

    POWER_MANAGER_BUTTON_EVENT = 1,

    POWER_MANAGER_TOUCH_EVENT = 2,



    POWER_MANAGER_LAST_EVENT = POWER_MANAGER_BUTTON_EVENT, // Last valid event code.

    POWER_MANAGER_LAST_EVENT = POWER_MANAGER_TOUCH_EVENT, // Last valid event code.

};



} // namespace android

libs/ui/InputDispatcher.cpp

+47 −31
Original line number Diff line number Diff line
@@ -51,9 +51,6 @@ 


namespace android {



// Delay before reporting long touch events to the power manager.

const nsecs_t LONG_TOUCH_DELAY = 300 * 1000000LL; // 300 ms



// Default input dispatching timeout if there is no focused application or paused window

// from which to determine an appropriate dispatching timeout.

const nsecs_t DEFAULT_INPUT_DISPATCHING_TIMEOUT = 5000 * 1000000LL; // 5 sec
@@ -1416,21 +1413,7 @@ void InputDispatcher::pokeUserActivityLocked(const EventEntry* eventEntry) { 
        }



        if (motionEntry->source & AINPUT_SOURCE_CLASS_POINTER) {

            switch (motionEntry->action) {

            case AMOTION_EVENT_ACTION_DOWN:

                eventType = POWER_MANAGER_TOUCH_EVENT;

                break;

            case AMOTION_EVENT_ACTION_UP:

                eventType = POWER_MANAGER_TOUCH_UP_EVENT;

                break;

            default:

                if (motionEntry->eventTime - motionEntry->downTime < LONG_TOUCH_DELAY) {

            eventType = POWER_MANAGER_TOUCH_EVENT;

                } else {

                    eventType = POWER_MANAGER_LONG_TOUCH_EVENT;

                }

                break;

            }

        }

        break;

    }
@@ -1770,13 +1753,14 @@ void InputDispatcher::startDispatchCycleLocked(nsecs_t currentTime, 
}



void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime,

        const sp<Connection>& connection) {

        const sp<Connection>& connection, bool handled) {

#if DEBUG_DISPATCH_CYCLE

    LOGD("channel '%s' ~ finishDispatchCycle - %01.1fms since event, "

            "%01.1fms since dispatch",

            "%01.1fms since dispatch, handled=%s",

            connection->getInputChannelName(),

            connection->getEventLatencyMillis(currentTime),

            connection->getDispatchLatencyMillis(currentTime));

            connection->getDispatchLatencyMillis(currentTime),

            toString(handled));

#endif



    if (connection->status == Connection::STATUS_BROKEN
@@ -1784,9 +1768,6 @@ void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime, 
        return;

    }



    // Notify other system components.

    onDispatchCycleFinishedLocked(currentTime, connection);



    // Reset the publisher since the event has been consumed.

    // We do this now so that the publisher can release some of its internal resources

    // while waiting for the next dispatch cycle to begin.
@@ -1798,7 +1779,8 @@ void InputDispatcher::finishDispatchCycleLocked(nsecs_t currentTime, 
        return;

    }



    startNextDispatchCycleLocked(currentTime, connection);

    // Notify other system components and prepare to start the next dispatch cycle.

    onDispatchCycleFinishedLocked(currentTime, connection, handled);

}



void InputDispatcher::startNextDispatchCycleLocked(nsecs_t currentTime,
@@ -1898,7 +1880,8 @@ int InputDispatcher::handleReceiveCallback(int receiveFd, int events, void* data 
            return 1;

        }



        status_t status = connection->inputPublisher.receiveFinishedSignal();

        bool handled = false;

        status_t status = connection->inputPublisher.receiveFinishedSignal(handled);

        if (status) {

            LOGE("channel '%s' ~ Failed to receive finished signal.  status=%d",

                    connection->getInputChannelName(), status);
@@ -1907,7 +1890,7 @@ int InputDispatcher::handleReceiveCallback(int receiveFd, int events, void* data 
            return 0; // remove the callback

        }



        d->finishDispatchCycleLocked(currentTime, connection);

        d->finishDispatchCycleLocked(currentTime, connection, handled);

        d->runCommandsLockedInterruptible();

        return 1;

    } // release lock
@@ -2945,7 +2928,11 @@ void InputDispatcher::onDispatchCycleStartedLocked( 
}



void InputDispatcher::onDispatchCycleFinishedLocked(

        nsecs_t currentTime, const sp<Connection>& connection) {

        nsecs_t currentTime, const sp<Connection>& connection, bool handled) {

    CommandEntry* commandEntry = postCommandLocked(

            & InputDispatcher::doDispatchCycleFinishedLockedInterruptible);

    commandEntry->connection = connection;

    commandEntry->handled = handled;

}



void InputDispatcher::onDispatchCycleBrokenLocked(
@@ -3014,9 +3001,7 @@ void InputDispatcher::doNotifyANRLockedInterruptible( 
void InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible(

        CommandEntry* commandEntry) {

    KeyEntry* entry = commandEntry->keyEntry;

    mReusableKeyEvent.initialize(entry->deviceId, entry->source, entry->action, entry->flags,

            entry->keyCode, entry->scanCode, entry->metaState, entry->repeatCount,

            entry->downTime, entry->eventTime);

    initializeKeyEvent(&mReusableKeyEvent, entry);



    mLock.unlock();
@@ -3031,6 +3016,31 @@ void InputDispatcher::doInterceptKeyBeforeDispatchingLockedInterruptible( 
    mAllocator.releaseKeyEntry(entry);

}



void InputDispatcher::doDispatchCycleFinishedLockedInterruptible(

        CommandEntry* commandEntry) {

    sp<Connection> connection = commandEntry->connection;

    bool handled = commandEntry->handled;



    if (!handled && !connection->outboundQueue.isEmpty()) {

        DispatchEntry* dispatchEntry = connection->outboundQueue.headSentinel.next;

        if (dispatchEntry->inProgress

                && dispatchEntry->hasForegroundTarget()

                && dispatchEntry->eventEntry->type == EventEntry::TYPE_KEY) {

            KeyEntry* keyEntry = static_cast<KeyEntry*>(dispatchEntry->eventEntry);

            initializeKeyEvent(&mReusableKeyEvent, keyEntry);



            mLock.unlock();



            mPolicy->dispatchUnhandledKey(connection->inputChannel,

                    & mReusableKeyEvent, keyEntry->policyFlags);



            mLock.lock();

        }

    }



    startNextDispatchCycleLocked(now(), connection);

}



void InputDispatcher::doPokeUserActivityLockedInterruptible(CommandEntry* commandEntry) {

    mLock.unlock();
@@ -3039,6 +3049,12 @@ void InputDispatcher::doPokeUserActivityLockedInterruptible(CommandEntry* comman 
    mLock.lock();

}



void InputDispatcher::initializeKeyEvent(KeyEvent* event, const KeyEntry* entry) {

    event->initialize(entry->deviceId, entry->source, entry->action, entry->flags,

            entry->keyCode, entry->scanCode, entry->metaState, entry->repeatCount,

            entry->downTime, entry->eventTime);

}



void InputDispatcher::updateDispatchStatisticsLocked(nsecs_t currentTime, const EventEntry* entry,

        int32_t injectionResult, nsecs_t timeSpentWaitingForApplication) {

    // TODO Write some statistics about how long we spend waiting.

libs/ui/InputTransport.cpp

+19 −8
Original line number Diff line number Diff line
@@ -35,8 +35,12 @@ static const int DEFAULT_MESSAGE_BUFFER_SIZE = 16384; 
static const char INPUT_SIGNAL_DISPATCH = 'D';



// Signal sent by the consumer to the producer to inform it that it has finished

// consuming the most recent message.

static const char INPUT_SIGNAL_FINISHED = 'f';

// consuming the most recent message and it handled it.

static const char INPUT_SIGNAL_FINISHED_HANDLED = 'f';



// Signal sent by the consumer to the producer to inform it that it has finished

// consuming the most recent message but it did not handle it.

static const char INPUT_SIGNAL_FINISHED_UNHANDLED = 'u';





// --- InputChannel ---
@@ -497,7 +501,7 @@ status_t InputPublisher::sendDispatchSignal() { 
    return mChannel->sendSignal(INPUT_SIGNAL_DISPATCH);

}



status_t InputPublisher::receiveFinishedSignal() {

status_t InputPublisher::receiveFinishedSignal(bool& outHandled) {

#if DEBUG_TRANSPORT_ACTIONS

    LOGD("channel '%s' publisher ~ receiveFinishedSignal",

            mChannel->getName().string());
@@ -506,9 +510,14 @@ status_t InputPublisher::receiveFinishedSignal() { 
    char signal;

    status_t result = mChannel->receiveSignal(& signal);

    if (result) {

        outHandled = false;

        return result;

    }

    if (signal != INPUT_SIGNAL_FINISHED) {

    if (signal == INPUT_SIGNAL_FINISHED_HANDLED) {

        outHandled = true;

    } else if (signal == INPUT_SIGNAL_FINISHED_UNHANDLED) {

        outHandled = false;

    } else {

        LOGE("channel '%s' publisher ~ Received unexpected signal '%c' from consumer",

                mChannel->getName().string(), signal);

        return UNKNOWN_ERROR;
@@ -626,13 +635,15 @@ status_t InputConsumer::consume(InputEventFactoryInterface* factory, InputEvent* 
    return OK;

}



status_t InputConsumer::sendFinishedSignal() {

status_t InputConsumer::sendFinishedSignal(bool handled) {

#if DEBUG_TRANSPORT_ACTIONS

    LOGD("channel '%s' consumer ~ sendFinishedSignal",

            mChannel->getName().string());

    LOGD("channel '%s' consumer ~ sendFinishedSignal: handled=%d",

            mChannel->getName().string(), handled);

#endif



    return mChannel->sendSignal(INPUT_SIGNAL_FINISHED);

    return mChannel->sendSignal(handled

            ? INPUT_SIGNAL_FINISHED_HANDLED

            : INPUT_SIGNAL_FINISHED_UNHANDLED);

}



status_t InputConsumer::receiveDispatchSignal() {