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
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
|
package com.actionbarsherlock.internal.widget;
import java.lang.reflect.Field;
import android.content.Context;
import android.util.AttributeSet;
import android.view.View;
import android.view.ViewTreeObserver;
import android.view.ViewTreeObserver.OnScrollChangedListener;
import android.widget.PopupWindow;
/**
* Works around bugs in the handling of {@link ViewTreeObserver} by
* {@link PopupWindow}.
* <p>
* <code>PopupWindow</code> registers an {@link OnScrollChangedListener} with
* {@link ViewTreeObserver}, but does not keep a reference to the observer
* instance that it has registers on. This is problematic when the anchor view
* used by <code>PopupWindow</code> to access the observer is detached from the
* window, as it will revert from the shared <code>ViewTreeObserver</code> owned
* by the <code>ViewRoot</code> to a floating one, meaning
* <code>PopupWindow</code> cannot unregister it's listener anymore and has
* leaked it into the global observer.
* <p>
* This class works around this issue by
* <ul>
* <li>replacing <code>PopupWindow.mOnScrollChangedListener</code> with a no-op
* listener so that any registration or unregistration performed by
* <code>PopupWindow</code> itself has no effect and causes no leaks.
* <li>registering the real listener only with the shared
* <code>ViewTreeObserver</code> and keeping a reference to it to facilitate
* correct unregistration. The reason for not registering on a floating observer
* (before a view is attached) is that there is no safe way to get a reference
* to the shared observer that the floating one will be merged into. This would
* again cause the listener to leak.
* </ul>
*/
public class PopupWindowCompat extends PopupWindow {
private static final Field superListenerField;
static {
Field f = null;
try {
f = PopupWindow.class.getDeclaredField("mOnScrollChangedListener");
f.setAccessible(true);
} catch (NoSuchFieldException e) {
/* ignored */
}
superListenerField = f;
}
private static final OnScrollChangedListener NOP = new OnScrollChangedListener() {
@Override
public void onScrollChanged() {
/* do nothing */
}
};
private OnScrollChangedListener mSuperScrollListener;
private ViewTreeObserver mViewTreeObserver;
public PopupWindowCompat() {
super();
init();
}
public PopupWindowCompat(Context context) {
super(context);
init();
}
public PopupWindowCompat(Context context, AttributeSet attrs) {
super(context, attrs);
init();
}
public PopupWindowCompat(Context context, AttributeSet attrs, int defStyle) {
super(context, attrs, defStyle);
init();
}
// @TargetApi(Build.VERSION_CODES.HONEYCOMB)
public PopupWindowCompat(Context context, AttributeSet attrs, int defStyleAttr, int defStyleRes) {
super(context, attrs, defStyleAttr, defStyleRes);
init();
}
public PopupWindowCompat(int width, int height) {
super(width, height);
init();
}
public PopupWindowCompat(View contentView) {
super(contentView);
init();
}
public PopupWindowCompat(View contentView, int width, int height, boolean focusable) {
super(contentView, width, height, focusable);
init();
}
public PopupWindowCompat(View contentView, int width, int height) {
super(contentView, width, height);
init();
}
private void init() {
if (superListenerField != null) {
try {
mSuperScrollListener = (OnScrollChangedListener) superListenerField.get(this);
superListenerField.set(this, NOP);
} catch (Exception e) {
mSuperScrollListener = null;
}
}
}
private void unregisterListener() {
// Don't do anything if we haven't managed to patch the super listener
if (mSuperScrollListener != null && mViewTreeObserver != null) {
if (mViewTreeObserver.isAlive()) {
mViewTreeObserver.removeOnScrollChangedListener(mSuperScrollListener);
}
mViewTreeObserver = null;
}
}
private void registerListener(View anchor) {
// Don't do anything if we haven't managed to patch the super listener.
// And don't bother attaching the listener if the anchor view isn't
// attached. This means we'll only have to deal with the real VTO owned
// by the ViewRoot.
if (mSuperScrollListener != null) {
ViewTreeObserver vto = (anchor.getWindowToken() != null) ? anchor.getViewTreeObserver()
: null;
if (vto != mViewTreeObserver) {
if (mViewTreeObserver != null && mViewTreeObserver.isAlive()) {
mViewTreeObserver.removeOnScrollChangedListener(mSuperScrollListener);
}
if ((mViewTreeObserver = vto) != null) {
vto.addOnScrollChangedListener(mSuperScrollListener);
}
}
}
}
@Override
public void showAsDropDown(View anchor, int xoff, int yoff) {
super.showAsDropDown(anchor, xoff, yoff);
registerListener(anchor);
}
@Override
public void update(View anchor, int xoff, int yoff, int width, int height) {
super.update(anchor, xoff, yoff, width, height);
registerListener(anchor);
}
@Override
public void update(View anchor, int width, int height) {
super.update(anchor, width, height);
registerListener(anchor);
}
@Override
public void showAtLocation(View parent, int gravity, int x, int y) {
super.showAtLocation(parent, gravity, x, y);
unregisterListener();
}
@Override
public void dismiss() {
super.dismiss();
unregisterListener();
}
}
|
