AccessibilityDelegateCompat.java revision 9648c538bac4f04145c118cc41168d1d7a536312 
1/*
2 * Copyright (C) 2011 The Android Open Source Project
3 *
4 * Licensed under the Apache License, Version 2.0 (the "License");
5 * you may not use this file except in compliance with the License.
6 * You may obtain a copy of the License at
7 *
8 *      http://www.apache.org/licenses/LICENSE-2.0
9 *
10 * Unless required by applicable law or agreed to in writing, software
11 * distributed under the License is distributed on an "AS IS" BASIS,
12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13 * See the License for the specific language governing permissions and
14 * limitations under the License.
15 */
16
17package android.support.v4.view;
18
19import android.os.Build;
20import android.support.v4.view.accessibility.AccessibilityNodeInfoCompat;
21import android.view.View;
22import android.view.ViewGroup;
23import android.view.accessibility.AccessibilityEvent;
24
25/**
26 * Helper for accessing AccessibilityDelegate from newer platform versions.
27 */
28public class AccessibilityDelegateCompat {
29
30    static interface AccessibilityDelegateImpl {
31        public Object newAccessiblityDelegateDefaultImpl();
32        public Object newAccessiblityDelegateBridge(AccessibilityDelegateCompat listener);
33        public boolean dispatchPopulateAccessibilityEvent(Object delegate, View host,
34                AccessibilityEvent event);
35        public void onInitializeAccessibilityEvent(Object delegate, View host,
36                AccessibilityEvent event);
37        public void onInitializeAccessibilityNodeInfo(Object delegate, View host, Object info);
38        public void onPopulateAccessibilityEvent(Object delegate, View host,
39                AccessibilityEvent event);
40        public boolean onRequestSendAccessibilityEvent(Object delegate, ViewGroup host, View child,
41                AccessibilityEvent event);
42        public void sendAccessibilityEvent(Object delegate, View host, int eventType);
43        public void sendAccessibilityEventUnchecked(Object delegate, View host,
44                AccessibilityEvent event);
45    }
46
47    static class AccessibilityDelegateStubImpl implements AccessibilityDelegateImpl {
48        public Object newAccessiblityDelegateDefaultImpl() {
49            return null;
50        }
51
52        public Object newAccessiblityDelegateBridge(AccessibilityDelegateCompat listener) {
53            return null;
54        }
55
56        public boolean dispatchPopulateAccessibilityEvent(Object delegate, View host,
57                AccessibilityEvent event) {
58            return false;
59        }
60
61        public void onInitializeAccessibilityEvent(Object delegate, View host,
62                AccessibilityEvent event) {
63
64        }
65
66        public void onInitializeAccessibilityNodeInfo(Object delegate, View host, Object info) {
67
68        }
69
70        public void onPopulateAccessibilityEvent(Object delegate, View host,
71                AccessibilityEvent event) {
72
73        }
74
75        public boolean onRequestSendAccessibilityEvent(Object delegate, ViewGroup host, View child,
76                AccessibilityEvent event) {
77            return true;
78        }
79
80        public void sendAccessibilityEvent(Object delegate, View host, int eventType) {
81
82        }
83
84        public void sendAccessibilityEventUnchecked(Object delegate, View host,
85                AccessibilityEvent event) {
86
87        }
88    }
89
90    static class AccessibilityDelegateIcsImpl extends AccessibilityDelegateStubImpl {
91        @Override
92        public Object newAccessiblityDelegateDefaultImpl() {
93            return AccessibilityDelegateCompatIcs.newAccessibilityDelegateDefaultImpl();
94        }
95
96        @Override
97        public Object newAccessiblityDelegateBridge(final AccessibilityDelegateCompat compat) {
98            return AccessibilityDelegateCompatIcs.newAccessibilityDelegateBridge(
99                    new AccessibilityDelegateCompatIcs.AccessibilityDelegateBridge() {
100                @Override
101                public boolean dispatchPopulateAccessibilityEvent(View host,
102                        AccessibilityEvent event) {
103                    return compat.dispatchPopulateAccessibilityEvent(host, event);
104                }
105
106                @Override
107                public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
108                    compat.onInitializeAccessibilityEvent(host, event);
109                }
110
111                @Override
112                public void onInitializeAccessibilityNodeInfo(View host, Object info) {
113                    compat.onInitializeAccessibilityNodeInfo(host,
114                            new AccessibilityNodeInfoCompat(info));
115                }
116
117                @Override
118                public void onPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
119                    compat.onPopulateAccessibilityEvent(host, event);
120                }
121
122                @Override
123                public boolean onRequestSendAccessibilityEvent(ViewGroup host, View child,
124                        AccessibilityEvent event) {
125                    return compat.onRequestSendAccessibilityEvent(host, child, event);
126                }
127
128                @Override
129                public void sendAccessibilityEvent(View host, int eventType) {
130                    compat.sendAccessibilityEvent(host, eventType);
131                }
132
133                @Override
134                public void sendAccessibilityEventUnchecked(View host, AccessibilityEvent event) {
135                    compat.sendAccessibilityEventUnchecked(host, event);
136                }
137            });
138        }
139
140        @Override
141        public boolean dispatchPopulateAccessibilityEvent(Object delegate, View host,
142                AccessibilityEvent event) {
143            return AccessibilityDelegateCompatIcs.dispatchPopulateAccessibilityEvent(delegate,
144                    host, event);
145        }
146
147        @Override
148        public void onInitializeAccessibilityEvent(Object delegate, View host,
149                AccessibilityEvent event) {
150            AccessibilityDelegateCompatIcs.onInitializeAccessibilityEvent(delegate, host, event);
151        }
152
153        @Override
154        public void onInitializeAccessibilityNodeInfo(Object delegate, View host, Object info) {
155            AccessibilityDelegateCompatIcs.onInitializeAccessibilityNodeInfo(delegate, host, info);
156        }
157
158        @Override
159        public void onPopulateAccessibilityEvent(Object delegate, View host,
160                AccessibilityEvent event) {
161            AccessibilityDelegateCompatIcs.onPopulateAccessibilityEvent(delegate, host, event);
162        }
163
164        @Override
165        public boolean onRequestSendAccessibilityEvent(Object delegate, ViewGroup host, View child,
166                AccessibilityEvent event) {
167            return AccessibilityDelegateCompatIcs.onRequestSendAccessibilityEvent(delegate, host,
168                    child, event);
169        }
170
171        @Override
172        public void sendAccessibilityEvent(Object delegate, View host, int eventType) {
173            AccessibilityDelegateCompatIcs.sendAccessibilityEvent(delegate, host, eventType);
174        }
175
176        @Override
177        public void sendAccessibilityEventUnchecked(Object delegate, View host,
178                AccessibilityEvent event) {
179            AccessibilityDelegateCompatIcs.sendAccessibilityEventUnchecked(delegate, host, event);
180        }
181    }
182
183    private static final AccessibilityDelegateImpl IMPL;
184    private static final Object DEFAULT_DELEGATE;
185
186    static {
187        if (Build.VERSION.SDK_INT >= 14) { // ICS
188            IMPL = new AccessibilityDelegateIcsImpl();
189        } else {
190            IMPL = new AccessibilityDelegateStubImpl();
191        }
192        DEFAULT_DELEGATE = IMPL.newAccessiblityDelegateDefaultImpl();
193    }
194
195    final Object mBridge;
196
197    /**
198     * Creates a new instance.
199     */
200    public AccessibilityDelegateCompat() {
201        mBridge = IMPL.newAccessiblityDelegateBridge(this);
202    }
203
204    /**
205     * @return The wrapped bridge implementation.
206     */
207    Object getBridge() {
208        return mBridge;
209    }
210
211    /**
212     * Sends an accessibility event of the given type. If accessibility is not
213     * enabled this method has no effect.
214     * <p>
215     * The default implementation behaves as {@link View#sendAccessibilityEvent(int)
216     * View#sendAccessibilityEvent(int)} for the case of no accessibility delegate
217     * been set.
218     * </p>
219     *
220     * @param host The View hosting the delegate.
221     * @param eventType The type of the event to send.
222     *
223     * @see View#sendAccessibilityEvent(int) View#sendAccessibilityEvent(int)
224     */
225    public void sendAccessibilityEvent(View host, int eventType) {
226        IMPL.sendAccessibilityEvent(DEFAULT_DELEGATE, host, eventType);
227    }
228
229    /**
230     * Sends an accessibility event. This method behaves exactly as
231     * {@link #sendAccessibilityEvent(View, int)} but takes as an argument an
232     * empty {@link AccessibilityEvent} and does not perform a check whether
233     * accessibility is enabled.
234     * <p>
235     * The default implementation behaves as
236     * {@link View#sendAccessibilityEventUnchecked(AccessibilityEvent)
237     * View#sendAccessibilityEventUnchecked(AccessibilityEvent)} for
238     * the case of no accessibility delegate been set.
239     * </p>
240     *
241     * @param host The View hosting the delegate.
242     * @param event The event to send.
243     *
244     * @see View#sendAccessibilityEventUnchecked(AccessibilityEvent)
245     *      View#sendAccessibilityEventUnchecked(AccessibilityEvent)
246     */
247    public void sendAccessibilityEventUnchecked(View host, AccessibilityEvent event) {
248        IMPL.sendAccessibilityEventUnchecked(DEFAULT_DELEGATE, host, event);
249    }
250
251    /**
252     * Dispatches an {@link AccessibilityEvent} to the host {@link View} first and then
253     * to its children for adding their text content to the event.
254     * <p>
255     * The default implementation behaves as
256     * {@link View#dispatchPopulateAccessibilityEvent(AccessibilityEvent)
257     * View#dispatchPopulateAccessibilityEvent(AccessibilityEvent)} for
258     * the case of no accessibility delegate been set.
259     * </p>
260     *
261     * @param host The View hosting the delegate.
262     * @param event The event.
263     * @return True if the event population was completed.
264     *
265     * @see View#dispatchPopulateAccessibilityEvent(AccessibilityEvent)
266     *      View#dispatchPopulateAccessibilityEvent(AccessibilityEvent)
267     */
268    public boolean dispatchPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
269        return IMPL.dispatchPopulateAccessibilityEvent(DEFAULT_DELEGATE, host, event);
270    }
271
272    /**
273     * Gives a chance to the host View to populate the accessibility event with its
274     * text content.
275     * <p>
276     * The default implementation behaves as
277     * {@link ViewCompat#onPopulateAccessibilityEvent(View, AccessibilityEvent)
278     * ViewCompat#onPopulateAccessibilityEvent(AccessibilityEvent)} for
279     * the case of no accessibility delegate been set.
280     * </p>
281     *
282     * @param host The View hosting the delegate.
283     * @param event The accessibility event which to populate.
284     *
285     * @see ViewCompat#onPopulateAccessibilityEvent(View ,AccessibilityEvent)
286     *      ViewCompat#onPopulateAccessibilityEvent(View, AccessibilityEvent)
287     */
288    public void onPopulateAccessibilityEvent(View host, AccessibilityEvent event) {
289        IMPL.onPopulateAccessibilityEvent(DEFAULT_DELEGATE, host, event);
290    }
291
292    /**
293     * Initializes an {@link AccessibilityEvent} with information about the
294     * the host View which is the event source.
295     * <p>
296     * The default implementation behaves as
297     * {@link ViewCompat#onInitializeAccessibilityEvent(View v, AccessibilityEvent event)
298     * ViewCompat#onInitalizeAccessibilityEvent(View v, AccessibilityEvent event)} for
299     * the case of no accessibility delegate been set.
300     * </p>
301     *
302     * @param host The View hosting the delegate.
303     * @param event The event to initialize.
304     *
305     * @see ViewCompat#onInitializeAccessibilityEvent(View, AccessibilityEvent)
306     *      ViewCompat#onInitializeAccessibilityEvent(View, AccessibilityEvent)
307     */
308    public void onInitializeAccessibilityEvent(View host, AccessibilityEvent event) {
309        IMPL.onInitializeAccessibilityEvent(DEFAULT_DELEGATE, host, event);
310    }
311
312    /**
313     * Initializes an {@link AccessibilityNodeInfoCompat} with information about the host view.
314     * <p>
315     * The default implementation behaves as
316     * {@link ViewCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)
317     * ViewCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)} for
318     * the case of no accessibility delegate been set.
319     * </p>
320     *
321     * @param host The View hosting the delegate.
322     * @param info The instance to initialize.
323     *
324     * @see ViewCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)
325     *      ViewCompat#onInitializeAccessibilityNodeInfo(View, AccessibilityNodeInfoCompat)
326     */
327    public void onInitializeAccessibilityNodeInfo(View host, AccessibilityNodeInfoCompat info) {
328        IMPL.onInitializeAccessibilityNodeInfo(DEFAULT_DELEGATE, host, info);
329    }
330
331    /**
332     * Called when a child of the host View has requested sending an
333     * {@link AccessibilityEvent} and gives an opportunity to the parent (the host)
334     * to augment the event.
335     * <p>
336     * The default implementation behaves as
337     * {@link ViewGroupCompat#onRequestSendAccessibilityEvent(ViewGroup, View, AccessibilityEvent)
338     * ViewGroupCompat#onRequestSendAccessibilityEvent(ViewGroup, View, AccessibilityEvent)} for
339     * the case of no accessibility delegate been set.
340     * </p>
341     *
342     * @param host The View hosting the delegate.
343     * @param child The child which requests sending the event.
344     * @param event The event to be sent.
345     * @return True if the event should be sent
346     *
347     * @see ViewGroupCompat#onRequestSendAccessibilityEvent(ViewGroup, View, AccessibilityEvent)
348     *      ViewGroupCompat#onRequestSendAccessibilityEvent(ViewGroup, View, AccessibilityEvent)
349     */
350    public boolean onRequestSendAccessibilityEvent(ViewGroup host, View child,
351            AccessibilityEvent event) {
352        return IMPL.onRequestSendAccessibilityEvent(DEFAULT_DELEGATE, host, child, event);
353    }
354}
355