1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
|
/*
* 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 android.view;
import static android.view.Display.INVALID_DISPLAY;
import android.annotation.Nullable;
import android.graphics.Region;
import android.os.IBinder;
import java.lang.ref.WeakReference;
/**
* 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 long ptr;
// The input application handle.
public InputApplicationHandle inputApplicationHandle;
// The token associates input data with a window and its input channel. The client input
// channel and the server input channel will both contain this token.
public IBinder token;
// 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;
public int surfaceInset;
// 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;
// Id of process and user that owns the window.
public int ownerPid;
public int ownerUid;
// Window input features.
public int inputFeatures;
// Display this input is on.
public int displayId;
// If this value is set to a valid display ID, it indicates this window is a portal which
// transports the touch of this window to the display indicated by portalToDisplayId.
public int portalToDisplayId = INVALID_DISPLAY;
/**
* Crops the touchable region to the bounds of the surface provided.
*
* This can be used in cases where the window is not
* {@link android.view.WindowManager#FLAG_NOT_TOUCH_MODAL} but should be constrained to the
* bounds of a parent window. That is the window should receive touch events outside its
* window but be limited to its stack bounds, such as in the case of split screen.
*/
public WeakReference<SurfaceControl> touchableRegionSurfaceControl = new WeakReference<>(null);
/**
* Replace {@link touchableRegion} with the bounds of {@link touchableRegionSurfaceControl}. If
* the handle is {@code null}, the bounds of the surface associated with this window is used
* as the touchable region.
*/
public boolean replaceTouchableRegionWithCrop;
private native void nativeDispose();
public InputWindowHandle(InputApplicationHandle inputApplicationHandle, int displayId) {
this.inputApplicationHandle = inputApplicationHandle;
this.displayId = displayId;
}
@Override
public String toString() {
return new StringBuilder(name != null ? name : "")
.append(", frame=[").append(frameLeft).append(",").append(frameTop).append(",")
.append(frameRight).append(",").append(frameBottom).append("]")
.append(", touchableRegion=").append(touchableRegion)
.append(", visible=").append(visible)
.toString();
}
@Override
protected void finalize() throws Throwable {
try {
nativeDispose();
} finally {
super.finalize();
}
}
/**
* Set the window touchable region to the bounds of {@link touchableRegionBounds} ignoring any
* touchable region provided.
*
* @param bounds surface to set the touchable region to. Set to {@code null} to set the bounds
* to the current surface.
*/
public void replaceTouchableRegionWithCrop(@Nullable SurfaceControl bounds) {
setTouchableRegionCrop(bounds);
replaceTouchableRegionWithCrop = true;
}
/**
* Crop the window touchable region to the bounds of the surface provided.
*/
public void setTouchableRegionCrop(@Nullable SurfaceControl bounds) {
touchableRegionSurfaceControl = new WeakReference<>(bounds);
}
}
|
