AccessibilityNodeProviderCompat.java revision ca55694ec8cfb4cd836a23efe82d45b4c5e4158d 
1/*
2 * Copyright (C) 2012 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.accessibility;
18
19import android.os.Build;
20import android.os.Bundle;
21import android.view.View;
22import android.view.accessibility.AccessibilityNodeInfo;
23
24import java.util.ArrayList;
25import java.util.List;
26
27/**
28 * Helper for accessing {@link android.view.accessibility.AccessibilityNodeProvider}
29 * introduced after API level 4 in a backwards compatible fashion.
30 */
31public class AccessibilityNodeProviderCompat {
32
33    interface AccessibilityNodeProviderImpl {
34        public Object newAccessibilityNodeProviderBridge(AccessibilityNodeProviderCompat compat);
35    }
36
37    static class AccessibilityNodeProviderStubImpl implements AccessibilityNodeProviderImpl {
38        @Override
39        public Object newAccessibilityNodeProviderBridge(AccessibilityNodeProviderCompat compat) {
40            return null;
41        }
42    }
43
44    static class AccessibilityNodeProviderJellyBeanImpl extends AccessibilityNodeProviderStubImpl {
45        @Override
46        public Object newAccessibilityNodeProviderBridge(
47                final AccessibilityNodeProviderCompat compat) {
48            return AccessibilityNodeProviderCompatJellyBean.newAccessibilityNodeProviderBridge(
49                    new AccessibilityNodeProviderCompatJellyBean.AccessibilityNodeInfoBridge() {
50                        @Override
51                        public boolean performAction(int virtualViewId, int action,
52                                Bundle arguments) {
53                            return compat.performAction(virtualViewId, action, arguments);
54                        }
55
56                        @Override
57                        public List<Object> findAccessibilityNodeInfosByText(
58                                            String text, int virtualViewId) {
59                            List<AccessibilityNodeInfoCompat> compatInfos =
60                                compat.findAccessibilityNodeInfosByText(text, virtualViewId);
61                            List<Object> infos = new ArrayList<Object>();
62                            final int infoCount = compatInfos.size();
63                            for (int i = 0; i < infoCount; i++) {
64                                AccessibilityNodeInfoCompat infoCompat = compatInfos.get(i);
65                                infos.add(infoCompat.getInfo());
66                            }
67                            return infos;
68                        }
69
70                        @Override
71                        public Object createAccessibilityNodeInfo(
72                                int virtualViewId) {
73                            final AccessibilityNodeInfoCompat compatInfo = compat
74                                    .createAccessibilityNodeInfo(virtualViewId);
75                            if (compatInfo == null) {
76                                return null;
77                            } else {
78                                return compatInfo.getInfo();
79                            }
80                        }
81                    });
82        }
83    }
84
85    static class AccessibilityNodeProviderKitKatImpl extends AccessibilityNodeProviderStubImpl {
86        @Override
87        public Object newAccessibilityNodeProviderBridge(
88                final AccessibilityNodeProviderCompat compat) {
89            return AccessibilityNodeProviderCompatKitKat.newAccessibilityNodeProviderBridge(
90                    new AccessibilityNodeProviderCompatKitKat.AccessibilityNodeInfoBridge() {
91                        @Override
92                        public boolean performAction(int virtualViewId, int action,
93                                Bundle arguments) {
94                            return compat.performAction(virtualViewId, action, arguments);
95                        }
96
97                        @Override
98                        public List<Object> findAccessibilityNodeInfosByText(
99                                            String text, int virtualViewId) {
100                            List<AccessibilityNodeInfoCompat> compatInfos =
101                                compat.findAccessibilityNodeInfosByText(text, virtualViewId);
102                            List<Object> infos = new ArrayList<Object>();
103                            final int infoCount = compatInfos.size();
104                            for (int i = 0; i < infoCount; i++) {
105                                AccessibilityNodeInfoCompat infoCompat = compatInfos.get(i);
106                                infos.add(infoCompat.getInfo());
107                            }
108                            return infos;
109                        }
110
111                        @Override
112                        public Object createAccessibilityNodeInfo(
113                                int virtualViewId) {
114                            final AccessibilityNodeInfoCompat compatInfo = compat
115                                    .createAccessibilityNodeInfo(virtualViewId);
116                            if (compatInfo == null) {
117                                return null;
118                            } else {
119                                return compatInfo.getInfo();
120                            }
121                        }
122
123                        @Override
124                        public Object findFocus(int focus) {
125                            return compat.findFocus(focus);
126                        }
127                    });
128        }
129    }
130
131    private static final AccessibilityNodeProviderImpl IMPL;
132
133    private final Object mProvider;
134
135    static {
136        // TODO: Remove code name check when APIs are finalized.
137        if ("KitKat".equals(Build.VERSION.CODENAME) || Build.VERSION.SDK_INT >= 19) { // KitKat
138            IMPL = new AccessibilityNodeProviderKitKatImpl();
139        } else if (Build.VERSION.SDK_INT >= 16) { // JellyBean
140            IMPL = new AccessibilityNodeProviderJellyBeanImpl();
141        } else {
142            IMPL = new AccessibilityNodeProviderStubImpl();
143        }
144    }
145
146    /**
147     * Creates a new instance.
148     */
149    public AccessibilityNodeProviderCompat() {
150        mProvider = IMPL.newAccessibilityNodeProviderBridge(this);
151    }
152
153    /**
154     * Creates a new instance wrapping an
155     * {@link android.view.accessibility.AccessibilityNodeProvider}.
156     *
157     * @param provider The provider.
158     */
159    public AccessibilityNodeProviderCompat(Object provider) {
160        mProvider = provider;
161    }
162
163    /**
164     * @return The wrapped {@link android.view.accessibility.AccessibilityNodeProvider}.
165     */
166    public Object getProvider() {
167        return mProvider;
168    }
169
170    /**
171     * Returns an {@link AccessibilityNodeInfoCompat} representing a virtual view,
172     * i.e. a descendant of the host View, with the given <code>virtualViewId</code>
173     * or the host View itself if <code>virtualViewId</code> equals to {@link View#NO_ID}.
174     * <p>
175     * A virtual descendant is an imaginary View that is reported as a part of the view
176     * hierarchy for accessibility purposes. This enables custom views that draw complex
177     * content to report them selves as a tree of virtual views, thus conveying their
178     * logical structure.
179     * </p>
180     * <p>
181     * The implementer is responsible for obtaining an accessibility node info from the
182     * pool of reusable instances and setting the desired properties of the node info
183     * before returning it.
184     * </p>
185     *
186     * @param virtualViewId A client defined virtual view id.
187     * @return A populated {@link AccessibilityNodeInfoCompat} for a virtual descendant
188     *     or the host View.
189     *
190     * @see AccessibilityNodeInfoCompat
191     */
192    public AccessibilityNodeInfoCompat createAccessibilityNodeInfo(int virtualViewId) {
193        return null;
194    }
195
196    /**
197     * Performs an accessibility action on a virtual view, i.e. a descendant of the
198     * host View, with the given <code>virtualViewId</code> or the host View itself
199     * if <code>virtualViewId</code> equals to {@link View#NO_ID}.
200     *
201     * @param virtualViewId A client defined virtual view id.
202     * @param action The action to perform.
203     * @param arguments Optional arguments.
204     * @return True if the action was performed.
205     *
206     * @see #createAccessibilityNodeInfo(int)
207     * @see AccessibilityNodeInfoCompat
208     */
209    public boolean performAction(int virtualViewId, int action, Bundle arguments) {
210        return false;
211    }
212
213    /**
214     * Finds {@link AccessibilityNodeInfoCompat}s by text. The match is case insensitive
215     * containment. The search is relative to the virtual view, i.e. a descendant of the
216     * host View, with the given <code>virtualViewId</code> or the host View itself
217     * <code>virtualViewId</code> equals to {@link View#NO_ID}.
218     *
219     * @param virtualViewId A client defined virtual view id which defined
220     *     the root of the tree in which to perform the search.
221     * @param text The searched text.
222     * @return A list of node info.
223     *
224     * @see #createAccessibilityNodeInfo(int)
225     * @see AccessibilityNodeInfoCompat
226     */
227    public List<AccessibilityNodeInfoCompat> findAccessibilityNodeInfosByText(String text,
228            int virtualViewId) {
229        return null;
230    }
231
232    /**
233     * Find the virtual view, i.e. a descendant of the host View, that has the
234     * specified focus type.
235     *
236     * @param focus The focus to find. One of
237     *            {@link AccessibilityNodeInfoCompat#FOCUS_INPUT} or
238     *            {@link AccessibilityNodeInfoCompat#FOCUS_ACCESSIBILITY}.
239     * @return The node info of the focused view or null.
240     * @see AccessibilityNodeInfoCompat#FOCUS_INPUT
241     * @see AccessibilityNodeInfoCompat#FOCUS_ACCESSIBILITY
242     */
243    public AccessibilityNodeInfo findFocus(int focus) {
244        return null;
245    }
246}
247