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

Commit 46b9ac0a authored by Jeff Brown's avatar Jeff Brown
Browse files

Native input dispatch rewrite work in progress. 

The old dispatch mechanism has been left in place and continues to
be used by default for now.  To enable native input dispatch,
edit the ENABLE_NATIVE_DISPATCH constant in WindowManagerPolicy.

Includes part of the new input event NDK API.  Some details TBD.

To wire up input dispatch, as the ViewRoot adds a window to the
window session it receives an InputChannel object as an output
argument.  The InputChannel encapsulates the file descriptors for a
shared memory region and two pipe end-points.  The ViewRoot then
provides the InputChannel to the InputQueue.  Behind the
scenes, InputQueue simply attaches handlers to the native PollLoop object
that underlies the MessageQueue.  This way MessageQueue doesn't need
to know anything about input dispatch per-se, it just exposes (in native
code) a PollLoop that other components can use to monitor file descriptor
state changes.

There can be zero or more targets for any given input event.  Each
input target is specified by its input channel and some parameters
including flags, an X/Y coordinate offset, and the dispatch timeout.
An input target can request either synchronous dispatch (for foreground apps)
or asynchronous dispatch (fire-and-forget for wallpapers and "outside"
targets).  Currently, finding the appropriate input targets for an event
requires a call back into the WindowManagerServer from native code.
In the future this will be refactored to avoid most of these callbacks
except as required to handle pending focus transitions.

End-to-end event dispatch mostly works!

To do: event injection, rate limiting, ANRs, testing, optimization, etc.

Change-Id: I8c36b2b9e0a2d27392040ecda0f51b636456de25
parent f62c57d6

core/java/android/os/MessageQueue.java

+35 −41
Original line number Diff line number Diff line
@@ -16,13 +16,11 @@ 


package android.os;



import java.util.ArrayList;



import android.util.AndroidRuntimeException;

import android.util.Config;

import android.util.Log;



import com.android.internal.os.RuntimeInit;

import java.util.ArrayList;



/**

 * Low-level class holding the list of messages to be dispatched by a
@@ -34,11 +32,18 @@ import com.android.internal.os.RuntimeInit; 
 */

public class MessageQueue {

    Message mMessages;

    private final ArrayList mIdleHandlers = new ArrayList();

    private final ArrayList<IdleHandler> mIdleHandlers = new ArrayList<IdleHandler>();

    private boolean mQuiting = false;

    private int mObject = 0;    // used by native code

    boolean mQuitAllowed = true;



    @SuppressWarnings("unused")

    private int mPtr; // used by native code

    

    private native void nativeInit();

    private native void nativeDestroy();

    private native boolean nativePollOnce(int timeoutMillis);

    private native void nativeWake();



    /**

     * Callback interface for discovering when a thread is going to block

     * waiting for more messages.
@@ -86,54 +91,38 @@ public class MessageQueue { 
        }

    }

    

    // Add an input pipe to the set being selected over.  If token is

    // negative, remove 'handler's entry from the current set and forget

    // about it.

    void setInputToken(int token, int region, Handler handler) {

        if (token >= 0) nativeRegisterInputStream(token, region, handler);

        else nativeUnregisterInputStream(token);

    }



    MessageQueue() {

        nativeInit();

    }

    private native void nativeInit();



    /**

     * @param token fd of the readable end of the input stream

     * @param region fd of the ashmem region used for data transport alongside the 'token' fd

     * @param handler Handler from which to make input messages based on data read from the fd

     */

    private native void nativeRegisterInputStream(int token, int region, Handler handler);

    private native void nativeUnregisterInputStream(int token);

    private native void nativeSignal();

    

    /**

     * Wait until the designated time for new messages to arrive.

     *

     * @param when Timestamp in SystemClock.uptimeMillis() base of the next message in the queue.

     *    If 'when' is zero, the method will check for incoming messages without blocking.  If

     *    'when' is negative, the method will block forever waiting for the next message.

     * @return

     */

    private native int nativeWaitForNext(long when);

    @Override

    protected void finalize() throws Throwable {

        try {

            nativeDestroy();

        } finally {

            super.finalize();

        }

    }



    final Message next() {

        boolean tryIdle = true;

        // when we start out, we'll just touch the input pipes and then go from there

        long timeToNextEventMillis = 0;

        int timeToNextEventMillis = 0;



        while (true) {

            long now;

            Object[] idlers = null;



            nativeWaitForNext(timeToNextEventMillis);

            boolean dispatched = nativePollOnce(timeToNextEventMillis);



            // Try to retrieve the next message, returning if found.

            synchronized (this) {

                now = SystemClock.uptimeMillis();

                Message msg = pullNextLocked(now);

                if (msg != null) return msg;

                if (msg != null) {

                    return msg;

                }

                

                if (tryIdle && mIdleHandlers.size() > 0) {

                    idlers = mIdleHandlers.toArray();

                }
@@ -170,9 +159,14 @@ public class MessageQueue { 
            synchronized (this) {

                // No messages, nobody to tell about it...  time to wait!

                if (mMessages != null) {

                    if (mMessages.when - now > 0) {

                    long longTimeToNextEventMillis = mMessages.when - now;

                    

                    if (longTimeToNextEventMillis > 0) {

                        Binder.flushPendingCommands();

                        timeToNextEventMillis = mMessages.when - now;

                        timeToNextEventMillis = (int) Math.min(longTimeToNextEventMillis,

                                Integer.MAX_VALUE);

                    } else {

                        timeToNextEventMillis = 0;

                    }

                } else {

                    Binder.flushPendingCommands();
@@ -230,7 +224,7 @@ public class MessageQueue { 
                msg.next = prev.next;

                prev.next = msg;

            }

            nativeSignal();

            nativeWake();

        }

        return true;

    }
@@ -351,7 +345,7 @@ public class MessageQueue { 
    void poke()

    {

        synchronized (this) {

            nativeSignal();

            nativeWake();

        }

    }

}

core/java/android/service/wallpaper/WallpaperService.java

+49 −1
Original line number Diff line number Diff line
@@ -18,6 +18,7 @@ package android.service.wallpaper; 


import com.android.internal.os.HandlerCaller;

import com.android.internal.view.BaseIWindow;

import com.android.internal.view.BaseInputHandler;

import com.android.internal.view.BaseSurfaceHolder;



import android.annotation.SdkConstant;
@@ -39,6 +40,10 @@ import android.util.Log; 
import android.util.LogPrinter;

import android.view.Gravity;

import android.view.IWindowSession;

import android.view.InputChannel;

import android.view.InputHandler;

import android.view.InputQueue;

import android.view.KeyEvent;

import android.view.MotionEvent;

import android.view.SurfaceHolder;

import android.view.View;
@@ -46,6 +51,7 @@ import android.view.ViewGroup; 
import android.view.ViewRoot;

import android.view.WindowManager;

import android.view.WindowManagerImpl;

import android.view.WindowManagerPolicy;



import java.util.ArrayList;
@@ -146,6 +152,7 @@ public abstract class WallpaperService extends Service { 
        final WindowManager.LayoutParams mLayout

                = new WindowManager.LayoutParams();

        IWindowSession mSession;

        InputChannel mInputChannel;



        final Object mLock = new Object();

        boolean mOffsetMessageEnqueued;
@@ -205,6 +212,30 @@ public abstract class WallpaperService extends Service { 
            

        };

        

        final InputHandler mInputHandler = new BaseInputHandler() {

            @Override

            public void handleTouch(MotionEvent event, Runnable finishedCallback) {

                try {

                    synchronized (mLock) {

                        if (event.getAction() == MotionEvent.ACTION_MOVE) {

                            if (mPendingMove != null) {

                                mCaller.removeMessages(MSG_TOUCH_EVENT, mPendingMove);

                                mPendingMove.recycle();

                            }

                            mPendingMove = event;

                        } else {

                            mPendingMove = null;

                        }

                        Message msg = mCaller.obtainMessageO(MSG_TOUCH_EVENT,

                                event);

                        mCaller.sendMessage(msg);

                    }

                } finally {

                    finishedCallback.run();

                }

            }

        };

        

        final BaseIWindow mWindow = new BaseIWindow() {

            @Override

            public boolean onDispatchPointer(MotionEvent event, long eventTime,
@@ -487,8 +518,15 @@ public abstract class WallpaperService extends Service { 
                        mLayout.setTitle(WallpaperService.this.getClass().getName());

                        mLayout.windowAnimations =

                                com.android.internal.R.style.Animation_Wallpaper;

                        mSession.add(mWindow, mLayout, View.VISIBLE, mContentInsets);

                        mInputChannel = new InputChannel();

                        mSession.add(mWindow, mLayout, View.VISIBLE, mContentInsets,

                                mInputChannel);

                        mCreated = true;



                        if (WindowManagerPolicy.ENABLE_NATIVE_INPUT_DISPATCH) {

                            InputQueue.registerInputChannel(mInputChannel, mInputHandler,

                                    Looper.myQueue());

                        }

                    }

                    

                    mSurfaceHolder.mSurfaceLock.lock();
@@ -587,6 +625,7 @@ public abstract class WallpaperService extends Service { 
            mSurfaceHolder.setSizeFromLayout();

            mInitializing = true;

            mSession = ViewRoot.getWindowSession(getMainLooper());

            

            mWindow.setSession(mSession);

            

            IntentFilter filter = new IntentFilter();
@@ -730,6 +769,15 @@ public abstract class WallpaperService extends Service { 
                try {

                    if (DEBUG) Log.v(TAG, "Removing window and destroying surface "

                            + mSurfaceHolder.getSurface() + " of: " + this);

                    

                    if (WindowManagerPolicy.ENABLE_NATIVE_INPUT_DISPATCH) {

                        if (mInputChannel != null) {

                            InputQueue.unregisterInputChannel(mInputChannel);

                            mInputChannel.dispose();

                            mInputChannel = null;

                        }

                    }

                    

                    mSession.remove(mWindow);

                } catch (RemoteException e) {

                }

core/java/android/view/IWindowSession.aidl

+4 −0
Original line number Diff line number Diff line
@@ -21,6 +21,7 @@ import android.content.res.Configuration; 
import android.graphics.Rect;

import android.graphics.Region;

import android.os.Bundle;

import android.view.InputChannel;

import android.view.IWindow;

import android.view.MotionEvent;

import android.view.WindowManager;
@@ -33,6 +34,9 @@ import android.view.Surface; 
 */

interface IWindowSession {

    int add(IWindow window, in WindowManager.LayoutParams attrs,

            in int viewVisibility, out Rect outContentInsets,

            out InputChannel outInputChannel);

    int addWithoutInputChannel(IWindow window, in WindowManager.LayoutParams attrs,

            in int viewVisibility, out Rect outContentInsets);

    void remove(IWindow window);

core/java/android/view/InputChannel.aidl

0 → 100644
+20 −0
Original line number Diff line number Diff line 
/* //device/java/android/android/view/InputChannel.aidl

**

** Copyright 2010, 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.

*/



package android.view;



parcelable InputChannel;

core/java/android/view/InputChannel.java

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

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

 */



package android.view;



import android.os.Parcel;

import android.os.Parcelable;

import android.util.Slog;



/**

 * An input channel specifies the file descriptors used to send input events to

 * a window in another process.  It is Parcelable so that it can be transmitted

 * to the ViewRoot through a Binder transaction as part of registering the Window.

 * @hide

 */

public class InputChannel implements Parcelable {

    private static final String TAG = "InputChannel";

    

    public static final Parcelable.Creator<InputChannel> CREATOR

            = new Parcelable.Creator<InputChannel>() {

        public InputChannel createFromParcel(Parcel source) {

            InputChannel result = new InputChannel();

            result.readFromParcel(source);

            return result;

        }

        

        public InputChannel[] newArray(int size) {

            return new InputChannel[size];

        }

    };

    

    @SuppressWarnings("unused")

    private int mPtr; // used by native code

    

    private boolean mDisposeAfterWriteToParcel;

    

    private static native InputChannel[] nativeOpenInputChannelPair(String name);

    

    private native void nativeDispose(boolean finalized);

    private native void nativeTransferTo(InputChannel other);

    private native void nativeReadFromParcel(Parcel parcel);

    private native void nativeWriteToParcel(Parcel parcel);

    

    private native String nativeGetName();



    /**

     * Creates an uninitialized input channel.

     * It can be initialized by reading from a Parcel or by transferring the state of

     * another input channel into this one.

     */

    public InputChannel() {

    }

    

    @Override

    protected void finalize() throws Throwable {

        try {

            nativeDispose(true);

        } finally {

            super.finalize();

        }

    }

    

    /**

     * Creates a new input channel pair.  One channel should be provided to the input

     * dispatcher and the other to the application's input queue.

     * @param name The descriptive (non-unique) name of the channel pair.

     * @return A pair of input channels.  They are symmetric and indistinguishable.

     */

    public static InputChannel[] openInputChannelPair(String name) {

        if (name == null) {

            throw new IllegalArgumentException("name must not be null");

        }

        

        Slog.d(TAG, "Opening input channel pair '" + name + "'");

        return nativeOpenInputChannelPair(name);

    }

    

    /**

     * Gets the name of the input channel.

     * @return The input channel name.

     */

    public String getName() {

        String name = nativeGetName();

        return name != null ? name : "uninitialized";

    }



    /**

     * Disposes the input channel.

     * Explicitly releases the reference this object is holding on the input channel.

     * When all references are released, the input channel will be closed.

     */

    public void dispose() {

        nativeDispose(false);

    }

    

    /**

     * Transfers ownership of the internal state of the input channel to another

     * instance and invalidates this instance.  This is used to pass an input channel

     * as an out parameter in a binder call.

     * @param other The other input channel instance.

     */

    public void transferToBinderOutParameter(InputChannel outParameter) {

        if (outParameter == null) {

            throw new IllegalArgumentException("outParameter must not be null");

        }

        

        nativeTransferTo(outParameter);

        outParameter.mDisposeAfterWriteToParcel = true;

    }



    public int describeContents() {

        return Parcelable.CONTENTS_FILE_DESCRIPTOR;

    }

    

    public void readFromParcel(Parcel in) {

        if (in == null) {

            throw new IllegalArgumentException("in must not be null");

        }

        

        nativeReadFromParcel(in);

    }

    

    public void writeToParcel(Parcel out, int flags) {

        if (out == null) {

            throw new IllegalArgumentException("out must not be null");

        }

        

        nativeWriteToParcel(out);

        

        if (mDisposeAfterWriteToParcel) {

            dispose();

        }

    }

    

    @Override

    public String toString() {

        return getName();

    }

}