Files
frameworks_base/services/java/com/android/server/wm/InputWindowHandle.java
Jeff Brown 9302c8796f Refactor input dispatcher use of window/app handles.
This change moves the cached window and application input state
into the handle objects themselves.  It simplifies the dispatcher
somewhat because it no longer needs to fix up references to
transient InputWindow objects each time the window list is updated.

This change will also make it easier to optimize setInputWindows
to avoid doing a lot of redundant data copying.  In principle, only
the modified fields need to be updated.  However, for now we
continue to update all fields in unison as before.

It turns out that the input dispatcher was inappropriately retaining
pointers to InputWindow objects within the mWindows InputWindow
vector.  This vector is copy-on-write so it is possible and the
item pointers to change if an editing operation is performed on
the vector when it does not exclusively own the underlying
SharedBuffer.  This bug was uncovered by a previous change that
replaced calls to clear() and appendVector() with a simple use
of operator= which caused the buffer to be shared.  Consequently
after editItemAt was called (which it shouldn't have, actually)
the buffer was copied and the cached InputWindow pointers became
invalid.  Oops.  This change fixes the problem.

Change-Id: I0a259339a6015fcf9113dc4081a6875e047fd425
2011-07-14 04:11:21 -07:00

105 lines
2.9 KiB
Java

/*
* Copyright (C) 2011 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 com.android.server.wm;
import android.graphics.Region;
import android.view.InputChannel;
import android.view.WindowManagerPolicy;
/**
* Functions as a handle for a window that can receive input.
* Enables the native input dispatcher to refer indirectly to the window manager's window state.
* @hide
*/
public final class InputWindowHandle {
// Pointer to the native input window handle.
// This field is lazily initialized via JNI.
@SuppressWarnings("unused")
private int ptr;
// The input application handle.
public final InputApplicationHandle inputApplicationHandle;
// The window manager's window state.
public final WindowManagerPolicy.WindowState windowState;
// The input channel associated with the window.
public InputChannel inputChannel;
// The window name.
public String name;
// Window layout params attributes. (WindowManager.LayoutParams)
public int layoutParamsFlags;
public int layoutParamsType;
// Dispatching timeout.
public long dispatchingTimeoutNanos;
// Window frame.
public int frameLeft;
public int frameTop;
public int frameRight;
public int frameBottom;
// Global scaling factor applied to touch events when they are dispatched
// to the window
public float scaleFactor;
// Window touchable region.
public final Region touchableRegion = new Region();
// Window is visible.
public boolean visible;
// Window can receive keys.
public boolean canReceiveKeys;
// Window has focus.
public boolean hasFocus;
// Window has wallpaper. (window is the current wallpaper target)
public boolean hasWallpaper;
// Input event dispatching is paused.
public boolean paused;
// Window layer.
public int layer;
// Id of process and user that owns the window.
public int ownerPid;
public int ownerUid;
// Window input features.
public int inputFeatures;
private native void nativeDispose();
public InputWindowHandle(InputApplicationHandle inputApplicationHandle,
WindowManagerPolicy.WindowState windowState) {
this.inputApplicationHandle = inputApplicationHandle;
this.windowState = windowState;
}
@Override
protected void finalize() throws Throwable {
nativeDispose();
super.finalize();
}
}