[go: nahoru, domu]

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.view.accessibility;
18
19import android.accessibilityservice.AccessibilityService;
20import android.accessibilityservice.AccessibilityServiceInfo;
21import android.annotation.Nullable;
22import android.graphics.Rect;
23import android.os.Bundle;
24import android.os.Parcel;
25import android.os.Parcelable;
26import android.text.InputType;
27import android.text.TextUtils;
28import android.util.ArraySet;
29import android.util.LongArray;
30import android.util.Pools.SynchronizedPool;
31import android.view.View;
32
33import com.android.internal.R;
34
35import java.util.ArrayList;
36import java.util.Collections;
37import java.util.List;
38
39/**
40 * This class represents a node of the window content as well as actions that
41 * can be requested from its source. From the point of view of an
42 * {@link android.accessibilityservice.AccessibilityService} a window's content is
43 * presented as a tree of accessibility node infos, which may or may not map one-to-one
44 * to the view hierarchy. In other words, a custom view is free to report itself as
45 * a tree of accessibility node info.
46 * </p>
47 * <p>
48 * Once an accessibility node info is delivered to an accessibility service it is
49 * made immutable and calling a state mutation method generates an error.
50 * </p>
51 * <p>
52 * Please refer to {@link android.accessibilityservice.AccessibilityService} for
53 * details about how to obtain a handle to window content as a tree of accessibility
54 * node info as well as details about the security model.
55 * </p>
56 * <div class="special reference">
57 * <h3>Developer Guides</h3>
58 * <p>For more information about making applications accessible, read the
59 * <a href="{@docRoot}guide/topics/ui/accessibility/index.html">Accessibility</a>
60 * developer guide.</p>
61 * </div>
62 *
63 * @see android.accessibilityservice.AccessibilityService
64 * @see AccessibilityEvent
65 * @see AccessibilityManager
66 */
67public class AccessibilityNodeInfo implements Parcelable {
68
69    private static final boolean DEBUG = false;
70
71    /** @hide */
72    public static final int UNDEFINED_CONNECTION_ID = -1;
73
74    /** @hide */
75    public static final int UNDEFINED_SELECTION_INDEX = -1;
76
77    /** @hide */
78    public static final int UNDEFINED_ITEM_ID = Integer.MAX_VALUE;
79
80    /** @hide */
81    public static final long ROOT_NODE_ID = makeNodeId(UNDEFINED_ITEM_ID, UNDEFINED_ITEM_ID);
82
83    /** @hide */
84    public static final int ACTIVE_WINDOW_ID = UNDEFINED_ITEM_ID;
85
86    /** @hide */
87    public static final int ANY_WINDOW_ID = -2;
88
89    /** @hide */
90    public static final int FLAG_PREFETCH_PREDECESSORS = 0x00000001;
91
92    /** @hide */
93    public static final int FLAG_PREFETCH_SIBLINGS = 0x00000002;
94
95    /** @hide */
96    public static final int FLAG_PREFETCH_DESCENDANTS = 0x00000004;
97
98    /** @hide */
99    public static final int FLAG_INCLUDE_NOT_IMPORTANT_VIEWS = 0x00000008;
100
101    /** @hide */
102    public static final int FLAG_REPORT_VIEW_IDS = 0x00000010;
103
104    // Actions.
105
106    /**
107     * Action that gives input focus to the node.
108     */
109    public static final int ACTION_FOCUS =  0x00000001;
110
111    /**
112     * Action that clears input focus of the node.
113     */
114    public static final int ACTION_CLEAR_FOCUS = 0x00000002;
115
116    /**
117     * Action that selects the node.
118     */
119    public static final int ACTION_SELECT = 0x00000004;
120
121    /**
122     * Action that deselects the node.
123     */
124    public static final int ACTION_CLEAR_SELECTION = 0x00000008;
125
126    /**
127     * Action that clicks on the node info.
128     *
129     * See {@link AccessibilityAction#ACTION_CLICK}
130     */
131    public static final int ACTION_CLICK = 0x00000010;
132
133    /**
134     * Action that long clicks on the node.
135     */
136    public static final int ACTION_LONG_CLICK = 0x00000020;
137
138    /**
139     * Action that gives accessibility focus to the node.
140     */
141    public static final int ACTION_ACCESSIBILITY_FOCUS = 0x00000040;
142
143    /**
144     * Action that clears accessibility focus of the node.
145     */
146    public static final int ACTION_CLEAR_ACCESSIBILITY_FOCUS = 0x00000080;
147
148    /**
149     * Action that requests to go to the next entity in this node's text
150     * at a given movement granularity. For example, move to the next character,
151     * word, etc.
152     * <p>
153     * <strong>Arguments:</strong> {@link #ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT}<,
154     * {@link #ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN}<br>
155     * <strong>Example:</strong> Move to the previous character and do not extend selection.
156     * <code><pre><p>
157     *   Bundle arguments = new Bundle();
158     *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT,
159     *           AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
160     *   arguments.putBoolean(AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN,
161     *           false);
162     *   info.performAction(AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, arguments);
163     * </code></pre></p>
164     * </p>
165     *
166     * @see #ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
167     * @see #ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
168     *
169     * @see #setMovementGranularities(int)
170     * @see #getMovementGranularities()
171     *
172     * @see #MOVEMENT_GRANULARITY_CHARACTER
173     * @see #MOVEMENT_GRANULARITY_WORD
174     * @see #MOVEMENT_GRANULARITY_LINE
175     * @see #MOVEMENT_GRANULARITY_PARAGRAPH
176     * @see #MOVEMENT_GRANULARITY_PAGE
177     */
178    public static final int ACTION_NEXT_AT_MOVEMENT_GRANULARITY = 0x00000100;
179
180    /**
181     * Action that requests to go to the previous entity in this node's text
182     * at a given movement granularity. For example, move to the next character,
183     * word, etc.
184     * <p>
185     * <strong>Arguments:</strong> {@link #ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT}<,
186     * {@link #ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN}<br>
187     * <strong>Example:</strong> Move to the next character and do not extend selection.
188     * <code><pre><p>
189     *   Bundle arguments = new Bundle();
190     *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT,
191     *           AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
192     *   arguments.putBoolean(AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN,
193     *           false);
194     *   info.performAction(AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY,
195     *           arguments);
196     * </code></pre></p>
197     * </p>
198     *
199     * @see #ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
200     * @see #ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
201     *
202     * @see #setMovementGranularities(int)
203     * @see #getMovementGranularities()
204     *
205     * @see #MOVEMENT_GRANULARITY_CHARACTER
206     * @see #MOVEMENT_GRANULARITY_WORD
207     * @see #MOVEMENT_GRANULARITY_LINE
208     * @see #MOVEMENT_GRANULARITY_PARAGRAPH
209     * @see #MOVEMENT_GRANULARITY_PAGE
210     */
211    public static final int ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY = 0x00000200;
212
213    /**
214     * Action to move to the next HTML element of a given type. For example, move
215     * to the BUTTON, INPUT, TABLE, etc.
216     * <p>
217     * <strong>Arguments:</strong> {@link #ACTION_ARGUMENT_HTML_ELEMENT_STRING}<br>
218     * <strong>Example:</strong>
219     * <code><pre><p>
220     *   Bundle arguments = new Bundle();
221     *   arguments.putString(AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING, "BUTTON");
222     *   info.performAction(AccessibilityNodeInfo.ACTION_NEXT_HTML_ELEMENT, arguments);
223     * </code></pre></p>
224     * </p>
225     */
226    public static final int ACTION_NEXT_HTML_ELEMENT = 0x00000400;
227
228    /**
229     * Action to move to the previous HTML element of a given type. For example, move
230     * to the BUTTON, INPUT, TABLE, etc.
231     * <p>
232     * <strong>Arguments:</strong> {@link #ACTION_ARGUMENT_HTML_ELEMENT_STRING}<br>
233     * <strong>Example:</strong>
234     * <code><pre><p>
235     *   Bundle arguments = new Bundle();
236     *   arguments.putString(AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING, "BUTTON");
237     *   info.performAction(AccessibilityNodeInfo.ACTION_PREVIOUS_HTML_ELEMENT, arguments);
238     * </code></pre></p>
239     * </p>
240     */
241    public static final int ACTION_PREVIOUS_HTML_ELEMENT = 0x00000800;
242
243    /**
244     * Action to scroll the node content forward.
245     */
246    public static final int ACTION_SCROLL_FORWARD = 0x00001000;
247
248    /**
249     * Action to scroll the node content backward.
250     */
251    public static final int ACTION_SCROLL_BACKWARD = 0x00002000;
252
253    /**
254     * Action to copy the current selection to the clipboard.
255     */
256    public static final int ACTION_COPY = 0x00004000;
257
258    /**
259     * Action to paste the current clipboard content.
260     */
261    public static final int ACTION_PASTE = 0x00008000;
262
263    /**
264     * Action to cut the current selection and place it to the clipboard.
265     */
266    public static final int ACTION_CUT = 0x00010000;
267
268    /**
269     * Action to set the selection. Performing this action with no arguments
270     * clears the selection.
271     * <p>
272     * <strong>Arguments:</strong>
273     * {@link #ACTION_ARGUMENT_SELECTION_START_INT},
274     * {@link #ACTION_ARGUMENT_SELECTION_END_INT}<br>
275     * <strong>Example:</strong>
276     * <code><pre><p>
277     *   Bundle arguments = new Bundle();
278     *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT, 1);
279     *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT, 2);
280     *   info.performAction(AccessibilityNodeInfo.ACTION_SET_SELECTION, arguments);
281     * </code></pre></p>
282     * </p>
283     *
284     * @see #ACTION_ARGUMENT_SELECTION_START_INT
285     * @see #ACTION_ARGUMENT_SELECTION_END_INT
286     */
287    public static final int ACTION_SET_SELECTION = 0x00020000;
288
289    /**
290     * Action to expand an expandable node.
291     */
292    public static final int ACTION_EXPAND = 0x00040000;
293
294    /**
295     * Action to collapse an expandable node.
296     */
297    public static final int ACTION_COLLAPSE = 0x00080000;
298
299    /**
300     * Action to dismiss a dismissable node.
301     */
302    public static final int ACTION_DISMISS = 0x00100000;
303
304    /**
305     * Action that sets the text of the node. Performing the action without argument, using <code>
306     * null</code> or empty {@link CharSequence} will clear the text. This action will also put the
307     * cursor at the end of text.
308     * <p>
309     * <strong>Arguments:</strong>
310     * {@link #ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE}<br>
311     * <strong>Example:</strong>
312     * <code><pre><p>
313     *   Bundle arguments = new Bundle();
314     *   arguments.putCharSequence(AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE,
315     *       "android");
316     *   info.performAction(AccessibilityNodeInfo.ACTION_SET_TEXT, arguments);
317     * </code></pre></p>
318     */
319    public static final int ACTION_SET_TEXT = 0x00200000;
320
321    private static final int LAST_LEGACY_STANDARD_ACTION = ACTION_SET_TEXT;
322
323    /**
324     * Mask to see if the value is larger than the largest ACTION_ constant
325     */
326    private static final int ACTION_TYPE_MASK = 0xFF000000;
327
328    // Action arguments
329
330    /**
331     * Argument for which movement granularity to be used when traversing the node text.
332     * <p>
333     * <strong>Type:</strong> int<br>
334     * <strong>Actions:</strong>
335     * <ul>
336     *     <li>{@link AccessibilityAction#ACTION_NEXT_AT_MOVEMENT_GRANULARITY}</li>
337     *     <li>{@link AccessibilityAction#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY}</li>
338     * </ul>
339     * </p>
340     *
341     * @see AccessibilityAction#ACTION_NEXT_AT_MOVEMENT_GRANULARITY
342     * @see AccessibilityAction#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
343     */
344    public static final String ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT =
345            "ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT";
346
347    /**
348     * Argument for which HTML element to get moving to the next/previous HTML element.
349     * <p>
350     * <strong>Type:</strong> String<br>
351     * <strong>Actions:</strong>
352     * <ul>
353     *     <li>{@link AccessibilityAction#ACTION_NEXT_HTML_ELEMENT}</li>
354     *     <li>{@link AccessibilityAction#ACTION_PREVIOUS_HTML_ELEMENT}</li>
355     * </ul>
356     * </p>
357     *
358     * @see AccessibilityAction#ACTION_NEXT_HTML_ELEMENT
359     * @see AccessibilityAction#ACTION_PREVIOUS_HTML_ELEMENT
360     */
361    public static final String ACTION_ARGUMENT_HTML_ELEMENT_STRING =
362            "ACTION_ARGUMENT_HTML_ELEMENT_STRING";
363
364    /**
365     * Argument for whether when moving at granularity to extend the selection
366     * or to move it otherwise.
367     * <p>
368     * <strong>Type:</strong> boolean<br>
369     * <strong>Actions:</strong>
370     * <ul>
371     *     <li>{@link AccessibilityAction#ACTION_NEXT_AT_MOVEMENT_GRANULARITY}</li>
372     *     <li>{@link AccessibilityAction#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY}</li>
373     * </ul>
374     *
375     * @see AccessibilityAction#ACTION_NEXT_AT_MOVEMENT_GRANULARITY
376     * @see AccessibilityAction#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
377     */
378    public static final String ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN =
379            "ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN";
380
381    /**
382     * Argument for specifying the selection start.
383     * <p>
384     * <strong>Type:</strong> int<br>
385     * <strong>Actions:</strong>
386     * <ul>
387     *     <li>{@link AccessibilityAction#ACTION_SET_SELECTION}</li>
388     * </ul>
389     *
390     * @see AccessibilityAction#ACTION_SET_SELECTION
391     */
392    public static final String ACTION_ARGUMENT_SELECTION_START_INT =
393            "ACTION_ARGUMENT_SELECTION_START_INT";
394
395    /**
396     * Argument for specifying the selection end.
397     * <p>
398     * <strong>Type:</strong> int<br>
399     * <strong>Actions:</strong>
400     * <ul>
401     *     <li>{@link AccessibilityAction#ACTION_SET_SELECTION}</li>
402     * </ul>
403     *
404     * @see AccessibilityAction#ACTION_SET_SELECTION
405     */
406    public static final String ACTION_ARGUMENT_SELECTION_END_INT =
407            "ACTION_ARGUMENT_SELECTION_END_INT";
408
409    /**
410     * Argument for specifying the text content to set.
411     * <p>
412     * <strong>Type:</strong> CharSequence<br>
413     * <strong>Actions:</strong>
414     * <ul>
415     *     <li>{@link AccessibilityAction#ACTION_SET_TEXT}</li>
416     * </ul>
417     *
418     * @see AccessibilityAction#ACTION_SET_TEXT
419     */
420    public static final String ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE =
421            "ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE";
422
423    /**
424     * Argument for specifying the collection row to make visible on screen.
425     * <p>
426     * <strong>Type:</strong> int<br>
427     * <strong>Actions:</strong>
428     * <ul>
429     *     <li>{@link AccessibilityAction#ACTION_SCROLL_TO_POSITION}</li>
430     * </ul>
431     *
432     * @see AccessibilityAction#ACTION_SCROLL_TO_POSITION
433     */
434    public static final String ACTION_ARGUMENT_ROW_INT =
435            "android.view.accessibility.action.ARGUMENT_ROW_INT";
436
437    /**
438     * Argument for specifying the collection column to make visible on screen.
439     * <p>
440     * <strong>Type:</strong> int<br>
441     * <strong>Actions:</strong>
442     * <ul>
443     *     <li>{@link AccessibilityAction#ACTION_SCROLL_TO_POSITION}</li>
444     * </ul>
445     *
446     * @see AccessibilityAction#ACTION_SCROLL_TO_POSITION
447     */
448    public static final String ACTION_ARGUMENT_COLUMN_INT =
449            "android.view.accessibility.action.ARGUMENT_COLUMN_INT";
450
451    /**
452     * Argument for specifying the progress value to set.
453     * <p>
454     * <strong>Type:</strong> float<br>
455     * <strong>Actions:</strong>
456     * <ul>
457     *     <li>{@link AccessibilityAction#ACTION_SET_PROGRESS}</li>
458     * </ul>
459     *
460     * @see AccessibilityAction#ACTION_SET_PROGRESS
461     */
462    public static final String ACTION_ARGUMENT_PROGRESS_VALUE =
463            "android.view.accessibility.action.ARGUMENT_PROGRESS_VALUE";
464
465    // Focus types
466
467    /**
468     * The input focus.
469     */
470    public static final int FOCUS_INPUT = 1;
471
472    /**
473     * The accessibility focus.
474     */
475    public static final int FOCUS_ACCESSIBILITY = 2;
476
477    // Movement granularities
478
479    /**
480     * Movement granularity bit for traversing the text of a node by character.
481     */
482    public static final int MOVEMENT_GRANULARITY_CHARACTER = 0x00000001;
483
484    /**
485     * Movement granularity bit for traversing the text of a node by word.
486     */
487    public static final int MOVEMENT_GRANULARITY_WORD = 0x00000002;
488
489    /**
490     * Movement granularity bit for traversing the text of a node by line.
491     */
492    public static final int MOVEMENT_GRANULARITY_LINE = 0x00000004;
493
494    /**
495     * Movement granularity bit for traversing the text of a node by paragraph.
496     */
497    public static final int MOVEMENT_GRANULARITY_PARAGRAPH = 0x00000008;
498
499    /**
500     * Movement granularity bit for traversing the text of a node by page.
501     */
502    public static final int MOVEMENT_GRANULARITY_PAGE = 0x00000010;
503
504    // Boolean attributes.
505
506    private static final int BOOLEAN_PROPERTY_CHECKABLE = 0x00000001;
507
508    private static final int BOOLEAN_PROPERTY_CHECKED = 0x00000002;
509
510    private static final int BOOLEAN_PROPERTY_FOCUSABLE = 0x00000004;
511
512    private static final int BOOLEAN_PROPERTY_FOCUSED = 0x00000008;
513
514    private static final int BOOLEAN_PROPERTY_SELECTED = 0x00000010;
515
516    private static final int BOOLEAN_PROPERTY_CLICKABLE = 0x00000020;
517
518    private static final int BOOLEAN_PROPERTY_LONG_CLICKABLE = 0x00000040;
519
520    private static final int BOOLEAN_PROPERTY_ENABLED = 0x00000080;
521
522    private static final int BOOLEAN_PROPERTY_PASSWORD = 0x00000100;
523
524    private static final int BOOLEAN_PROPERTY_SCROLLABLE = 0x00000200;
525
526    private static final int BOOLEAN_PROPERTY_ACCESSIBILITY_FOCUSED = 0x00000400;
527
528    private static final int BOOLEAN_PROPERTY_VISIBLE_TO_USER = 0x00000800;
529
530    private static final int BOOLEAN_PROPERTY_EDITABLE = 0x00001000;
531
532    private static final int BOOLEAN_PROPERTY_OPENS_POPUP = 0x00002000;
533
534    private static final int BOOLEAN_PROPERTY_DISMISSABLE = 0x00004000;
535
536    private static final int BOOLEAN_PROPERTY_MULTI_LINE = 0x00008000;
537
538    private static final int BOOLEAN_PROPERTY_CONTENT_INVALID = 0x00010000;
539
540    private static final int BOOLEAN_PROPERTY_CONTEXT_CLICKABLE = 0x00020000;
541
542    private static final int BOOLEAN_PROPERTY_IMPORTANCE = 0x0040000;
543
544    /**
545     * Bits that provide the id of a virtual descendant of a view.
546     */
547    private static final long VIRTUAL_DESCENDANT_ID_MASK = 0xffffffff00000000L;
548
549    /**
550     * Bit shift of {@link #VIRTUAL_DESCENDANT_ID_MASK} to get to the id for a
551     * virtual descendant of a view. Such a descendant does not exist in the view
552     * hierarchy and is only reported via the accessibility APIs.
553     */
554    private static final int VIRTUAL_DESCENDANT_ID_SHIFT = 32;
555
556    /**
557     * Gets the accessibility view id which identifies a View in the view three.
558     *
559     * @param accessibilityNodeId The id of an {@link AccessibilityNodeInfo}.
560     * @return The accessibility view id part of the node id.
561     *
562     * @hide
563     */
564    public static int getAccessibilityViewId(long accessibilityNodeId) {
565        return (int) accessibilityNodeId;
566    }
567
568    /**
569     * Gets the virtual descendant id which identifies an imaginary view in a
570     * containing View.
571     *
572     * @param accessibilityNodeId The id of an {@link AccessibilityNodeInfo}.
573     * @return The virtual view id part of the node id.
574     *
575     * @hide
576     */
577    public static int getVirtualDescendantId(long accessibilityNodeId) {
578        return (int) ((accessibilityNodeId & VIRTUAL_DESCENDANT_ID_MASK)
579                >> VIRTUAL_DESCENDANT_ID_SHIFT);
580    }
581
582    /**
583     * Makes a node id by shifting the <code>virtualDescendantId</code>
584     * by {@link #VIRTUAL_DESCENDANT_ID_SHIFT} and taking
585     * the bitwise or with the <code>accessibilityViewId</code>.
586     *
587     * @param accessibilityViewId A View accessibility id.
588     * @param virtualDescendantId A virtual descendant id.
589     * @return The node id.
590     *
591     * @hide
592     */
593    public static long makeNodeId(int accessibilityViewId, int virtualDescendantId) {
594        // We changed the value for undefined node to positive due to wrong
595        // global id composition (two 32-bin ints into one 64-bit long) but
596        // the value used for the host node provider view has id -1 so we
597        // remap it here.
598        if (virtualDescendantId == AccessibilityNodeProvider.HOST_VIEW_ID) {
599            virtualDescendantId = UNDEFINED_ITEM_ID;
600        }
601        return (((long) virtualDescendantId) << VIRTUAL_DESCENDANT_ID_SHIFT) | accessibilityViewId;
602    }
603
604    // Housekeeping.
605    private static final int MAX_POOL_SIZE = 50;
606    private static final SynchronizedPool<AccessibilityNodeInfo> sPool =
607            new SynchronizedPool<>(MAX_POOL_SIZE);
608
609    private boolean mSealed;
610
611    // Data.
612    private int mWindowId = UNDEFINED_ITEM_ID;
613    private long mSourceNodeId = ROOT_NODE_ID;
614    private long mParentNodeId = ROOT_NODE_ID;
615    private long mLabelForId = ROOT_NODE_ID;
616    private long mLabeledById = ROOT_NODE_ID;
617    private long mTraversalBefore = ROOT_NODE_ID;
618    private long mTraversalAfter = ROOT_NODE_ID;
619
620    private int mBooleanProperties;
621    private final Rect mBoundsInParent = new Rect();
622    private final Rect mBoundsInScreen = new Rect();
623    private int mDrawingOrderInParent;
624
625    private CharSequence mPackageName;
626    private CharSequence mClassName;
627    private CharSequence mText;
628    private CharSequence mError;
629    private CharSequence mContentDescription;
630    private String mViewIdResourceName;
631
632    private LongArray mChildNodeIds;
633    private ArrayList<AccessibilityAction> mActions;
634
635    private int mMaxTextLength = -1;
636    private int mMovementGranularities;
637
638    private int mTextSelectionStart = UNDEFINED_SELECTION_INDEX;
639    private int mTextSelectionEnd = UNDEFINED_SELECTION_INDEX;
640    private int mInputType = InputType.TYPE_NULL;
641    private int mLiveRegion = View.ACCESSIBILITY_LIVE_REGION_NONE;
642
643    private Bundle mExtras;
644
645    private int mConnectionId = UNDEFINED_CONNECTION_ID;
646
647    private RangeInfo mRangeInfo;
648    private CollectionInfo mCollectionInfo;
649    private CollectionItemInfo mCollectionItemInfo;
650
651    /**
652     * Hide constructor from clients.
653     */
654    private AccessibilityNodeInfo() {
655        /* do nothing */
656    }
657
658    /**
659     * Sets the source.
660     * <p>
661     *   <strong>Note:</strong> Cannot be called from an
662     *   {@link android.accessibilityservice.AccessibilityService}.
663     *   This class is made immutable before being delivered to an AccessibilityService.
664     * </p>
665     *
666     * @param source The info source.
667     */
668    public void setSource(View source) {
669        setSource(source, UNDEFINED_ITEM_ID);
670    }
671
672    /**
673     * Sets the source to be a virtual descendant of the given <code>root</code>.
674     * If <code>virtualDescendantId</code> is {@link View#NO_ID} the root
675     * is set as the source.
676     * <p>
677     * A virtual descendant is an imaginary View that is reported as a part of the view
678     * hierarchy for accessibility purposes. This enables custom views that draw complex
679     * content to report themselves as a tree of virtual views, thus conveying their
680     * logical structure.
681     * </p>
682     * <p>
683     *   <strong>Note:</strong> Cannot be called from an
684     *   {@link android.accessibilityservice.AccessibilityService}.
685     *   This class is made immutable before being delivered to an AccessibilityService.
686     * </p>
687     *
688     * @param root The root of the virtual subtree.
689     * @param virtualDescendantId The id of the virtual descendant.
690     */
691    public void setSource(View root, int virtualDescendantId) {
692        enforceNotSealed();
693        mWindowId = (root != null) ? root.getAccessibilityWindowId() : UNDEFINED_ITEM_ID;
694        final int rootAccessibilityViewId =
695            (root != null) ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
696        mSourceNodeId = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
697    }
698
699    /**
700     * Find the view that has the specified focus type. The search starts from
701     * the view represented by this node info.
702     *
703     * @param focus The focus to find. One of {@link #FOCUS_INPUT} or
704     *         {@link #FOCUS_ACCESSIBILITY}.
705     * @return The node info of the focused view or null.
706     *
707     * @see #FOCUS_INPUT
708     * @see #FOCUS_ACCESSIBILITY
709     */
710    public AccessibilityNodeInfo findFocus(int focus) {
711        enforceSealed();
712        enforceValidFocusType(focus);
713        if (!canPerformRequestOverConnection(mSourceNodeId)) {
714            return null;
715        }
716        return AccessibilityInteractionClient.getInstance().findFocus(mConnectionId, mWindowId,
717                mSourceNodeId, focus);
718    }
719
720    /**
721     * Searches for the nearest view in the specified direction that can take
722     * the input focus.
723     *
724     * @param direction The direction. Can be one of:
725     *     {@link View#FOCUS_DOWN},
726     *     {@link View#FOCUS_UP},
727     *     {@link View#FOCUS_LEFT},
728     *     {@link View#FOCUS_RIGHT},
729     *     {@link View#FOCUS_FORWARD},
730     *     {@link View#FOCUS_BACKWARD}.
731     *
732     * @return The node info for the view that can take accessibility focus.
733     */
734    public AccessibilityNodeInfo focusSearch(int direction) {
735        enforceSealed();
736        enforceValidFocusDirection(direction);
737        if (!canPerformRequestOverConnection(mSourceNodeId)) {
738            return null;
739        }
740        return AccessibilityInteractionClient.getInstance().focusSearch(mConnectionId, mWindowId,
741                mSourceNodeId, direction);
742    }
743
744    /**
745     * Gets the id of the window from which the info comes from.
746     *
747     * @return The window id.
748     */
749    public int getWindowId() {
750        return mWindowId;
751    }
752
753    /**
754     * Refreshes this info with the latest state of the view it represents.
755     * <p>
756     * <strong>Note:</strong> If this method returns false this info is obsolete
757     * since it represents a view that is no longer in the view tree and should
758     * be recycled.
759     * </p>
760     *
761     * @param bypassCache Whether to bypass the cache.
762     * @return Whether the refresh succeeded.
763     *
764     * @hide
765     */
766    public boolean refresh(boolean bypassCache) {
767        enforceSealed();
768        if (!canPerformRequestOverConnection(mSourceNodeId)) {
769            return false;
770        }
771        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
772        AccessibilityNodeInfo refreshedInfo = client.findAccessibilityNodeInfoByAccessibilityId(
773                mConnectionId, mWindowId, mSourceNodeId, bypassCache, 0);
774        if (refreshedInfo == null) {
775            return false;
776        }
777        init(refreshedInfo);
778        refreshedInfo.recycle();
779        return true;
780    }
781
782    /**
783     * Refreshes this info with the latest state of the view it represents.
784     * <p>
785     * <strong>Note:</strong> If this method returns false this info is obsolete
786     * since it represents a view that is no longer in the view tree and should
787     * be recycled.
788     * </p>
789     * @return Whether the refresh succeeded.
790     */
791    public boolean refresh() {
792        return refresh(true);
793    }
794
795    /**
796     * Returns the array containing the IDs of this node's children.
797     *
798     * @hide
799     */
800    public LongArray getChildNodeIds() {
801        return mChildNodeIds;
802    }
803
804    /**
805     * Returns the id of the child at the specified index.
806     *
807     * @throws IndexOutOfBoundsException when index &lt; 0 || index &gt;=
808     *             getChildCount()
809     * @hide
810     */
811    public long getChildId(int index) {
812        if (mChildNodeIds == null) {
813            throw new IndexOutOfBoundsException();
814        }
815        return mChildNodeIds.get(index);
816    }
817
818    /**
819     * Gets the number of children.
820     *
821     * @return The child count.
822     */
823    public int getChildCount() {
824        return mChildNodeIds == null ? 0 : mChildNodeIds.size();
825    }
826
827    /**
828     * Get the child at given index.
829     * <p>
830     *   <strong>Note:</strong> It is a client responsibility to recycle the
831     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
832     *     to avoid creating of multiple instances.
833     * </p>
834     *
835     * @param index The child index.
836     * @return The child node.
837     *
838     * @throws IllegalStateException If called outside of an AccessibilityService.
839     *
840     */
841    public AccessibilityNodeInfo getChild(int index) {
842        enforceSealed();
843        if (mChildNodeIds == null) {
844            return null;
845        }
846        if (!canPerformRequestOverConnection(mSourceNodeId)) {
847            return null;
848        }
849        final long childId = mChildNodeIds.get(index);
850        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
851        return client.findAccessibilityNodeInfoByAccessibilityId(mConnectionId, mWindowId,
852                childId, false, FLAG_PREFETCH_DESCENDANTS);
853    }
854
855    /**
856     * Adds a child.
857     * <p>
858     * <strong>Note:</strong> Cannot be called from an
859     * {@link android.accessibilityservice.AccessibilityService}.
860     * This class is made immutable before being delivered to an AccessibilityService.
861     * </p>
862     *
863     * @param child The child.
864     *
865     * @throws IllegalStateException If called from an AccessibilityService.
866     */
867    public void addChild(View child) {
868        addChildInternal(child, UNDEFINED_ITEM_ID, true);
869    }
870
871    /**
872     * Unchecked version of {@link #addChild(View)} that does not verify
873     * uniqueness. For framework use only.
874     *
875     * @hide
876     */
877    public void addChildUnchecked(View child) {
878        addChildInternal(child, UNDEFINED_ITEM_ID, false);
879    }
880
881    /**
882     * Removes a child. If the child was not previously added to the node,
883     * calling this method has no effect.
884     * <p>
885     * <strong>Note:</strong> Cannot be called from an
886     * {@link android.accessibilityservice.AccessibilityService}.
887     * This class is made immutable before being delivered to an AccessibilityService.
888     * </p>
889     *
890     * @param child The child.
891     * @return true if the child was present
892     *
893     * @throws IllegalStateException If called from an AccessibilityService.
894     */
895    public boolean removeChild(View child) {
896        return removeChild(child, UNDEFINED_ITEM_ID);
897    }
898
899    /**
900     * Adds a virtual child which is a descendant of the given <code>root</code>.
901     * If <code>virtualDescendantId</code> is {@link View#NO_ID} the root
902     * is added as a child.
903     * <p>
904     * A virtual descendant is an imaginary View that is reported as a part of the view
905     * hierarchy for accessibility purposes. This enables custom views that draw complex
906     * content to report them selves as a tree of virtual views, thus conveying their
907     * logical structure.
908     * </p>
909     *
910     * @param root The root of the virtual subtree.
911     * @param virtualDescendantId The id of the virtual child.
912     */
913    public void addChild(View root, int virtualDescendantId) {
914        addChildInternal(root, virtualDescendantId, true);
915    }
916
917    private void addChildInternal(View root, int virtualDescendantId, boolean checked) {
918        enforceNotSealed();
919        if (mChildNodeIds == null) {
920            mChildNodeIds = new LongArray();
921        }
922        final int rootAccessibilityViewId =
923            (root != null) ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
924        final long childNodeId = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
925        // If we're checking uniqueness and the ID already exists, abort.
926        if (checked && mChildNodeIds.indexOf(childNodeId) >= 0) {
927            return;
928        }
929        mChildNodeIds.add(childNodeId);
930    }
931
932    /**
933     * Removes a virtual child which is a descendant of the given
934     * <code>root</code>. If the child was not previously added to the node,
935     * calling this method has no effect.
936     *
937     * @param root The root of the virtual subtree.
938     * @param virtualDescendantId The id of the virtual child.
939     * @return true if the child was present
940     * @see #addChild(View, int)
941     */
942    public boolean removeChild(View root, int virtualDescendantId) {
943        enforceNotSealed();
944        final LongArray childIds = mChildNodeIds;
945        if (childIds == null) {
946            return false;
947        }
948        final int rootAccessibilityViewId =
949                (root != null) ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
950        final long childNodeId = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
951        final int index = childIds.indexOf(childNodeId);
952        if (index < 0) {
953            return false;
954        }
955        childIds.remove(index);
956        return true;
957    }
958
959    /**
960     * Gets the actions that can be performed on the node.
961     */
962    public List<AccessibilityAction> getActionList() {
963        if (mActions == null) {
964            return Collections.emptyList();
965        }
966
967        return mActions;
968    }
969
970    /**
971     * Gets the actions that can be performed on the node.
972     *
973     * @return The bit mask of with actions.
974     *
975     * @see AccessibilityNodeInfo#ACTION_FOCUS
976     * @see AccessibilityNodeInfo#ACTION_CLEAR_FOCUS
977     * @see AccessibilityNodeInfo#ACTION_SELECT
978     * @see AccessibilityNodeInfo#ACTION_CLEAR_SELECTION
979     * @see AccessibilityNodeInfo#ACTION_ACCESSIBILITY_FOCUS
980     * @see AccessibilityNodeInfo#ACTION_CLEAR_ACCESSIBILITY_FOCUS
981     * @see AccessibilityNodeInfo#ACTION_CLICK
982     * @see AccessibilityNodeInfo#ACTION_LONG_CLICK
983     * @see AccessibilityNodeInfo#ACTION_NEXT_AT_MOVEMENT_GRANULARITY
984     * @see AccessibilityNodeInfo#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY
985     * @see AccessibilityNodeInfo#ACTION_NEXT_HTML_ELEMENT
986     * @see AccessibilityNodeInfo#ACTION_PREVIOUS_HTML_ELEMENT
987     * @see AccessibilityNodeInfo#ACTION_SCROLL_FORWARD
988     * @see AccessibilityNodeInfo#ACTION_SCROLL_BACKWARD
989     *
990     * @deprecated Use {@link #getActionList()}.
991     */
992    @Deprecated
993    public int getActions() {
994        int returnValue = 0;
995
996        if (mActions == null) {
997            return returnValue;
998        }
999
1000        final int actionSize = mActions.size();
1001        for (int i = 0; i < actionSize; i++) {
1002            int actionId = mActions.get(i).getId();
1003            if (actionId <= LAST_LEGACY_STANDARD_ACTION) {
1004                returnValue |= actionId;
1005            }
1006        }
1007
1008        return returnValue;
1009    }
1010
1011    /**
1012     * Adds an action that can be performed on the node.
1013     * <p>
1014     * To add a standard action use the static constants on {@link AccessibilityAction}.
1015     * To add a custom action create a new {@link AccessibilityAction} by passing in a
1016     * resource id from your application as the action id and an optional label that
1017     * describes the action. To override one of the standard actions use as the action
1018     * id of a standard action id such as {@link #ACTION_CLICK} and an optional label that
1019     * describes the action.
1020     * </p>
1021     * <p>
1022     *   <strong>Note:</strong> Cannot be called from an
1023     *   {@link android.accessibilityservice.AccessibilityService}.
1024     *   This class is made immutable before being delivered to an AccessibilityService.
1025     * </p>
1026     *
1027     * @param action The action.
1028     *
1029     * @throws IllegalStateException If called from an AccessibilityService.
1030     */
1031    public void addAction(AccessibilityAction action) {
1032        enforceNotSealed();
1033
1034        addActionUnchecked(action);
1035    }
1036
1037    private void addActionUnchecked(AccessibilityAction action) {
1038        if (action == null) {
1039            return;
1040        }
1041
1042        if (mActions == null) {
1043            mActions = new ArrayList<>();
1044        }
1045
1046        mActions.remove(action);
1047        mActions.add(action);
1048    }
1049
1050    /**
1051     * Adds an action that can be performed on the node.
1052     * <p>
1053     *   <strong>Note:</strong> Cannot be called from an
1054     *   {@link android.accessibilityservice.AccessibilityService}.
1055     *   This class is made immutable before being delivered to an AccessibilityService.
1056     * </p>
1057     *
1058     * @param action The action.
1059     *
1060     * @throws IllegalStateException If called from an AccessibilityService.
1061     * @throws IllegalArgumentException If the argument is not one of the standard actions.
1062     *
1063     * @deprecated This has been deprecated for {@link #addAction(AccessibilityAction)}
1064     */
1065    @Deprecated
1066    public void addAction(int action) {
1067        enforceNotSealed();
1068
1069        if ((action & ACTION_TYPE_MASK) != 0) {
1070            throw new IllegalArgumentException("Action is not a combination of the standard " +
1071                    "actions: " + action);
1072        }
1073
1074        addLegacyStandardActions(action);
1075    }
1076
1077    /**
1078     * Removes an action that can be performed on the node. If the action was
1079     * not already added to the node, calling this method has no effect.
1080     * <p>
1081     *   <strong>Note:</strong> Cannot be called from an
1082     *   {@link android.accessibilityservice.AccessibilityService}.
1083     *   This class is made immutable before being delivered to an AccessibilityService.
1084     * </p>
1085     *
1086     * @param action The action to be removed.
1087     *
1088     * @throws IllegalStateException If called from an AccessibilityService.
1089     * @deprecated Use {@link #removeAction(AccessibilityAction)}
1090     */
1091    @Deprecated
1092    public void removeAction(int action) {
1093        enforceNotSealed();
1094
1095        removeAction(getActionSingleton(action));
1096    }
1097
1098    /**
1099     * Removes an action that can be performed on the node. If the action was
1100     * not already added to the node, calling this method has no effect.
1101     * <p>
1102     *   <strong>Note:</strong> Cannot be called from an
1103     *   {@link android.accessibilityservice.AccessibilityService}.
1104     *   This class is made immutable before being delivered to an AccessibilityService.
1105     * </p>
1106     *
1107     * @param action The action to be removed.
1108     * @return The action removed from the list of actions.
1109     *
1110     * @throws IllegalStateException If called from an AccessibilityService.
1111     */
1112    public boolean removeAction(AccessibilityAction action) {
1113        enforceNotSealed();
1114
1115        if (mActions == null || action == null) {
1116            return false;
1117        }
1118
1119        return mActions.remove(action);
1120    }
1121
1122    /**
1123     * Gets the node before which this one is visited during traversal. A screen-reader
1124     * must visit the content of this node before the content of the one it precedes.
1125     *
1126     * @return The succeeding node if such or <code>null</code>.
1127     *
1128     * @see #setTraversalBefore(android.view.View)
1129     * @see #setTraversalBefore(android.view.View, int)
1130     */
1131    public AccessibilityNodeInfo getTraversalBefore() {
1132        enforceSealed();
1133        return getNodeForAccessibilityId(mTraversalBefore);
1134    }
1135
1136    /**
1137     * Sets the view before whose node this one should be visited during traversal. A
1138     * screen-reader must visit the content of this node before the content of the one
1139     * it precedes.
1140     * <p>
1141     *   <strong>Note:</strong> Cannot be called from an
1142     *   {@link android.accessibilityservice.AccessibilityService}.
1143     *   This class is made immutable before being delivered to an AccessibilityService.
1144     * </p>
1145     *
1146     * @param view The view providing the preceding node.
1147     *
1148     * @see #getTraversalBefore()
1149     */
1150    public void setTraversalBefore(View view) {
1151        setTraversalBefore(view, UNDEFINED_ITEM_ID);
1152    }
1153
1154    /**
1155     * Sets the node before which this one is visited during traversal. A screen-reader
1156     * must visit the content of this node before the content of the one it precedes.
1157     * The successor is a virtual descendant of the given <code>root</code>. If
1158     * <code>virtualDescendantId</code> equals to {@link View#NO_ID} the root is set
1159     * as the successor.
1160     * <p>
1161     * A virtual descendant is an imaginary View that is reported as a part of the view
1162     * hierarchy for accessibility purposes. This enables custom views that draw complex
1163     * content to report them selves as a tree of virtual views, thus conveying their
1164     * logical structure.
1165     * </p>
1166     * <p>
1167     *   <strong>Note:</strong> Cannot be called from an
1168     *   {@link android.accessibilityservice.AccessibilityService}.
1169     *   This class is made immutable before being delivered to an AccessibilityService.
1170     * </p>
1171     *
1172     * @param root The root of the virtual subtree.
1173     * @param virtualDescendantId The id of the virtual descendant.
1174     */
1175    public void setTraversalBefore(View root, int virtualDescendantId) {
1176        enforceNotSealed();
1177        final int rootAccessibilityViewId = (root != null)
1178                ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
1179        mTraversalBefore = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
1180    }
1181
1182    /**
1183     * Gets the node after which this one is visited in accessibility traversal.
1184     * A screen-reader must visit the content of the other node before the content
1185     * of this one.
1186     *
1187     * @return The succeeding node if such or <code>null</code>.
1188     *
1189     * @see #setTraversalAfter(android.view.View)
1190     * @see #setTraversalAfter(android.view.View, int)
1191     */
1192    public AccessibilityNodeInfo getTraversalAfter() {
1193        enforceSealed();
1194        return getNodeForAccessibilityId(mTraversalAfter);
1195    }
1196
1197    /**
1198     * Sets the view whose node is visited after this one in accessibility traversal.
1199     * A screen-reader must visit the content of the other node before the content
1200     * of this one.
1201     * <p>
1202     *   <strong>Note:</strong> Cannot be called from an
1203     *   {@link android.accessibilityservice.AccessibilityService}.
1204     *   This class is made immutable before being delivered to an AccessibilityService.
1205     * </p>
1206     *
1207     * @param view The previous view.
1208     *
1209     * @see #getTraversalAfter()
1210     */
1211    public void setTraversalAfter(View view) {
1212        setTraversalAfter(view, UNDEFINED_ITEM_ID);
1213    }
1214
1215    /**
1216     * Sets the node after which this one is visited in accessibility traversal.
1217     * A screen-reader must visit the content of the other node before the content
1218     * of this one. If <code>virtualDescendantId</code> equals to {@link View#NO_ID}
1219     * the root is set as the predecessor.
1220     * <p>
1221     * A virtual descendant is an imaginary View that is reported as a part of the view
1222     * hierarchy for accessibility purposes. This enables custom views that draw complex
1223     * content to report them selves as a tree of virtual views, thus conveying their
1224     * logical structure.
1225     * </p>
1226     * <p>
1227     *   <strong>Note:</strong> Cannot be called from an
1228     *   {@link android.accessibilityservice.AccessibilityService}.
1229     *   This class is made immutable before being delivered to an AccessibilityService.
1230     * </p>
1231     *
1232     * @param root The root of the virtual subtree.
1233     * @param virtualDescendantId The id of the virtual descendant.
1234     */
1235    public void setTraversalAfter(View root, int virtualDescendantId) {
1236        enforceNotSealed();
1237        final int rootAccessibilityViewId = (root != null)
1238                ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
1239        mTraversalAfter = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
1240    }
1241
1242    /**
1243     * Sets the maximum text length, or -1 for no limit.
1244     * <p>
1245     * Typically used to indicate that an editable text field has a limit on
1246     * the number of characters entered.
1247     * <p>
1248     * <strong>Note:</strong> Cannot be called from an
1249     * {@link android.accessibilityservice.AccessibilityService}.
1250     * This class is made immutable before being delivered to an AccessibilityService.
1251     *
1252     * @param max The maximum text length.
1253     * @see #getMaxTextLength()
1254     *
1255     * @throws IllegalStateException If called from an AccessibilityService.
1256     */
1257    public void setMaxTextLength(int max) {
1258        enforceNotSealed();
1259        mMaxTextLength = max;
1260    }
1261
1262    /**
1263     * Returns the maximum text length for this node.
1264     *
1265     * @return The maximum text length, or -1 for no limit.
1266     * @see #setMaxTextLength(int)
1267     */
1268    public int getMaxTextLength() {
1269        return mMaxTextLength;
1270    }
1271
1272    /**
1273     * Sets the movement granularities for traversing the text of this node.
1274     * <p>
1275     *   <strong>Note:</strong> Cannot be called from an
1276     *   {@link android.accessibilityservice.AccessibilityService}.
1277     *   This class is made immutable before being delivered to an AccessibilityService.
1278     * </p>
1279     *
1280     * @param granularities The bit mask with granularities.
1281     *
1282     * @throws IllegalStateException If called from an AccessibilityService.
1283     */
1284    public void setMovementGranularities(int granularities) {
1285        enforceNotSealed();
1286        mMovementGranularities = granularities;
1287    }
1288
1289    /**
1290     * Gets the movement granularities for traversing the text of this node.
1291     *
1292     * @return The bit mask with granularities.
1293     */
1294    public int getMovementGranularities() {
1295        return mMovementGranularities;
1296    }
1297
1298    /**
1299     * Performs an action on the node.
1300     * <p>
1301     *   <strong>Note:</strong> An action can be performed only if the request is made
1302     *   from an {@link android.accessibilityservice.AccessibilityService}.
1303     * </p>
1304     *
1305     * @param action The action to perform.
1306     * @return True if the action was performed.
1307     *
1308     * @throws IllegalStateException If called outside of an AccessibilityService.
1309     */
1310    public boolean performAction(int action) {
1311        enforceSealed();
1312        if (!canPerformRequestOverConnection(mSourceNodeId)) {
1313            return false;
1314        }
1315        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
1316        return client.performAccessibilityAction(mConnectionId, mWindowId, mSourceNodeId,
1317                action, null);
1318    }
1319
1320    /**
1321     * Performs an action on the node.
1322     * <p>
1323     *   <strong>Note:</strong> An action can be performed only if the request is made
1324     *   from an {@link android.accessibilityservice.AccessibilityService}.
1325     * </p>
1326     *
1327     * @param action The action to perform.
1328     * @param arguments A bundle with additional arguments.
1329     * @return True if the action was performed.
1330     *
1331     * @throws IllegalStateException If called outside of an AccessibilityService.
1332     */
1333    public boolean performAction(int action, Bundle arguments) {
1334        enforceSealed();
1335        if (!canPerformRequestOverConnection(mSourceNodeId)) {
1336            return false;
1337        }
1338        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
1339        return client.performAccessibilityAction(mConnectionId, mWindowId, mSourceNodeId,
1340                action, arguments);
1341    }
1342
1343    /**
1344     * Finds {@link AccessibilityNodeInfo}s by text. The match is case
1345     * insensitive containment. The search is relative to this info i.e.
1346     * this info is the root of the traversed tree.
1347     *
1348     * <p>
1349     *   <strong>Note:</strong> It is a client responsibility to recycle the
1350     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
1351     *     to avoid creating of multiple instances.
1352     * </p>
1353     *
1354     * @param text The searched text.
1355     * @return A list of node info.
1356     */
1357    public List<AccessibilityNodeInfo> findAccessibilityNodeInfosByText(String text) {
1358        enforceSealed();
1359        if (!canPerformRequestOverConnection(mSourceNodeId)) {
1360            return Collections.emptyList();
1361        }
1362        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
1363        return client.findAccessibilityNodeInfosByText(mConnectionId, mWindowId, mSourceNodeId,
1364                text);
1365    }
1366
1367    /**
1368     * Finds {@link AccessibilityNodeInfo}s by the fully qualified view id's resource
1369     * name where a fully qualified id is of the from "package:id/id_resource_name".
1370     * For example, if the target application's package is "foo.bar" and the id
1371     * resource name is "baz", the fully qualified resource id is "foo.bar:id/baz".
1372     *
1373     * <p>
1374     *   <strong>Note:</strong> It is a client responsibility to recycle the
1375     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
1376     *     to avoid creating of multiple instances.
1377     * </p>
1378     * <p>
1379     *   <strong>Note:</strong> The primary usage of this API is for UI test automation
1380     *   and in order to report the fully qualified view id if an {@link AccessibilityNodeInfo}
1381     *   the client has to set the {@link AccessibilityServiceInfo#FLAG_REPORT_VIEW_IDS}
1382     *   flag when configuring his {@link android.accessibilityservice.AccessibilityService}.
1383     * </p>
1384     *
1385     * @param viewId The fully qualified resource name of the view id to find.
1386     * @return A list of node info.
1387     */
1388    public List<AccessibilityNodeInfo> findAccessibilityNodeInfosByViewId(String viewId) {
1389        enforceSealed();
1390        if (!canPerformRequestOverConnection(mSourceNodeId)) {
1391            return Collections.emptyList();
1392        }
1393        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
1394        return client.findAccessibilityNodeInfosByViewId(mConnectionId, mWindowId, mSourceNodeId,
1395                viewId);
1396    }
1397
1398    /**
1399     * Gets the window to which this node belongs.
1400     *
1401     * @return The window.
1402     *
1403     * @see android.accessibilityservice.AccessibilityService#getWindows()
1404     */
1405    public AccessibilityWindowInfo getWindow() {
1406        enforceSealed();
1407        if (!canPerformRequestOverConnection(mSourceNodeId)) {
1408            return null;
1409        }
1410        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
1411        return client.getWindow(mConnectionId, mWindowId);
1412    }
1413
1414    /**
1415     * Gets the parent.
1416     * <p>
1417     *   <strong>Note:</strong> It is a client responsibility to recycle the
1418     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
1419     *     to avoid creating of multiple instances.
1420     * </p>
1421     *
1422     * @return The parent.
1423     */
1424    public AccessibilityNodeInfo getParent() {
1425        enforceSealed();
1426        return getNodeForAccessibilityId(mParentNodeId);
1427    }
1428
1429    /**
1430     * @return The parent node id.
1431     *
1432     * @hide
1433     */
1434    public long getParentNodeId() {
1435        return mParentNodeId;
1436    }
1437
1438    /**
1439     * Sets the parent.
1440     * <p>
1441     *   <strong>Note:</strong> Cannot be called from an
1442     *   {@link android.accessibilityservice.AccessibilityService}.
1443     *   This class is made immutable before being delivered to an AccessibilityService.
1444     * </p>
1445     *
1446     * @param parent The parent.
1447     *
1448     * @throws IllegalStateException If called from an AccessibilityService.
1449     */
1450    public void setParent(View parent) {
1451        setParent(parent, UNDEFINED_ITEM_ID);
1452    }
1453
1454    /**
1455     * Sets the parent to be a virtual descendant of the given <code>root</code>.
1456     * If <code>virtualDescendantId</code> equals to {@link View#NO_ID} the root
1457     * is set as the parent.
1458     * <p>
1459     * A virtual descendant is an imaginary View that is reported as a part of the view
1460     * hierarchy for accessibility purposes. This enables custom views that draw complex
1461     * content to report them selves as a tree of virtual views, thus conveying their
1462     * logical structure.
1463     * </p>
1464     * <p>
1465     *   <strong>Note:</strong> Cannot be called from an
1466     *   {@link android.accessibilityservice.AccessibilityService}.
1467     *   This class is made immutable before being delivered to an AccessibilityService.
1468     * </p>
1469     *
1470     * @param root The root of the virtual subtree.
1471     * @param virtualDescendantId The id of the virtual descendant.
1472     */
1473    public void setParent(View root, int virtualDescendantId) {
1474        enforceNotSealed();
1475        final int rootAccessibilityViewId =
1476            (root != null) ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
1477        mParentNodeId = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
1478    }
1479
1480    /**
1481     * Gets the node bounds in parent coordinates.
1482     *
1483     * @param outBounds The output node bounds.
1484     */
1485    public void getBoundsInParent(Rect outBounds) {
1486        outBounds.set(mBoundsInParent.left, mBoundsInParent.top,
1487                mBoundsInParent.right, mBoundsInParent.bottom);
1488    }
1489
1490    /**
1491     * Sets the node bounds in parent coordinates.
1492     * <p>
1493     *   <strong>Note:</strong> Cannot be called from an
1494     *   {@link android.accessibilityservice.AccessibilityService}.
1495     *   This class is made immutable before being delivered to an AccessibilityService.
1496     * </p>
1497     *
1498     * @param bounds The node bounds.
1499     *
1500     * @throws IllegalStateException If called from an AccessibilityService.
1501     */
1502    public void setBoundsInParent(Rect bounds) {
1503        enforceNotSealed();
1504        mBoundsInParent.set(bounds.left, bounds.top, bounds.right, bounds.bottom);
1505    }
1506
1507    /**
1508     * Gets the node bounds in screen coordinates.
1509     *
1510     * @param outBounds The output node bounds.
1511     */
1512    public void getBoundsInScreen(Rect outBounds) {
1513        outBounds.set(mBoundsInScreen.left, mBoundsInScreen.top,
1514                mBoundsInScreen.right, mBoundsInScreen.bottom);
1515    }
1516
1517    /**
1518     * Returns the actual rect containing the node bounds in screen coordinates.
1519     *
1520     * @hide Not safe to expose outside the framework.
1521     */
1522    public Rect getBoundsInScreen() {
1523        return mBoundsInScreen;
1524    }
1525
1526    /**
1527     * Sets the node bounds in screen coordinates.
1528     * <p>
1529     *   <strong>Note:</strong> Cannot be called from an
1530     *   {@link android.accessibilityservice.AccessibilityService}.
1531     *   This class is made immutable before being delivered to an AccessibilityService.
1532     * </p>
1533     *
1534     * @param bounds The node bounds.
1535     *
1536     * @throws IllegalStateException If called from an AccessibilityService.
1537     */
1538    public void setBoundsInScreen(Rect bounds) {
1539        enforceNotSealed();
1540        mBoundsInScreen.set(bounds.left, bounds.top, bounds.right, bounds.bottom);
1541    }
1542
1543    /**
1544     * Gets whether this node is checkable.
1545     *
1546     * @return True if the node is checkable.
1547     */
1548    public boolean isCheckable() {
1549        return getBooleanProperty(BOOLEAN_PROPERTY_CHECKABLE);
1550    }
1551
1552    /**
1553     * Sets whether this node is checkable.
1554     * <p>
1555     *   <strong>Note:</strong> Cannot be called from an
1556     *   {@link android.accessibilityservice.AccessibilityService}.
1557     *   This class is made immutable before being delivered to an AccessibilityService.
1558     * </p>
1559     *
1560     * @param checkable True if the node is checkable.
1561     *
1562     * @throws IllegalStateException If called from an AccessibilityService.
1563     */
1564    public void setCheckable(boolean checkable) {
1565        setBooleanProperty(BOOLEAN_PROPERTY_CHECKABLE, checkable);
1566    }
1567
1568    /**
1569     * Gets whether this node is checked.
1570     *
1571     * @return True if the node is checked.
1572     */
1573    public boolean isChecked() {
1574        return getBooleanProperty(BOOLEAN_PROPERTY_CHECKED);
1575    }
1576
1577    /**
1578     * Sets whether this node is checked.
1579     * <p>
1580     *   <strong>Note:</strong> Cannot be called from an
1581     *   {@link android.accessibilityservice.AccessibilityService}.
1582     *   This class is made immutable before being delivered to an AccessibilityService.
1583     * </p>
1584     *
1585     * @param checked True if the node is checked.
1586     *
1587     * @throws IllegalStateException If called from an AccessibilityService.
1588     */
1589    public void setChecked(boolean checked) {
1590        setBooleanProperty(BOOLEAN_PROPERTY_CHECKED, checked);
1591    }
1592
1593    /**
1594     * Gets whether this node is focusable.
1595     *
1596     * @return True if the node is focusable.
1597     */
1598    public boolean isFocusable() {
1599        return getBooleanProperty(BOOLEAN_PROPERTY_FOCUSABLE);
1600    }
1601
1602    /**
1603     * Sets whether this node is focusable.
1604     * <p>
1605     *   <strong>Note:</strong> Cannot be called from an
1606     *   {@link android.accessibilityservice.AccessibilityService}.
1607     *   This class is made immutable before being delivered to an AccessibilityService.
1608     * </p>
1609     *
1610     * @param focusable True if the node is focusable.
1611     *
1612     * @throws IllegalStateException If called from an AccessibilityService.
1613     */
1614    public void setFocusable(boolean focusable) {
1615        setBooleanProperty(BOOLEAN_PROPERTY_FOCUSABLE, focusable);
1616    }
1617
1618    /**
1619     * Gets whether this node is focused.
1620     *
1621     * @return True if the node is focused.
1622     */
1623    public boolean isFocused() {
1624        return getBooleanProperty(BOOLEAN_PROPERTY_FOCUSED);
1625    }
1626
1627    /**
1628     * Sets whether this node is focused.
1629     * <p>
1630     *   <strong>Note:</strong> Cannot be called from an
1631     *   {@link android.accessibilityservice.AccessibilityService}.
1632     *   This class is made immutable before being delivered to an AccessibilityService.
1633     * </p>
1634     *
1635     * @param focused True if the node is focused.
1636     *
1637     * @throws IllegalStateException If called from an AccessibilityService.
1638     */
1639    public void setFocused(boolean focused) {
1640        setBooleanProperty(BOOLEAN_PROPERTY_FOCUSED, focused);
1641    }
1642
1643    /**
1644     * Gets whether this node is visible to the user.
1645     *
1646     * @return Whether the node is visible to the user.
1647     */
1648    public boolean isVisibleToUser() {
1649        return getBooleanProperty(BOOLEAN_PROPERTY_VISIBLE_TO_USER);
1650    }
1651
1652    /**
1653     * Sets whether this node is visible to the user.
1654     * <p>
1655     *   <strong>Note:</strong> Cannot be called from an
1656     *   {@link android.accessibilityservice.AccessibilityService}.
1657     *   This class is made immutable before being delivered to an AccessibilityService.
1658     * </p>
1659     *
1660     * @param visibleToUser Whether the node is visible to the user.
1661     *
1662     * @throws IllegalStateException If called from an AccessibilityService.
1663     */
1664    public void setVisibleToUser(boolean visibleToUser) {
1665        setBooleanProperty(BOOLEAN_PROPERTY_VISIBLE_TO_USER, visibleToUser);
1666    }
1667
1668    /**
1669     * Gets whether this node is accessibility focused.
1670     *
1671     * @return True if the node is accessibility focused.
1672     */
1673    public boolean isAccessibilityFocused() {
1674        return getBooleanProperty(BOOLEAN_PROPERTY_ACCESSIBILITY_FOCUSED);
1675    }
1676
1677    /**
1678     * Sets whether this node is accessibility focused.
1679     * <p>
1680     *   <strong>Note:</strong> Cannot be called from an
1681     *   {@link android.accessibilityservice.AccessibilityService}.
1682     *   This class is made immutable before being delivered to an AccessibilityService.
1683     * </p>
1684     *
1685     * @param focused True if the node is accessibility focused.
1686     *
1687     * @throws IllegalStateException If called from an AccessibilityService.
1688     */
1689    public void setAccessibilityFocused(boolean focused) {
1690        setBooleanProperty(BOOLEAN_PROPERTY_ACCESSIBILITY_FOCUSED, focused);
1691    }
1692
1693    /**
1694     * Gets whether this node is selected.
1695     *
1696     * @return True if the node is selected.
1697     */
1698    public boolean isSelected() {
1699        return getBooleanProperty(BOOLEAN_PROPERTY_SELECTED);
1700    }
1701
1702    /**
1703     * Sets whether this node is selected.
1704     * <p>
1705     *   <strong>Note:</strong> Cannot be called from an
1706     *   {@link android.accessibilityservice.AccessibilityService}.
1707     *   This class is made immutable before being delivered to an AccessibilityService.
1708     * </p>
1709     *
1710     * @param selected True if the node is selected.
1711     *
1712     * @throws IllegalStateException If called from an AccessibilityService.
1713     */
1714    public void setSelected(boolean selected) {
1715        setBooleanProperty(BOOLEAN_PROPERTY_SELECTED, selected);
1716    }
1717
1718    /**
1719     * Gets whether this node is clickable.
1720     *
1721     * @return True if the node is clickable.
1722     */
1723    public boolean isClickable() {
1724        return getBooleanProperty(BOOLEAN_PROPERTY_CLICKABLE);
1725    }
1726
1727    /**
1728     * Sets whether this node is clickable.
1729     * <p>
1730     *   <strong>Note:</strong> Cannot be called from an
1731     *   {@link android.accessibilityservice.AccessibilityService}.
1732     *   This class is made immutable before being delivered to an AccessibilityService.
1733     * </p>
1734     *
1735     * @param clickable True if the node is clickable.
1736     *
1737     * @throws IllegalStateException If called from an AccessibilityService.
1738     */
1739    public void setClickable(boolean clickable) {
1740        setBooleanProperty(BOOLEAN_PROPERTY_CLICKABLE, clickable);
1741    }
1742
1743    /**
1744     * Gets whether this node is long clickable.
1745     *
1746     * @return True if the node is long clickable.
1747     */
1748    public boolean isLongClickable() {
1749        return getBooleanProperty(BOOLEAN_PROPERTY_LONG_CLICKABLE);
1750    }
1751
1752    /**
1753     * Sets whether this node is long clickable.
1754     * <p>
1755     *   <strong>Note:</strong> Cannot be called from an
1756     *   {@link android.accessibilityservice.AccessibilityService}.
1757     *   This class is made immutable before being delivered to an AccessibilityService.
1758     * </p>
1759     *
1760     * @param longClickable True if the node is long clickable.
1761     *
1762     * @throws IllegalStateException If called from an AccessibilityService.
1763     */
1764    public void setLongClickable(boolean longClickable) {
1765        setBooleanProperty(BOOLEAN_PROPERTY_LONG_CLICKABLE, longClickable);
1766    }
1767
1768    /**
1769     * Gets whether this node is enabled.
1770     *
1771     * @return True if the node is enabled.
1772     */
1773    public boolean isEnabled() {
1774        return getBooleanProperty(BOOLEAN_PROPERTY_ENABLED);
1775    }
1776
1777    /**
1778     * Sets whether this node is enabled.
1779     * <p>
1780     *   <strong>Note:</strong> Cannot be called from an
1781     *   {@link android.accessibilityservice.AccessibilityService}.
1782     *   This class is made immutable before being delivered to an AccessibilityService.
1783     * </p>
1784     *
1785     * @param enabled True if the node is enabled.
1786     *
1787     * @throws IllegalStateException If called from an AccessibilityService.
1788     */
1789    public void setEnabled(boolean enabled) {
1790        setBooleanProperty(BOOLEAN_PROPERTY_ENABLED, enabled);
1791    }
1792
1793    /**
1794     * Gets whether this node is a password.
1795     *
1796     * @return True if the node is a password.
1797     */
1798    public boolean isPassword() {
1799        return getBooleanProperty(BOOLEAN_PROPERTY_PASSWORD);
1800    }
1801
1802    /**
1803     * Sets whether this node is a password.
1804     * <p>
1805     *   <strong>Note:</strong> Cannot be called from an
1806     *   {@link android.accessibilityservice.AccessibilityService}.
1807     *   This class is made immutable before being delivered to an AccessibilityService.
1808     * </p>
1809     *
1810     * @param password True if the node is a password.
1811     *
1812     * @throws IllegalStateException If called from an AccessibilityService.
1813     */
1814    public void setPassword(boolean password) {
1815        setBooleanProperty(BOOLEAN_PROPERTY_PASSWORD, password);
1816    }
1817
1818    /**
1819     * Gets if the node is scrollable.
1820     *
1821     * @return True if the node is scrollable, false otherwise.
1822     */
1823    public boolean isScrollable() {
1824        return getBooleanProperty(BOOLEAN_PROPERTY_SCROLLABLE);
1825    }
1826
1827    /**
1828     * Sets if the node is scrollable.
1829     * <p>
1830     *   <strong>Note:</strong> Cannot be called from an
1831     *   {@link android.accessibilityservice.AccessibilityService}.
1832     *   This class is made immutable before being delivered to an AccessibilityService.
1833     * </p>
1834     *
1835     * @param scrollable True if the node is scrollable, false otherwise.
1836     *
1837     * @throws IllegalStateException If called from an AccessibilityService.
1838     */
1839    public void setScrollable(boolean scrollable) {
1840        setBooleanProperty(BOOLEAN_PROPERTY_SCROLLABLE, scrollable);
1841    }
1842
1843    /**
1844     * Gets if the node is editable.
1845     *
1846     * @return True if the node is editable, false otherwise.
1847     */
1848    public boolean isEditable() {
1849        return getBooleanProperty(BOOLEAN_PROPERTY_EDITABLE);
1850    }
1851
1852    /**
1853     * Sets whether this node is editable.
1854     * <p>
1855     *   <strong>Note:</strong> Cannot be called from an
1856     *   {@link android.accessibilityservice.AccessibilityService}.
1857     *   This class is made immutable before being delivered to an AccessibilityService.
1858     * </p>
1859     *
1860     * @param editable True if the node is editable.
1861     *
1862     * @throws IllegalStateException If called from an AccessibilityService.
1863     */
1864    public void setEditable(boolean editable) {
1865        setBooleanProperty(BOOLEAN_PROPERTY_EDITABLE, editable);
1866    }
1867
1868    /**
1869     * Get the drawing order of the view corresponding it this node.
1870     * <p>
1871     * Drawing order is determined only within the node's parent, so this index is only relative
1872     * to its siblings.
1873     * <p>
1874     * In some cases, the drawing order is essentially simultaneous, so it is possible for two
1875     * siblings to return the same value. It is also possible that values will be skipped.
1876     *
1877     * @return The drawing position of the view corresponding to this node relative to its siblings.
1878     */
1879    public int getDrawingOrder() {
1880        return mDrawingOrderInParent;
1881    }
1882
1883    /**
1884     * Set the drawing order of the view corresponding it this node.
1885     *
1886     * <p>
1887     *   <strong>Note:</strong> Cannot be called from an
1888     *   {@link android.accessibilityservice.AccessibilityService}.
1889     *   This class is made immutable before being delivered to an AccessibilityService.
1890     * </p>
1891     * @param drawingOrderInParent
1892     * @throws IllegalStateException If called from an AccessibilityService.
1893     */
1894    public void setDrawingOrder(int drawingOrderInParent) {
1895        enforceNotSealed();
1896        mDrawingOrderInParent = drawingOrderInParent;
1897    }
1898
1899    /**
1900     * Gets the collection info if the node is a collection. A collection
1901     * child is always a collection item.
1902     *
1903     * @return The collection info.
1904     */
1905    public CollectionInfo getCollectionInfo() {
1906        return mCollectionInfo;
1907    }
1908
1909    /**
1910     * Sets the collection info if the node is a collection. A collection
1911     * child is always a collection item.
1912     * <p>
1913     *   <strong>Note:</strong> Cannot be called from an
1914     *   {@link android.accessibilityservice.AccessibilityService}.
1915     *   This class is made immutable before being delivered to an AccessibilityService.
1916     * </p>
1917     *
1918     * @param collectionInfo The collection info.
1919     */
1920    public void setCollectionInfo(CollectionInfo collectionInfo) {
1921        enforceNotSealed();
1922        mCollectionInfo = collectionInfo;
1923    }
1924
1925    /**
1926     * Gets the collection item info if the node is a collection item. A collection
1927     * item is always a child of a collection.
1928     *
1929     * @return The collection item info.
1930     */
1931    public CollectionItemInfo getCollectionItemInfo() {
1932        return mCollectionItemInfo;
1933    }
1934
1935    /**
1936     * Sets the collection item info if the node is a collection item. A collection
1937     * item is always a child of a collection.
1938     * <p>
1939     *   <strong>Note:</strong> Cannot be called from an
1940     *   {@link android.accessibilityservice.AccessibilityService}.
1941     *   This class is made immutable before being delivered to an AccessibilityService.
1942     * </p>
1943     */
1944    public void setCollectionItemInfo(CollectionItemInfo collectionItemInfo) {
1945        enforceNotSealed();
1946        mCollectionItemInfo = collectionItemInfo;
1947    }
1948
1949    /**
1950     * Gets the range info if this node is a range.
1951     *
1952     * @return The range.
1953     */
1954    public RangeInfo getRangeInfo() {
1955        return mRangeInfo;
1956    }
1957
1958    /**
1959     * Sets the range info if this node is a range.
1960     * <p>
1961     *   <strong>Note:</strong> Cannot be called from an
1962     *   {@link android.accessibilityservice.AccessibilityService}.
1963     *   This class is made immutable before being delivered to an AccessibilityService.
1964     * </p>
1965     *
1966     * @param rangeInfo The range info.
1967     */
1968    public void setRangeInfo(RangeInfo rangeInfo) {
1969        enforceNotSealed();
1970        mRangeInfo = rangeInfo;
1971    }
1972
1973    /**
1974     * Gets if the content of this node is invalid. For example,
1975     * a date is not well-formed.
1976     *
1977     * @return If the node content is invalid.
1978     */
1979    public boolean isContentInvalid() {
1980        return getBooleanProperty(BOOLEAN_PROPERTY_CONTENT_INVALID);
1981    }
1982
1983    /**
1984     * Sets if the content of this node is invalid. For example,
1985     * a date is not well-formed.
1986     * <p>
1987     *   <strong>Note:</strong> Cannot be called from an
1988     *   {@link android.accessibilityservice.AccessibilityService}.
1989     *   This class is made immutable before being delivered to an AccessibilityService.
1990     * </p>
1991     *
1992     * @param contentInvalid If the node content is invalid.
1993     */
1994    public void setContentInvalid(boolean contentInvalid) {
1995        setBooleanProperty(BOOLEAN_PROPERTY_CONTENT_INVALID, contentInvalid);
1996    }
1997
1998    /**
1999     * Gets whether this node is context clickable.
2000     *
2001     * @return True if the node is context clickable.
2002     */
2003    public boolean isContextClickable() {
2004        return getBooleanProperty(BOOLEAN_PROPERTY_CONTEXT_CLICKABLE);
2005    }
2006
2007    /**
2008     * Sets whether this node is context clickable.
2009     * <p>
2010     * <strong>Note:</strong> Cannot be called from an
2011     * {@link android.accessibilityservice.AccessibilityService}. This class is made immutable
2012     * before being delivered to an AccessibilityService.
2013     * </p>
2014     *
2015     * @param contextClickable True if the node is context clickable.
2016     * @throws IllegalStateException If called from an AccessibilityService.
2017     */
2018    public void setContextClickable(boolean contextClickable) {
2019        setBooleanProperty(BOOLEAN_PROPERTY_CONTEXT_CLICKABLE, contextClickable);
2020    }
2021
2022    /**
2023     * Gets the node's live region mode.
2024     * <p>
2025     * A live region is a node that contains information that is important for
2026     * the user and when it changes the user should be notified. For example,
2027     * in a login screen with a TextView that displays an "incorrect password"
2028     * notification, that view should be marked as a live region with mode
2029     * {@link View#ACCESSIBILITY_LIVE_REGION_POLITE}.
2030     * <p>
2031     * It is the responsibility of the accessibility service to monitor
2032     * {@link AccessibilityEvent#TYPE_WINDOW_CONTENT_CHANGED} events indicating
2033     * changes to live region nodes and their children.
2034     *
2035     * @return The live region mode, or
2036     *         {@link View#ACCESSIBILITY_LIVE_REGION_NONE} if the view is not a
2037     *         live region.
2038     * @see android.view.View#getAccessibilityLiveRegion()
2039     */
2040    public int getLiveRegion() {
2041        return mLiveRegion;
2042    }
2043
2044    /**
2045     * Sets the node's live region mode.
2046     * <p>
2047     * <strong>Note:</strong> Cannot be called from an
2048     * {@link android.accessibilityservice.AccessibilityService}. This class is
2049     * made immutable before being delivered to an AccessibilityService.
2050     *
2051     * @param mode The live region mode, or
2052     *        {@link View#ACCESSIBILITY_LIVE_REGION_NONE} if the view is not a
2053     *        live region.
2054     * @see android.view.View#setAccessibilityLiveRegion(int)
2055     */
2056    public void setLiveRegion(int mode) {
2057        enforceNotSealed();
2058        mLiveRegion = mode;
2059    }
2060
2061    /**
2062     * Gets if the node is a multi line editable text.
2063     *
2064     * @return True if the node is multi line.
2065     */
2066    public boolean isMultiLine() {
2067        return getBooleanProperty(BOOLEAN_PROPERTY_MULTI_LINE);
2068    }
2069
2070    /**
2071     * Sets if the node is a multi line editable text.
2072     * <p>
2073     *   <strong>Note:</strong> Cannot be called from an
2074     *   {@link android.accessibilityservice.AccessibilityService}.
2075     *   This class is made immutable before being delivered to an AccessibilityService.
2076     * </p>
2077     *
2078     * @param multiLine True if the node is multi line.
2079     */
2080    public void setMultiLine(boolean multiLine) {
2081        setBooleanProperty(BOOLEAN_PROPERTY_MULTI_LINE, multiLine);
2082    }
2083
2084    /**
2085     * Gets if this node opens a popup or a dialog.
2086     *
2087     * @return If the the node opens a popup.
2088     */
2089    public boolean canOpenPopup() {
2090        return getBooleanProperty(BOOLEAN_PROPERTY_OPENS_POPUP);
2091    }
2092
2093    /**
2094     * Sets if this node opens a popup or a dialog.
2095     * <p>
2096     *   <strong>Note:</strong> Cannot be called from an
2097     *   {@link android.accessibilityservice.AccessibilityService}.
2098     *   This class is made immutable before being delivered to an AccessibilityService.
2099     * </p>
2100     *
2101     * @param opensPopup If the the node opens a popup.
2102     */
2103    public void setCanOpenPopup(boolean opensPopup) {
2104        enforceNotSealed();
2105        setBooleanProperty(BOOLEAN_PROPERTY_OPENS_POPUP, opensPopup);
2106    }
2107
2108    /**
2109     * Gets if the node can be dismissed.
2110     *
2111     * @return If the node can be dismissed.
2112     */
2113    public boolean isDismissable() {
2114        return getBooleanProperty(BOOLEAN_PROPERTY_DISMISSABLE);
2115    }
2116
2117    /**
2118     * Sets if the node can be dismissed.
2119     * <p>
2120     *   <strong>Note:</strong> Cannot be called from an
2121     *   {@link android.accessibilityservice.AccessibilityService}.
2122     *   This class is made immutable before being delivered to an AccessibilityService.
2123     * </p>
2124     *
2125     * @param dismissable If the node can be dismissed.
2126     */
2127    public void setDismissable(boolean dismissable) {
2128        setBooleanProperty(BOOLEAN_PROPERTY_DISMISSABLE, dismissable);
2129    }
2130
2131    /**
2132     * Returns whether the node originates from a view considered important for accessibility.
2133     *
2134     * @return {@code true} if the node originates from a view considered important for
2135     *         accessibility, {@code false} otherwise
2136     *
2137     * @see View#isImportantForAccessibility()
2138     */
2139    public boolean isImportantForAccessibility() {
2140        return getBooleanProperty(BOOLEAN_PROPERTY_IMPORTANCE);
2141    }
2142
2143    /**
2144     * Sets whether the node is considered important for accessibility.
2145     * <p>
2146     *   <strong>Note:</strong> Cannot be called from an
2147     *   {@link android.accessibilityservice.AccessibilityService}.
2148     *   This class is made immutable before being delivered to an AccessibilityService.
2149     * </p>
2150     *
2151     * @param important {@code true} if the node is considered important for accessibility,
2152     *                  {@code false} otherwise
2153     */
2154    public void setImportantForAccessibility(boolean important) {
2155        setBooleanProperty(BOOLEAN_PROPERTY_IMPORTANCE, important);
2156    }
2157
2158    /**
2159     * Gets the package this node comes from.
2160     *
2161     * @return The package name.
2162     */
2163    public CharSequence getPackageName() {
2164        return mPackageName;
2165    }
2166
2167    /**
2168     * Sets the package this node comes from.
2169     * <p>
2170     *   <strong>Note:</strong> Cannot be called from an
2171     *   {@link android.accessibilityservice.AccessibilityService}.
2172     *   This class is made immutable before being delivered to an AccessibilityService.
2173     * </p>
2174     *
2175     * @param packageName The package name.
2176     *
2177     * @throws IllegalStateException If called from an AccessibilityService.
2178     */
2179    public void setPackageName(CharSequence packageName) {
2180        enforceNotSealed();
2181        mPackageName = packageName;
2182    }
2183
2184    /**
2185     * Gets the class this node comes from.
2186     *
2187     * @return The class name.
2188     */
2189    public CharSequence getClassName() {
2190        return mClassName;
2191    }
2192
2193    /**
2194     * Sets the class this node comes from.
2195     * <p>
2196     *   <strong>Note:</strong> Cannot be called from an
2197     *   {@link android.accessibilityservice.AccessibilityService}.
2198     *   This class is made immutable before being delivered to an AccessibilityService.
2199     * </p>
2200     *
2201     * @param className The class name.
2202     *
2203     * @throws IllegalStateException If called from an AccessibilityService.
2204     */
2205    public void setClassName(CharSequence className) {
2206        enforceNotSealed();
2207        mClassName = className;
2208    }
2209
2210    /**
2211     * Gets the text of this node.
2212     *
2213     * @return The text.
2214     */
2215    public CharSequence getText() {
2216        return mText;
2217    }
2218
2219    /**
2220     * Sets the text of this node.
2221     * <p>
2222     *   <strong>Note:</strong> Cannot be called from an
2223     *   {@link android.accessibilityservice.AccessibilityService}.
2224     *   This class is made immutable before being delivered to an AccessibilityService.
2225     * </p>
2226     *
2227     * @param text The text.
2228     *
2229     * @throws IllegalStateException If called from an AccessibilityService.
2230     */
2231    public void setText(CharSequence text) {
2232        enforceNotSealed();
2233        mText = text;
2234    }
2235
2236    /**
2237     * Sets the error text of this node.
2238     * <p>
2239     *   <strong>Note:</strong> Cannot be called from an
2240     *   {@link android.accessibilityservice.AccessibilityService}.
2241     *   This class is made immutable before being delivered to an AccessibilityService.
2242     * </p>
2243     *
2244     * @param error The error text.
2245     *
2246     * @throws IllegalStateException If called from an AccessibilityService.
2247     */
2248    public void setError(CharSequence error) {
2249        enforceNotSealed();
2250        mError = error;
2251    }
2252
2253    /**
2254     * Gets the error text of this node.
2255     *
2256     * @return The error text.
2257     */
2258    public CharSequence getError() {
2259        return mError;
2260    }
2261
2262    /**
2263     * Gets the content description of this node.
2264     *
2265     * @return The content description.
2266     */
2267    public CharSequence getContentDescription() {
2268        return mContentDescription;
2269    }
2270
2271    /**
2272     * Sets the content description of this node.
2273     * <p>
2274     *   <strong>Note:</strong> Cannot be called from an
2275     *   {@link android.accessibilityservice.AccessibilityService}.
2276     *   This class is made immutable before being delivered to an AccessibilityService.
2277     * </p>
2278     *
2279     * @param contentDescription The content description.
2280     *
2281     * @throws IllegalStateException If called from an AccessibilityService.
2282     */
2283    public void setContentDescription(CharSequence contentDescription) {
2284        enforceNotSealed();
2285        mContentDescription = contentDescription;
2286    }
2287
2288    /**
2289     * Sets the view for which the view represented by this info serves as a
2290     * label for accessibility purposes.
2291     *
2292     * @param labeled The view for which this info serves as a label.
2293     */
2294    public void setLabelFor(View labeled) {
2295        setLabelFor(labeled, UNDEFINED_ITEM_ID);
2296    }
2297
2298    /**
2299     * Sets the view for which the view represented by this info serves as a
2300     * label for accessibility purposes. If <code>virtualDescendantId</code>
2301     * is {@link View#NO_ID} the root is set as the labeled.
2302     * <p>
2303     * A virtual descendant is an imaginary View that is reported as a part of the view
2304     * hierarchy for accessibility purposes. This enables custom views that draw complex
2305     * content to report themselves as a tree of virtual views, thus conveying their
2306     * logical structure.
2307     * </p>
2308     * <p>
2309     *   <strong>Note:</strong> Cannot be called from an
2310     *   {@link android.accessibilityservice.AccessibilityService}.
2311     *   This class is made immutable before being delivered to an AccessibilityService.
2312     * </p>
2313     *
2314     * @param root The root whose virtual descendant serves as a label.
2315     * @param virtualDescendantId The id of the virtual descendant.
2316     */
2317    public void setLabelFor(View root, int virtualDescendantId) {
2318        enforceNotSealed();
2319        final int rootAccessibilityViewId = (root != null)
2320                ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
2321        mLabelForId = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
2322    }
2323
2324    /**
2325     * Gets the node info for which the view represented by this info serves as
2326     * a label for accessibility purposes.
2327     * <p>
2328     *   <strong>Note:</strong> It is a client responsibility to recycle the
2329     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
2330     *     to avoid creating of multiple instances.
2331     * </p>
2332     *
2333     * @return The labeled info.
2334     */
2335    public AccessibilityNodeInfo getLabelFor() {
2336        enforceSealed();
2337        return getNodeForAccessibilityId(mLabelForId);
2338    }
2339
2340    /**
2341     * Sets the view which serves as the label of the view represented by
2342     * this info for accessibility purposes.
2343     *
2344     * @param label The view that labels this node's source.
2345     */
2346    public void setLabeledBy(View label) {
2347        setLabeledBy(label, UNDEFINED_ITEM_ID);
2348    }
2349
2350    /**
2351     * Sets the view which serves as the label of the view represented by
2352     * this info for accessibility purposes. If <code>virtualDescendantId</code>
2353     * is {@link View#NO_ID} the root is set as the label.
2354     * <p>
2355     * A virtual descendant is an imaginary View that is reported as a part of the view
2356     * hierarchy for accessibility purposes. This enables custom views that draw complex
2357     * content to report themselves as a tree of virtual views, thus conveying their
2358     * logical structure.
2359     * </p>
2360     * <p>
2361     *   <strong>Note:</strong> Cannot be called from an
2362     *   {@link android.accessibilityservice.AccessibilityService}.
2363     *   This class is made immutable before being delivered to an AccessibilityService.
2364     * </p>
2365     *
2366     * @param root The root whose virtual descendant labels this node's source.
2367     * @param virtualDescendantId The id of the virtual descendant.
2368     */
2369    public void setLabeledBy(View root, int virtualDescendantId) {
2370        enforceNotSealed();
2371        final int rootAccessibilityViewId = (root != null)
2372                ? root.getAccessibilityViewId() : UNDEFINED_ITEM_ID;
2373        mLabeledById = makeNodeId(rootAccessibilityViewId, virtualDescendantId);
2374    }
2375
2376    /**
2377     * Gets the node info which serves as the label of the view represented by
2378     * this info for accessibility purposes.
2379     * <p>
2380     *   <strong>Note:</strong> It is a client responsibility to recycle the
2381     *     received info by calling {@link AccessibilityNodeInfo#recycle()}
2382     *     to avoid creating of multiple instances.
2383     * </p>
2384     *
2385     * @return The label.
2386     */
2387    public AccessibilityNodeInfo getLabeledBy() {
2388        enforceSealed();
2389        return getNodeForAccessibilityId(mLabeledById);
2390    }
2391
2392    /**
2393     * Sets the fully qualified resource name of the source view's id.
2394     *
2395     * <p>
2396     *   <strong>Note:</strong> Cannot be called from an
2397     *   {@link android.accessibilityservice.AccessibilityService}.
2398     *   This class is made immutable before being delivered to an AccessibilityService.
2399     * </p>
2400     *
2401     * @param viewIdResName The id resource name.
2402     */
2403    public void setViewIdResourceName(String viewIdResName) {
2404        enforceNotSealed();
2405        mViewIdResourceName = viewIdResName;
2406    }
2407
2408    /**
2409     * Gets the fully qualified resource name of the source view's id.
2410     *
2411     * <p>
2412     *   <strong>Note:</strong> The primary usage of this API is for UI test automation
2413     *   and in order to report the source view id of an {@link AccessibilityNodeInfo} the
2414     *   client has to set the {@link AccessibilityServiceInfo#FLAG_REPORT_VIEW_IDS}
2415     *   flag when configuring his {@link android.accessibilityservice.AccessibilityService}.
2416     * </p>
2417
2418     * @return The id resource name.
2419     */
2420    public String getViewIdResourceName() {
2421        return mViewIdResourceName;
2422    }
2423
2424    /**
2425     * Gets the text selection start or the cursor position.
2426     * <p>
2427     * If no text is selected, both this method and
2428     * {@link AccessibilityNodeInfo#getTextSelectionEnd()} return the same value:
2429     * the current location of the cursor.
2430     * </p>
2431     *
2432     * @return The text selection start, the cursor location if there is no selection, or -1 if
2433     *         there is no text selection and no cursor.
2434     */
2435    public int getTextSelectionStart() {
2436        return mTextSelectionStart;
2437    }
2438
2439    /**
2440     * Gets the text selection end if text is selected.
2441     * <p>
2442     * If no text is selected, both this method and
2443     * {@link AccessibilityNodeInfo#getTextSelectionStart()} return the same value:
2444     * the current location of the cursor.
2445     * </p>
2446     *
2447     * @return The text selection end, the cursor location if there is no selection, or -1 if
2448     *         there is no text selection and no cursor.
2449     */
2450    public int getTextSelectionEnd() {
2451        return mTextSelectionEnd;
2452    }
2453
2454    /**
2455     * Sets the text selection start and end.
2456     * <p>
2457     *   <strong>Note:</strong> Cannot be called from an
2458     *   {@link android.accessibilityservice.AccessibilityService}.
2459     *   This class is made immutable before being delivered to an AccessibilityService.
2460     * </p>
2461     *
2462     * @param start The text selection start.
2463     * @param end The text selection end.
2464     *
2465     * @throws IllegalStateException If called from an AccessibilityService.
2466     */
2467    public void setTextSelection(int start, int end) {
2468        enforceNotSealed();
2469        mTextSelectionStart = start;
2470        mTextSelectionEnd = end;
2471    }
2472
2473    /**
2474     * Gets the input type of the source as defined by {@link InputType}.
2475     *
2476     * @return The input type.
2477     */
2478    public int getInputType() {
2479        return mInputType;
2480    }
2481
2482    /**
2483     * Sets the input type of the source as defined by {@link InputType}.
2484     * <p>
2485     *   <strong>Note:</strong> Cannot be called from an
2486     *   {@link android.accessibilityservice.AccessibilityService}.
2487     *   This class is made immutable before being delivered to an
2488     *   AccessibilityService.
2489     * </p>
2490     *
2491     * @param inputType The input type.
2492     *
2493     * @throws IllegalStateException If called from an AccessibilityService.
2494     */
2495    public void setInputType(int inputType) {
2496        enforceNotSealed();
2497        mInputType = inputType;
2498    }
2499
2500    /**
2501     * Gets an optional bundle with extra data. The bundle
2502     * is lazily created and never <code>null</code>.
2503     * <p>
2504     * <strong>Note:</strong> It is recommended to use the package
2505     * name of your application as a prefix for the keys to avoid
2506     * collisions which may confuse an accessibility service if the
2507     * same key has different meaning when emitted from different
2508     * applications.
2509     * </p>
2510     *
2511     * @return The bundle.
2512     */
2513    public Bundle getExtras() {
2514        if (mExtras == null) {
2515            mExtras = new Bundle();
2516        }
2517        return mExtras;
2518    }
2519
2520    /**
2521     * Gets the value of a boolean property.
2522     *
2523     * @param property The property.
2524     * @return The value.
2525     */
2526    private boolean getBooleanProperty(int property) {
2527        return (mBooleanProperties & property) != 0;
2528    }
2529
2530    /**
2531     * Sets a boolean property.
2532     *
2533     * @param property The property.
2534     * @param value The value.
2535     *
2536     * @throws IllegalStateException If called from an AccessibilityService.
2537     */
2538    private void setBooleanProperty(int property, boolean value) {
2539        enforceNotSealed();
2540        if (value) {
2541            mBooleanProperties |= property;
2542        } else {
2543            mBooleanProperties &= ~property;
2544        }
2545    }
2546
2547    /**
2548     * Sets the unique id of the IAccessibilityServiceConnection over which
2549     * this instance can send requests to the system.
2550     *
2551     * @param connectionId The connection id.
2552     *
2553     * @hide
2554     */
2555    public void setConnectionId(int connectionId) {
2556        enforceNotSealed();
2557        mConnectionId = connectionId;
2558    }
2559
2560    /**
2561     * {@inheritDoc}
2562     */
2563    @Override
2564    public int describeContents() {
2565        return 0;
2566    }
2567
2568    /**
2569     * Gets the id of the source node.
2570     *
2571     * @return The id.
2572     *
2573     * @hide
2574     */
2575    public long getSourceNodeId() {
2576        return mSourceNodeId;
2577    }
2578
2579    /**
2580     * Sets if this instance is sealed.
2581     *
2582     * @param sealed Whether is sealed.
2583     *
2584     * @hide
2585     */
2586    public void setSealed(boolean sealed) {
2587        mSealed = sealed;
2588    }
2589
2590    /**
2591     * Gets if this instance is sealed.
2592     *
2593     * @return Whether is sealed.
2594     *
2595     * @hide
2596     */
2597    public boolean isSealed() {
2598        return mSealed;
2599    }
2600
2601    /**
2602     * Enforces that this instance is sealed.
2603     *
2604     * @throws IllegalStateException If this instance is not sealed.
2605     *
2606     * @hide
2607     */
2608    protected void enforceSealed() {
2609        if (!isSealed()) {
2610            throw new IllegalStateException("Cannot perform this "
2611                    + "action on a not sealed instance.");
2612        }
2613    }
2614
2615    private void enforceValidFocusDirection(int direction) {
2616        switch (direction) {
2617            case View.FOCUS_DOWN:
2618            case View.FOCUS_UP:
2619            case View.FOCUS_LEFT:
2620            case View.FOCUS_RIGHT:
2621            case View.FOCUS_FORWARD:
2622            case View.FOCUS_BACKWARD:
2623                return;
2624            default:
2625                throw new IllegalArgumentException("Unknown direction: " + direction);
2626        }
2627    }
2628
2629    private void enforceValidFocusType(int focusType) {
2630        switch (focusType) {
2631            case FOCUS_INPUT:
2632            case FOCUS_ACCESSIBILITY:
2633                return;
2634            default:
2635                throw new IllegalArgumentException("Unknown focus type: " + focusType);
2636        }
2637    }
2638
2639    /**
2640     * Enforces that this instance is not sealed.
2641     *
2642     * @throws IllegalStateException If this instance is sealed.
2643     *
2644     * @hide
2645     */
2646    protected void enforceNotSealed() {
2647        if (isSealed()) {
2648            throw new IllegalStateException("Cannot perform this "
2649                    + "action on a sealed instance.");
2650        }
2651    }
2652
2653    /**
2654     * Returns a cached instance if such is available otherwise a new one
2655     * and sets the source.
2656     *
2657     * @param source The source view.
2658     * @return An instance.
2659     *
2660     * @see #setSource(View)
2661     */
2662    public static AccessibilityNodeInfo obtain(View source) {
2663        AccessibilityNodeInfo info = AccessibilityNodeInfo.obtain();
2664        info.setSource(source);
2665        return info;
2666    }
2667
2668    /**
2669     * Returns a cached instance if such is available otherwise a new one
2670     * and sets the source.
2671     *
2672     * @param root The root of the virtual subtree.
2673     * @param virtualDescendantId The id of the virtual descendant.
2674     * @return An instance.
2675     *
2676     * @see #setSource(View, int)
2677     */
2678    public static AccessibilityNodeInfo obtain(View root, int virtualDescendantId) {
2679        AccessibilityNodeInfo info = AccessibilityNodeInfo.obtain();
2680        info.setSource(root, virtualDescendantId);
2681        return info;
2682    }
2683
2684    /**
2685     * Returns a cached instance if such is available otherwise a new one.
2686     *
2687     * @return An instance.
2688     */
2689    public static AccessibilityNodeInfo obtain() {
2690        AccessibilityNodeInfo info = sPool.acquire();
2691        return (info != null) ? info : new AccessibilityNodeInfo();
2692    }
2693
2694    /**
2695     * Returns a cached instance if such is available or a new one is
2696     * create. The returned instance is initialized from the given
2697     * <code>info</code>.
2698     *
2699     * @param info The other info.
2700     * @return An instance.
2701     */
2702    public static AccessibilityNodeInfo obtain(AccessibilityNodeInfo info) {
2703        AccessibilityNodeInfo infoClone = AccessibilityNodeInfo.obtain();
2704        infoClone.init(info);
2705        return infoClone;
2706    }
2707
2708    /**
2709     * Return an instance back to be reused.
2710     * <p>
2711     * <strong>Note:</strong> You must not touch the object after calling this function.
2712     *
2713     * @throws IllegalStateException If the info is already recycled.
2714     */
2715    public void recycle() {
2716        clear();
2717        sPool.release(this);
2718    }
2719
2720    /**
2721     * {@inheritDoc}
2722     * <p>
2723     *   <strong>Note:</strong> After the instance is written to a parcel it
2724     *      is recycled. You must not touch the object after calling this function.
2725     * </p>
2726     */
2727    @Override
2728    public void writeToParcel(Parcel parcel, int flags) {
2729        parcel.writeInt(isSealed() ? 1 : 0);
2730        parcel.writeLong(mSourceNodeId);
2731        parcel.writeInt(mWindowId);
2732        parcel.writeLong(mParentNodeId);
2733        parcel.writeLong(mLabelForId);
2734        parcel.writeLong(mLabeledById);
2735        parcel.writeLong(mTraversalBefore);
2736        parcel.writeLong(mTraversalAfter);
2737
2738        parcel.writeInt(mConnectionId);
2739
2740        final LongArray childIds = mChildNodeIds;
2741        if (childIds == null) {
2742            parcel.writeInt(0);
2743        } else {
2744            final int childIdsSize = childIds.size();
2745            parcel.writeInt(childIdsSize);
2746            for (int i = 0; i < childIdsSize; i++) {
2747                parcel.writeLong(childIds.get(i));
2748            }
2749        }
2750
2751        parcel.writeInt(mBoundsInParent.top);
2752        parcel.writeInt(mBoundsInParent.bottom);
2753        parcel.writeInt(mBoundsInParent.left);
2754        parcel.writeInt(mBoundsInParent.right);
2755
2756        parcel.writeInt(mBoundsInScreen.top);
2757        parcel.writeInt(mBoundsInScreen.bottom);
2758        parcel.writeInt(mBoundsInScreen.left);
2759        parcel.writeInt(mBoundsInScreen.right);
2760
2761        if (mActions != null && !mActions.isEmpty()) {
2762            final int actionCount = mActions.size();
2763            parcel.writeInt(actionCount);
2764
2765            int defaultLegacyStandardActions = 0;
2766            for (int i = 0; i < actionCount; i++) {
2767                AccessibilityAction action = mActions.get(i);
2768                if (isDefaultLegacyStandardAction(action)) {
2769                    defaultLegacyStandardActions |= action.getId();
2770                }
2771            }
2772            parcel.writeInt(defaultLegacyStandardActions);
2773
2774            for (int i = 0; i < actionCount; i++) {
2775                AccessibilityAction action = mActions.get(i);
2776                if (!isDefaultLegacyStandardAction(action)) {
2777                    parcel.writeInt(action.getId());
2778                    parcel.writeCharSequence(action.getLabel());
2779                }
2780            }
2781        } else {
2782            parcel.writeInt(0);
2783        }
2784
2785        parcel.writeInt(mMaxTextLength);
2786        parcel.writeInt(mMovementGranularities);
2787        parcel.writeInt(mBooleanProperties);
2788
2789        parcel.writeCharSequence(mPackageName);
2790        parcel.writeCharSequence(mClassName);
2791        parcel.writeCharSequence(mText);
2792        parcel.writeCharSequence(mError);
2793        parcel.writeCharSequence(mContentDescription);
2794        parcel.writeString(mViewIdResourceName);
2795
2796        parcel.writeInt(mTextSelectionStart);
2797        parcel.writeInt(mTextSelectionEnd);
2798        parcel.writeInt(mInputType);
2799        parcel.writeInt(mLiveRegion);
2800        parcel.writeInt(mDrawingOrderInParent);
2801
2802        if (mExtras != null) {
2803            parcel.writeInt(1);
2804            parcel.writeBundle(mExtras);
2805        } else {
2806            parcel.writeInt(0);
2807        }
2808
2809        if (mRangeInfo != null) {
2810            parcel.writeInt(1);
2811            parcel.writeInt(mRangeInfo.getType());
2812            parcel.writeFloat(mRangeInfo.getMin());
2813            parcel.writeFloat(mRangeInfo.getMax());
2814            parcel.writeFloat(mRangeInfo.getCurrent());
2815        } else {
2816            parcel.writeInt(0);
2817        }
2818
2819        if (mCollectionInfo != null) {
2820            parcel.writeInt(1);
2821            parcel.writeInt(mCollectionInfo.getRowCount());
2822            parcel.writeInt(mCollectionInfo.getColumnCount());
2823            parcel.writeInt(mCollectionInfo.isHierarchical() ? 1 : 0);
2824            parcel.writeInt(mCollectionInfo.getSelectionMode());
2825        } else {
2826            parcel.writeInt(0);
2827        }
2828
2829        if (mCollectionItemInfo != null) {
2830            parcel.writeInt(1);
2831            parcel.writeInt(mCollectionItemInfo.getRowIndex());
2832            parcel.writeInt(mCollectionItemInfo.getRowSpan());
2833            parcel.writeInt(mCollectionItemInfo.getColumnIndex());
2834            parcel.writeInt(mCollectionItemInfo.getColumnSpan());
2835            parcel.writeInt(mCollectionItemInfo.isHeading() ? 1 : 0);
2836            parcel.writeInt(mCollectionItemInfo.isSelected() ? 1 : 0);
2837        } else {
2838            parcel.writeInt(0);
2839        }
2840
2841        // Since instances of this class are fetched via synchronous i.e. blocking
2842        // calls in IPCs we always recycle as soon as the instance is marshaled.
2843        recycle();
2844    }
2845
2846    /**
2847     * Initializes this instance from another one.
2848     *
2849     * @param other The other instance.
2850     */
2851    private void init(AccessibilityNodeInfo other) {
2852        mSealed = other.mSealed;
2853        mSourceNodeId = other.mSourceNodeId;
2854        mParentNodeId = other.mParentNodeId;
2855        mLabelForId = other.mLabelForId;
2856        mLabeledById = other.mLabeledById;
2857        mTraversalBefore = other.mTraversalBefore;
2858        mTraversalAfter = other.mTraversalAfter;
2859        mWindowId = other.mWindowId;
2860        mConnectionId = other.mConnectionId;
2861        mBoundsInParent.set(other.mBoundsInParent);
2862        mBoundsInScreen.set(other.mBoundsInScreen);
2863        mPackageName = other.mPackageName;
2864        mClassName = other.mClassName;
2865        mText = other.mText;
2866        mError = other.mError;
2867        mContentDescription = other.mContentDescription;
2868        mViewIdResourceName = other.mViewIdResourceName;
2869
2870        final ArrayList<AccessibilityAction> otherActions = other.mActions;
2871        if (otherActions != null && otherActions.size() > 0) {
2872            if (mActions == null) {
2873                mActions = new ArrayList(otherActions);
2874            } else {
2875                mActions.clear();
2876                mActions.addAll(other.mActions);
2877            }
2878        }
2879
2880        mBooleanProperties = other.mBooleanProperties;
2881        mMaxTextLength = other.mMaxTextLength;
2882        mMovementGranularities = other.mMovementGranularities;
2883
2884        final LongArray otherChildNodeIds = other.mChildNodeIds;
2885        if (otherChildNodeIds != null && otherChildNodeIds.size() > 0) {
2886            if (mChildNodeIds == null) {
2887                mChildNodeIds = otherChildNodeIds.clone();
2888            } else {
2889                mChildNodeIds.clear();
2890                mChildNodeIds.addAll(otherChildNodeIds);
2891            }
2892        }
2893
2894        mTextSelectionStart = other.mTextSelectionStart;
2895        mTextSelectionEnd = other.mTextSelectionEnd;
2896        mInputType = other.mInputType;
2897        mLiveRegion = other.mLiveRegion;
2898        mDrawingOrderInParent = other.mDrawingOrderInParent;
2899        if (other.mExtras != null) {
2900            mExtras = new Bundle(other.mExtras);
2901        } else {
2902            mExtras = null;
2903        }
2904        mRangeInfo = (other.mRangeInfo != null)
2905                ? RangeInfo.obtain(other.mRangeInfo) : null;
2906        mCollectionInfo = (other.mCollectionInfo != null)
2907                ? CollectionInfo.obtain(other.mCollectionInfo) : null;
2908        mCollectionItemInfo =  (other.mCollectionItemInfo != null)
2909                ? CollectionItemInfo.obtain(other.mCollectionItemInfo) : null;
2910    }
2911
2912    /**
2913     * Creates a new instance from a {@link Parcel}.
2914     *
2915     * @param parcel A parcel containing the state of a {@link AccessibilityNodeInfo}.
2916     */
2917    private void initFromParcel(Parcel parcel) {
2918        final boolean sealed = (parcel.readInt()  == 1);
2919        mSourceNodeId = parcel.readLong();
2920        mWindowId = parcel.readInt();
2921        mParentNodeId = parcel.readLong();
2922        mLabelForId = parcel.readLong();
2923        mLabeledById = parcel.readLong();
2924        mTraversalBefore = parcel.readLong();
2925        mTraversalAfter = parcel.readLong();
2926
2927        mConnectionId = parcel.readInt();
2928
2929        final int childrenSize = parcel.readInt();
2930        if (childrenSize <= 0) {
2931            mChildNodeIds = null;
2932        } else {
2933            mChildNodeIds = new LongArray(childrenSize);
2934            for (int i = 0; i < childrenSize; i++) {
2935                final long childId = parcel.readLong();
2936                mChildNodeIds.add(childId);
2937            }
2938        }
2939
2940        mBoundsInParent.top = parcel.readInt();
2941        mBoundsInParent.bottom = parcel.readInt();
2942        mBoundsInParent.left = parcel.readInt();
2943        mBoundsInParent.right = parcel.readInt();
2944
2945        mBoundsInScreen.top = parcel.readInt();
2946        mBoundsInScreen.bottom = parcel.readInt();
2947        mBoundsInScreen.left = parcel.readInt();
2948        mBoundsInScreen.right = parcel.readInt();
2949
2950        final int actionCount = parcel.readInt();
2951        if (actionCount > 0) {
2952            final int legacyStandardActions = parcel.readInt();
2953            addLegacyStandardActions(legacyStandardActions);
2954            final int nonLegacyActionCount = actionCount - Integer.bitCount(legacyStandardActions);
2955            for (int i = 0; i < nonLegacyActionCount; i++) {
2956                final AccessibilityAction action = new AccessibilityAction(
2957                        parcel.readInt(), parcel.readCharSequence());
2958                addActionUnchecked(action);
2959            }
2960        }
2961
2962        mMaxTextLength = parcel.readInt();
2963        mMovementGranularities = parcel.readInt();
2964        mBooleanProperties = parcel.readInt();
2965
2966        mPackageName = parcel.readCharSequence();
2967        mClassName = parcel.readCharSequence();
2968        mText = parcel.readCharSequence();
2969        mError = parcel.readCharSequence();
2970        mContentDescription = parcel.readCharSequence();
2971        mViewIdResourceName = parcel.readString();
2972
2973        mTextSelectionStart = parcel.readInt();
2974        mTextSelectionEnd = parcel.readInt();
2975
2976        mInputType = parcel.readInt();
2977        mLiveRegion = parcel.readInt();
2978        mDrawingOrderInParent = parcel.readInt();
2979
2980        if (parcel.readInt() == 1) {
2981            mExtras = parcel.readBundle();
2982        } else {
2983            mExtras = null;
2984        }
2985
2986        if (parcel.readInt() == 1) {
2987            mRangeInfo = RangeInfo.obtain(
2988                    parcel.readInt(),
2989                    parcel.readFloat(),
2990                    parcel.readFloat(),
2991                    parcel.readFloat());
2992        }
2993
2994        if (parcel.readInt() == 1) {
2995            mCollectionInfo = CollectionInfo.obtain(
2996                    parcel.readInt(),
2997                    parcel.readInt(),
2998                    parcel.readInt() == 1,
2999                    parcel.readInt());
3000        }
3001
3002        if (parcel.readInt() == 1) {
3003            mCollectionItemInfo = CollectionItemInfo.obtain(
3004                    parcel.readInt(),
3005                    parcel.readInt(),
3006                    parcel.readInt(),
3007                    parcel.readInt(),
3008                    parcel.readInt() == 1,
3009                    parcel.readInt() == 1);
3010        }
3011
3012        mSealed = sealed;
3013    }
3014
3015    /**
3016     * Clears the state of this instance.
3017     */
3018    private void clear() {
3019        mSealed = false;
3020        mSourceNodeId = ROOT_NODE_ID;
3021        mParentNodeId = ROOT_NODE_ID;
3022        mLabelForId = ROOT_NODE_ID;
3023        mLabeledById = ROOT_NODE_ID;
3024        mTraversalBefore = ROOT_NODE_ID;
3025        mTraversalAfter = ROOT_NODE_ID;
3026        mWindowId = UNDEFINED_ITEM_ID;
3027        mConnectionId = UNDEFINED_CONNECTION_ID;
3028        mMaxTextLength = -1;
3029        mMovementGranularities = 0;
3030        if (mChildNodeIds != null) {
3031            mChildNodeIds.clear();
3032        }
3033        mBoundsInParent.set(0, 0, 0, 0);
3034        mBoundsInScreen.set(0, 0, 0, 0);
3035        mBooleanProperties = 0;
3036        mDrawingOrderInParent = 0;
3037        mPackageName = null;
3038        mClassName = null;
3039        mText = null;
3040        mError = null;
3041        mContentDescription = null;
3042        mViewIdResourceName = null;
3043        if (mActions != null) {
3044            mActions.clear();
3045        }
3046        mTextSelectionStart = UNDEFINED_SELECTION_INDEX;
3047        mTextSelectionEnd = UNDEFINED_SELECTION_INDEX;
3048        mInputType = InputType.TYPE_NULL;
3049        mLiveRegion = View.ACCESSIBILITY_LIVE_REGION_NONE;
3050        mExtras = null;
3051        if (mRangeInfo != null) {
3052            mRangeInfo.recycle();
3053            mRangeInfo = null;
3054        }
3055        if (mCollectionInfo != null) {
3056            mCollectionInfo.recycle();
3057            mCollectionInfo = null;
3058        }
3059        if (mCollectionItemInfo != null) {
3060            mCollectionItemInfo.recycle();
3061            mCollectionItemInfo = null;
3062        }
3063    }
3064
3065    private static boolean isDefaultLegacyStandardAction(AccessibilityAction action) {
3066        return (action.getId() <= LAST_LEGACY_STANDARD_ACTION
3067                && TextUtils.isEmpty(action.getLabel()));
3068    }
3069
3070    private static AccessibilityAction getActionSingleton(int actionId) {
3071        final int actions = AccessibilityAction.sStandardActions.size();
3072        for (int i = 0; i < actions; i++) {
3073            AccessibilityAction currentAction = AccessibilityAction.sStandardActions.valueAt(i);
3074            if (actionId == currentAction.getId()) {
3075                return currentAction;
3076            }
3077        }
3078
3079        return null;
3080    }
3081
3082    private void addLegacyStandardActions(int actionMask) {
3083        int remainingIds = actionMask;
3084        while (remainingIds > 0) {
3085            final int id = 1 << Integer.numberOfTrailingZeros(remainingIds);
3086            remainingIds &= ~id;
3087            AccessibilityAction action = getActionSingleton(id);
3088            addAction(action);
3089        }
3090    }
3091
3092    /**
3093     * Gets the human readable action symbolic name.
3094     *
3095     * @param action The action.
3096     * @return The symbolic name.
3097     */
3098    private static String getActionSymbolicName(int action) {
3099        switch (action) {
3100            case ACTION_FOCUS:
3101                return "ACTION_FOCUS";
3102            case ACTION_CLEAR_FOCUS:
3103                return "ACTION_CLEAR_FOCUS";
3104            case ACTION_SELECT:
3105                return "ACTION_SELECT";
3106            case ACTION_CLEAR_SELECTION:
3107                return "ACTION_CLEAR_SELECTION";
3108            case ACTION_CLICK:
3109                return "ACTION_CLICK";
3110            case ACTION_LONG_CLICK:
3111                return "ACTION_LONG_CLICK";
3112            case ACTION_ACCESSIBILITY_FOCUS:
3113                return "ACTION_ACCESSIBILITY_FOCUS";
3114            case ACTION_CLEAR_ACCESSIBILITY_FOCUS:
3115                return "ACTION_CLEAR_ACCESSIBILITY_FOCUS";
3116            case ACTION_NEXT_AT_MOVEMENT_GRANULARITY:
3117                return "ACTION_NEXT_AT_MOVEMENT_GRANULARITY";
3118            case ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY:
3119                return "ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY";
3120            case ACTION_NEXT_HTML_ELEMENT:
3121                return "ACTION_NEXT_HTML_ELEMENT";
3122            case ACTION_PREVIOUS_HTML_ELEMENT:
3123                return "ACTION_PREVIOUS_HTML_ELEMENT";
3124            case ACTION_SCROLL_FORWARD:
3125                return "ACTION_SCROLL_FORWARD";
3126            case ACTION_SCROLL_BACKWARD:
3127                return "ACTION_SCROLL_BACKWARD";
3128            case ACTION_CUT:
3129                return "ACTION_CUT";
3130            case ACTION_COPY:
3131                return "ACTION_COPY";
3132            case ACTION_PASTE:
3133                return "ACTION_PASTE";
3134            case ACTION_SET_SELECTION:
3135                return "ACTION_SET_SELECTION";
3136            case ACTION_EXPAND:
3137                return "ACTION_EXPAND";
3138            case ACTION_COLLAPSE:
3139                return "ACTION_COLLAPSE";
3140            case ACTION_DISMISS:
3141                return "ACTION_DISMISS";
3142            case ACTION_SET_TEXT:
3143                return "ACTION_SET_TEXT";
3144            case R.id.accessibilityActionShowOnScreen:
3145                return "ACTION_SHOW_ON_SCREEN";
3146            case R.id.accessibilityActionScrollToPosition:
3147                return "ACTION_SCROLL_TO_POSITION";
3148            case R.id.accessibilityActionScrollUp:
3149                return "ACTION_SCROLL_UP";
3150            case R.id.accessibilityActionScrollLeft:
3151                return "ACTION_SCROLL_LEFT";
3152            case R.id.accessibilityActionScrollDown:
3153                return "ACTION_SCROLL_DOWN";
3154            case R.id.accessibilityActionScrollRight:
3155                return "ACTION_SCROLL_RIGHT";
3156            case R.id.accessibilityActionSetProgress:
3157                return "ACTION_SET_PROGRESS";
3158            case R.id.accessibilityActionContextClick:
3159                return "ACTION_CONTEXT_CLICK";
3160            default:
3161                return "ACTION_UNKNOWN";
3162        }
3163    }
3164
3165    /**
3166     * Gets the human readable movement granularity symbolic name.
3167     *
3168     * @param granularity The granularity.
3169     * @return The symbolic name.
3170     */
3171    private static String getMovementGranularitySymbolicName(int granularity) {
3172        switch (granularity) {
3173            case MOVEMENT_GRANULARITY_CHARACTER:
3174                return "MOVEMENT_GRANULARITY_CHARACTER";
3175            case MOVEMENT_GRANULARITY_WORD:
3176                return "MOVEMENT_GRANULARITY_WORD";
3177            case MOVEMENT_GRANULARITY_LINE:
3178                return "MOVEMENT_GRANULARITY_LINE";
3179            case MOVEMENT_GRANULARITY_PARAGRAPH:
3180                return "MOVEMENT_GRANULARITY_PARAGRAPH";
3181            case MOVEMENT_GRANULARITY_PAGE:
3182                return "MOVEMENT_GRANULARITY_PAGE";
3183            default:
3184                throw new IllegalArgumentException("Unknown movement granularity: " + granularity);
3185        }
3186    }
3187
3188    private boolean canPerformRequestOverConnection(long accessibilityNodeId) {
3189        return (mWindowId != UNDEFINED_ITEM_ID
3190                && getAccessibilityViewId(accessibilityNodeId) != UNDEFINED_ITEM_ID
3191                && mConnectionId != UNDEFINED_CONNECTION_ID);
3192    }
3193
3194    @Override
3195    public boolean equals(Object object) {
3196        if (this == object) {
3197            return true;
3198        }
3199        if (object == null) {
3200            return false;
3201        }
3202        if (getClass() != object.getClass()) {
3203            return false;
3204        }
3205        AccessibilityNodeInfo other = (AccessibilityNodeInfo) object;
3206        if (mSourceNodeId != other.mSourceNodeId) {
3207            return false;
3208        }
3209        if (mWindowId != other.mWindowId) {
3210            return false;
3211        }
3212        return true;
3213    }
3214
3215    @Override
3216    public int hashCode() {
3217        final int prime = 31;
3218        int result = 1;
3219        result = prime * result + getAccessibilityViewId(mSourceNodeId);
3220        result = prime * result + getVirtualDescendantId(mSourceNodeId);
3221        result = prime * result + mWindowId;
3222        return result;
3223    }
3224
3225    @Override
3226    public String toString() {
3227        StringBuilder builder = new StringBuilder();
3228        builder.append(super.toString());
3229
3230        if (DEBUG) {
3231            builder.append("; sourceNodeId: " + mSourceNodeId);
3232            builder.append("; accessibilityViewId: " + getAccessibilityViewId(mSourceNodeId));
3233            builder.append("; virtualDescendantId: " + getVirtualDescendantId(mSourceNodeId));
3234            builder.append("; mParentNodeId: " + mParentNodeId);
3235            builder.append("; traversalBefore: ").append(mTraversalBefore);
3236            builder.append("; traversalAfter: ").append(mTraversalAfter);
3237
3238            int granularities = mMovementGranularities;
3239            builder.append("; MovementGranularities: [");
3240            while (granularities != 0) {
3241                final int granularity = 1 << Integer.numberOfTrailingZeros(granularities);
3242                granularities &= ~granularity;
3243                builder.append(getMovementGranularitySymbolicName(granularity));
3244                if (granularities != 0) {
3245                    builder.append(", ");
3246                }
3247            }
3248            builder.append("]");
3249
3250            builder.append("; childAccessibilityIds: [");
3251            final LongArray childIds = mChildNodeIds;
3252            if (childIds != null) {
3253                for (int i = 0, count = childIds.size(); i < count; i++) {
3254                    builder.append(childIds.get(i));
3255                    if (i < count - 1) {
3256                        builder.append(", ");
3257                    }
3258                }
3259            }
3260            builder.append("]");
3261        }
3262
3263        builder.append("; boundsInParent: " + mBoundsInParent);
3264        builder.append("; boundsInScreen: " + mBoundsInScreen);
3265
3266        builder.append("; packageName: ").append(mPackageName);
3267        builder.append("; className: ").append(mClassName);
3268        builder.append("; text: ").append(mText);
3269        builder.append("; error: ").append(mError);
3270        builder.append("; maxTextLength: ").append(mMaxTextLength);
3271        builder.append("; contentDescription: ").append(mContentDescription);
3272        builder.append("; viewIdResName: ").append(mViewIdResourceName);
3273
3274        builder.append("; checkable: ").append(isCheckable());
3275        builder.append("; checked: ").append(isChecked());
3276        builder.append("; focusable: ").append(isFocusable());
3277        builder.append("; focused: ").append(isFocused());
3278        builder.append("; selected: ").append(isSelected());
3279        builder.append("; clickable: ").append(isClickable());
3280        builder.append("; longClickable: ").append(isLongClickable());
3281        builder.append("; contextClickable: ").append(isContextClickable());
3282        builder.append("; enabled: ").append(isEnabled());
3283        builder.append("; password: ").append(isPassword());
3284        builder.append("; scrollable: ").append(isScrollable());
3285        builder.append("; actions: ").append(mActions);
3286
3287        return builder.toString();
3288    }
3289
3290    private AccessibilityNodeInfo getNodeForAccessibilityId(long accessibilityId) {
3291        if (!canPerformRequestOverConnection(accessibilityId)) {
3292            return null;
3293        }
3294        AccessibilityInteractionClient client = AccessibilityInteractionClient.getInstance();
3295        return client.findAccessibilityNodeInfoByAccessibilityId(mConnectionId,
3296                mWindowId, accessibilityId, false, FLAG_PREFETCH_PREDECESSORS
3297                        | FLAG_PREFETCH_DESCENDANTS | FLAG_PREFETCH_SIBLINGS);
3298    }
3299
3300    /**
3301     * A class defining an action that can be performed on an {@link AccessibilityNodeInfo}.
3302     * Each action has a unique id that is mandatory and optional data.
3303     * <p>
3304     * There are three categories of actions:
3305     * <ul>
3306     * <li><strong>Standard actions</strong> - These are actions that are reported and
3307     * handled by the standard UI widgets in the platform. For each standard action
3308     * there is a static constant defined in this class, e.g. {@link #ACTION_FOCUS}.
3309     * </li>
3310     * <li><strong>Custom actions action</strong> - These are actions that are reported
3311     * and handled by custom widgets. i.e. ones that are not part of the UI toolkit. For
3312     * example, an application may define a custom action for clearing the user history.
3313     * </li>
3314     * <li><strong>Overriden standard actions</strong> - These are actions that override
3315     * standard actions to customize them. For example, an app may add a label to the
3316     * standard {@link #ACTION_CLICK} action to announce that this action clears browsing history.
3317     * </ul>
3318     * </p>
3319     * <p>
3320     * Actions are typically added to an {@link AccessibilityNodeInfo} by using
3321     * {@link AccessibilityNodeInfo#addAction(AccessibilityAction)} within
3322     * {@link View#onInitializeAccessibilityNodeInfo(AccessibilityNodeInfo)} and are performed
3323     * within {@link View#performAccessibilityAction(int, Bundle)}.
3324     * </p>
3325     * <p class="note">
3326     * <strong>Note:</strong> Views which support these actions should invoke
3327     * {@link View#setImportantForAccessibility(int)} with
3328     * {@link View#IMPORTANT_FOR_ACCESSIBILITY_YES} to ensure an {@link AccessibilityService}
3329     * can discover the set of supported actions.
3330     * </p>
3331     */
3332    public static final class AccessibilityAction {
3333
3334        /**
3335         * Action that gives input focus to the node.
3336         */
3337        public static final AccessibilityAction ACTION_FOCUS =
3338                new AccessibilityAction(
3339                        AccessibilityNodeInfo.ACTION_FOCUS, null);
3340
3341        /**
3342         * Action that clears input focus of the node.
3343         */
3344        public static final AccessibilityAction ACTION_CLEAR_FOCUS =
3345                new AccessibilityAction(
3346                        AccessibilityNodeInfo.ACTION_CLEAR_FOCUS, null);
3347
3348        /**
3349         *  Action that selects the node.
3350         */
3351        public static final AccessibilityAction ACTION_SELECT =
3352                new AccessibilityAction(
3353                        AccessibilityNodeInfo.ACTION_SELECT, null);
3354
3355        /**
3356         * Action that deselects the node.
3357         */
3358        public static final AccessibilityAction ACTION_CLEAR_SELECTION =
3359                new AccessibilityAction(
3360                        AccessibilityNodeInfo.ACTION_CLEAR_SELECTION, null);
3361
3362        /**
3363         * Action that clicks on the node info.
3364         */
3365        public static final AccessibilityAction ACTION_CLICK =
3366                new AccessibilityAction(
3367                        AccessibilityNodeInfo.ACTION_CLICK, null);
3368
3369        /**
3370         * Action that long clicks on the node.
3371         */
3372        public static final AccessibilityAction ACTION_LONG_CLICK =
3373                new AccessibilityAction(
3374                        AccessibilityNodeInfo.ACTION_LONG_CLICK, null);
3375
3376        /**
3377         * Action that gives accessibility focus to the node.
3378         */
3379        public static final AccessibilityAction ACTION_ACCESSIBILITY_FOCUS =
3380                new AccessibilityAction(
3381                        AccessibilityNodeInfo.ACTION_ACCESSIBILITY_FOCUS, null);
3382
3383        /**
3384         * Action that clears accessibility focus of the node.
3385         */
3386        public static final AccessibilityAction ACTION_CLEAR_ACCESSIBILITY_FOCUS =
3387                new AccessibilityAction(
3388                        AccessibilityNodeInfo.ACTION_CLEAR_ACCESSIBILITY_FOCUS, null);
3389
3390        /**
3391         * Action that requests to go to the next entity in this node's text
3392         * at a given movement granularity. For example, move to the next character,
3393         * word, etc.
3394         * <p>
3395         * <strong>Arguments:</strong>
3396         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3397         *  AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT},
3398         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3399         *  AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN}<br>
3400         * <strong>Example:</strong> Move to the previous character and do not extend selection.
3401         * <code><pre><p>
3402         *   Bundle arguments = new Bundle();
3403         *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT,
3404         *           AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
3405         *   arguments.putBoolean(AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN,
3406         *           false);
3407         *   info.performAction(AccessibilityAction.ACTION_NEXT_AT_MOVEMENT_GRANULARITY.getId(),
3408         *           arguments);
3409         * </code></pre></p>
3410         * </p>
3411         *
3412         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3413         *  AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3414         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3415         *  AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3416         *
3417         * @see AccessibilityNodeInfo#setMovementGranularities(int)
3418         *  AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3419         * @see AccessibilityNodeInfo#getMovementGranularities()
3420         *  AccessibilityNodeInfo.getMovementGranularities()
3421         *
3422         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_CHARACTER
3423         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER
3424         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_WORD
3425         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD
3426         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_LINE
3427         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE
3428         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_PARAGRAPH
3429         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PARAGRAPH
3430         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_PAGE
3431         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PAGE
3432         */
3433        public static final AccessibilityAction ACTION_NEXT_AT_MOVEMENT_GRANULARITY =
3434                new AccessibilityAction(
3435                        AccessibilityNodeInfo.ACTION_NEXT_AT_MOVEMENT_GRANULARITY, null);
3436
3437        /**
3438         * Action that requests to go to the previous entity in this node's text
3439         * at a given movement granularity. For example, move to the next character,
3440         * word, etc.
3441         * <p>
3442         * <strong>Arguments:</strong>
3443         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3444         *  AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT},
3445         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3446         *  AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN}<br>
3447         * <strong>Example:</strong> Move to the next character and do not extend selection.
3448         * <code><pre><p>
3449         *   Bundle arguments = new Bundle();
3450         *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT,
3451         *           AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER);
3452         *   arguments.putBoolean(AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN,
3453         *           false);
3454         *   info.performAction(AccessibilityAction.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY.getId(),
3455         *           arguments);
3456         * </code></pre></p>
3457         * </p>
3458         *
3459         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3460         *  AccessibilityNodeInfo.ACTION_ARGUMENT_MOVEMENT_GRANULARITY_INT
3461         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3462         *  AccessibilityNodeInfo.ACTION_ARGUMENT_EXTEND_SELECTION_BOOLEAN
3463         *
3464         * @see AccessibilityNodeInfo#setMovementGranularities(int)
3465         *   AccessibilityNodeInfo.setMovementGranularities(int)
3466         * @see AccessibilityNodeInfo#getMovementGranularities()
3467         *  AccessibilityNodeInfo.getMovementGranularities()
3468         *
3469         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_CHARACTER
3470         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_CHARACTER
3471         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_WORD
3472         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_WORD
3473         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_LINE
3474         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_LINE
3475         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_PARAGRAPH
3476         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PARAGRAPH
3477         * @see AccessibilityNodeInfo#MOVEMENT_GRANULARITY_PAGE
3478         *  AccessibilityNodeInfo.MOVEMENT_GRANULARITY_PAGE
3479         */
3480        public static final AccessibilityAction ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY =
3481                new AccessibilityAction(
3482                        AccessibilityNodeInfo.ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY, null);
3483
3484        /**
3485         * Action to move to the next HTML element of a given type. For example, move
3486         * to the BUTTON, INPUT, TABLE, etc.
3487         * <p>
3488         * <strong>Arguments:</strong>
3489         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_HTML_ELEMENT_STRING
3490         *  AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING}<br>
3491         * <strong>Example:</strong>
3492         * <code><pre><p>
3493         *   Bundle arguments = new Bundle();
3494         *   arguments.putString(AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING, "BUTTON");
3495         *   info.performAction(AccessibilityAction.ACTION_NEXT_HTML_ELEMENT.getId(), arguments);
3496         * </code></pre></p>
3497         * </p>
3498         */
3499        public static final AccessibilityAction ACTION_NEXT_HTML_ELEMENT =
3500                new AccessibilityAction(
3501                        AccessibilityNodeInfo.ACTION_NEXT_HTML_ELEMENT, null);
3502
3503        /**
3504         * Action to move to the previous HTML element of a given type. For example, move
3505         * to the BUTTON, INPUT, TABLE, etc.
3506         * <p>
3507         * <strong>Arguments:</strong>
3508         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_HTML_ELEMENT_STRING
3509         *  AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING}<br>
3510         * <strong>Example:</strong>
3511         * <code><pre><p>
3512         *   Bundle arguments = new Bundle();
3513         *   arguments.putString(AccessibilityNodeInfo.ACTION_ARGUMENT_HTML_ELEMENT_STRING, "BUTTON");
3514         *   info.performAction(AccessibilityAction.ACTION_PREVIOUS_HTML_ELEMENT.getId(), arguments);
3515         * </code></pre></p>
3516         * </p>
3517         */
3518        public static final AccessibilityAction ACTION_PREVIOUS_HTML_ELEMENT =
3519                new AccessibilityAction(
3520                        AccessibilityNodeInfo.ACTION_PREVIOUS_HTML_ELEMENT, null);
3521
3522        /**
3523         * Action to scroll the node content forward.
3524         */
3525        public static final AccessibilityAction ACTION_SCROLL_FORWARD =
3526                new AccessibilityAction(
3527                        AccessibilityNodeInfo.ACTION_SCROLL_FORWARD, null);
3528
3529        /**
3530         * Action to scroll the node content backward.
3531         */
3532        public static final AccessibilityAction ACTION_SCROLL_BACKWARD =
3533                new AccessibilityAction(
3534                        AccessibilityNodeInfo.ACTION_SCROLL_BACKWARD, null);
3535
3536        /**
3537         * Action to copy the current selection to the clipboard.
3538         */
3539        public static final AccessibilityAction ACTION_COPY =
3540                new AccessibilityAction(
3541                        AccessibilityNodeInfo.ACTION_COPY, null);
3542
3543        /**
3544         * Action to paste the current clipboard content.
3545         */
3546        public static final AccessibilityAction ACTION_PASTE =
3547                new AccessibilityAction(
3548                        AccessibilityNodeInfo.ACTION_PASTE, null);
3549
3550        /**
3551         * Action to cut the current selection and place it to the clipboard.
3552         */
3553        public static final AccessibilityAction ACTION_CUT =
3554                new AccessibilityAction(
3555                        AccessibilityNodeInfo.ACTION_CUT, null);
3556
3557        /**
3558         * Action to set the selection. Performing this action with no arguments
3559         * clears the selection.
3560         * <p>
3561         * <strong>Arguments:</strong>
3562         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_SELECTION_START_INT
3563         *  AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT},
3564         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_SELECTION_END_INT
3565         *  AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT}<br>
3566         * <strong>Example:</strong>
3567         * <code><pre><p>
3568         *   Bundle arguments = new Bundle();
3569         *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT, 1);
3570         *   arguments.putInt(AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT, 2);
3571         *   info.performAction(AccessibilityAction.ACTION_SET_SELECTION.getId(), arguments);
3572         * </code></pre></p>
3573         * </p>
3574         *
3575         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_SELECTION_START_INT
3576         *  AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_START_INT
3577         * @see AccessibilityNodeInfo#ACTION_ARGUMENT_SELECTION_END_INT
3578         *  AccessibilityNodeInfo.ACTION_ARGUMENT_SELECTION_END_INT
3579         */
3580        public static final AccessibilityAction ACTION_SET_SELECTION =
3581                new AccessibilityAction(
3582                        AccessibilityNodeInfo.ACTION_SET_SELECTION, null);
3583
3584        /**
3585         * Action to expand an expandable node.
3586         */
3587        public static final AccessibilityAction ACTION_EXPAND =
3588                new AccessibilityAction(
3589                        AccessibilityNodeInfo.ACTION_EXPAND, null);
3590
3591        /**
3592         * Action to collapse an expandable node.
3593         */
3594        public static final AccessibilityAction ACTION_COLLAPSE =
3595                new AccessibilityAction(
3596                        AccessibilityNodeInfo.ACTION_COLLAPSE, null);
3597
3598        /**
3599         * Action to dismiss a dismissable node.
3600         */
3601        public static final AccessibilityAction ACTION_DISMISS =
3602                new AccessibilityAction(
3603                        AccessibilityNodeInfo.ACTION_DISMISS, null);
3604
3605        /**
3606         * Action that sets the text of the node. Performing the action without argument,
3607         * using <code> null</code> or empty {@link CharSequence} will clear the text. This
3608         * action will also put the cursor at the end of text.
3609         * <p>
3610         * <strong>Arguments:</strong>
3611         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE
3612         *  AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE}<br>
3613         * <strong>Example:</strong>
3614         * <code><pre><p>
3615         *   Bundle arguments = new Bundle();
3616         *   arguments.putCharSequence(AccessibilityNodeInfo.ACTION_ARGUMENT_SET_TEXT_CHARSEQUENCE,
3617         *       "android");
3618         *   info.performAction(AccessibilityAction.ACTION_SET_TEXT.getId(), arguments);
3619         * </code></pre></p>
3620         */
3621        public static final AccessibilityAction ACTION_SET_TEXT =
3622                new AccessibilityAction(
3623                        AccessibilityNodeInfo.ACTION_SET_TEXT, null);
3624
3625        /**
3626         * Action that requests the node make its bounding rectangle visible
3627         * on the screen, scrolling if necessary just enough.
3628         *
3629         * @see View#requestRectangleOnScreen(Rect)
3630         */
3631        public static final AccessibilityAction ACTION_SHOW_ON_SCREEN =
3632                new AccessibilityAction(R.id.accessibilityActionShowOnScreen, null);
3633
3634        /**
3635         * Action that scrolls the node to make the specified collection
3636         * position visible on screen.
3637         * <p>
3638         * <strong>Arguments:</strong>
3639         * <ul>
3640         *     <li>{@link AccessibilityNodeInfo#ACTION_ARGUMENT_ROW_INT}</li>
3641         *     <li>{@link AccessibilityNodeInfo#ACTION_ARGUMENT_COLUMN_INT}</li>
3642         * <ul>
3643         *
3644         * @see AccessibilityNodeInfo#getCollectionInfo()
3645         */
3646        public static final AccessibilityAction ACTION_SCROLL_TO_POSITION =
3647                new AccessibilityAction(R.id.accessibilityActionScrollToPosition, null);
3648
3649        /**
3650         * Action to scroll the node content up.
3651         */
3652        public static final AccessibilityAction ACTION_SCROLL_UP =
3653                new AccessibilityAction(R.id.accessibilityActionScrollUp, null);
3654
3655        /**
3656         * Action to scroll the node content left.
3657         */
3658        public static final AccessibilityAction ACTION_SCROLL_LEFT =
3659                new AccessibilityAction(R.id.accessibilityActionScrollLeft, null);
3660
3661        /**
3662         * Action to scroll the node content down.
3663         */
3664        public static final AccessibilityAction ACTION_SCROLL_DOWN =
3665                new AccessibilityAction(R.id.accessibilityActionScrollDown, null);
3666
3667        /**
3668         * Action to scroll the node content right.
3669         */
3670        public static final AccessibilityAction ACTION_SCROLL_RIGHT =
3671                new AccessibilityAction(R.id.accessibilityActionScrollRight, null);
3672
3673        /**
3674         * Action that context clicks the node.
3675         */
3676        public static final AccessibilityAction ACTION_CONTEXT_CLICK =
3677                new AccessibilityAction(R.id.accessibilityActionContextClick, null);
3678
3679        /**
3680         * Action that sets progress between {@link  RangeInfo#getMin() RangeInfo.getMin()} and
3681         * {@link  RangeInfo#getMax() RangeInfo.getMax()}. It should use the same value type as
3682         * {@link RangeInfo#getType() RangeInfo.getType()}
3683         * <p>
3684         * <strong>Arguments:</strong>
3685         * {@link AccessibilityNodeInfo#ACTION_ARGUMENT_PROGRESS_VALUE}
3686         *
3687         * @see RangeInfo
3688         */
3689        public static final AccessibilityAction ACTION_SET_PROGRESS =
3690                new AccessibilityAction(R.id.accessibilityActionSetProgress, null);
3691
3692        private static final ArraySet<AccessibilityAction> sStandardActions = new ArraySet<>();
3693        static {
3694            sStandardActions.add(ACTION_FOCUS);
3695            sStandardActions.add(ACTION_CLEAR_FOCUS);
3696            sStandardActions.add(ACTION_SELECT);
3697            sStandardActions.add(ACTION_CLEAR_SELECTION);
3698            sStandardActions.add(ACTION_CLICK);
3699            sStandardActions.add(ACTION_LONG_CLICK);
3700            sStandardActions.add(ACTION_ACCESSIBILITY_FOCUS);
3701            sStandardActions.add(ACTION_CLEAR_ACCESSIBILITY_FOCUS);
3702            sStandardActions.add(ACTION_NEXT_AT_MOVEMENT_GRANULARITY);
3703            sStandardActions.add(ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY);
3704            sStandardActions.add(ACTION_NEXT_HTML_ELEMENT);
3705            sStandardActions.add(ACTION_PREVIOUS_HTML_ELEMENT);
3706            sStandardActions.add(ACTION_SCROLL_FORWARD);
3707            sStandardActions.add(ACTION_SCROLL_BACKWARD);
3708            sStandardActions.add(ACTION_COPY);
3709            sStandardActions.add(ACTION_PASTE);
3710            sStandardActions.add(ACTION_CUT);
3711            sStandardActions.add(ACTION_SET_SELECTION);
3712            sStandardActions.add(ACTION_EXPAND);
3713            sStandardActions.add(ACTION_COLLAPSE);
3714            sStandardActions.add(ACTION_DISMISS);
3715            sStandardActions.add(ACTION_SET_TEXT);
3716            sStandardActions.add(ACTION_SHOW_ON_SCREEN);
3717            sStandardActions.add(ACTION_SCROLL_TO_POSITION);
3718            sStandardActions.add(ACTION_SCROLL_UP);
3719            sStandardActions.add(ACTION_SCROLL_LEFT);
3720            sStandardActions.add(ACTION_SCROLL_DOWN);
3721            sStandardActions.add(ACTION_SCROLL_RIGHT);
3722            sStandardActions.add(ACTION_SET_PROGRESS);
3723            sStandardActions.add(ACTION_CONTEXT_CLICK);
3724        }
3725
3726        private final int mActionId;
3727        private final CharSequence mLabel;
3728
3729        /**
3730         * Creates a new AccessibilityAction. For adding a standard action without a specific label,
3731         * use the static constants.
3732         *
3733         * You can also override the description for one the standard actions. Below is an example
3734         * how to override the standard click action by adding a custom label:
3735         * <pre>
3736         *   AccessibilityAction action = new AccessibilityAction(
3737         *           AccessibilityAction.ACTION_ACTION_CLICK, getLocalizedLabel());
3738         *   node.addAction(action);
3739         * </pre>
3740         *
3741         * @param actionId The id for this action. This should either be one of the
3742         *                 standard actions or a specific action for your app. In that case it is
3743         *                 required to use a resource identifier.
3744         * @param label The label for the new AccessibilityAction.
3745         */
3746        public AccessibilityAction(int actionId, @Nullable CharSequence label) {
3747            if ((actionId & ACTION_TYPE_MASK) == 0 && Integer.bitCount(actionId) != 1) {
3748                throw new IllegalArgumentException("Invalid standard action id");
3749            }
3750
3751            mActionId = actionId;
3752            mLabel = label;
3753        }
3754
3755        /**
3756         * Gets the id for this action.
3757         *
3758         * @return The action id.
3759         */
3760        public int getId() {
3761            return mActionId;
3762        }
3763
3764        /**
3765         * Gets the label for this action. Its purpose is to describe the
3766         * action to user.
3767         *
3768         * @return The label.
3769         */
3770        public CharSequence getLabel() {
3771            return mLabel;
3772        }
3773
3774        @Override
3775        public int hashCode() {
3776            return mActionId;
3777        }
3778
3779        @Override
3780        public boolean equals(Object other) {
3781            if (other == null) {
3782                return false;
3783            }
3784
3785            if (other == this) {
3786                return true;
3787            }
3788
3789            if (getClass() != other.getClass()) {
3790                return false;
3791            }
3792
3793            return mActionId == ((AccessibilityAction)other).mActionId;
3794        }
3795
3796        @Override
3797        public String toString() {
3798            return "AccessibilityAction: " + getActionSymbolicName(mActionId) + " - " + mLabel;
3799        }
3800    }
3801
3802    /**
3803     * Class with information if a node is a range. Use
3804     * {@link RangeInfo#obtain(int, float, float, float)} to get an instance.
3805     */
3806    public static final class RangeInfo {
3807        private static final int MAX_POOL_SIZE = 10;
3808
3809        /** Range type: integer. */
3810        public static final int RANGE_TYPE_INT = 0;
3811        /** Range type: float. */
3812        public static final int RANGE_TYPE_FLOAT = 1;
3813        /** Range type: percent with values from zero to one.*/
3814        public static final int RANGE_TYPE_PERCENT = 2;
3815
3816        private static final SynchronizedPool<RangeInfo> sPool =
3817                new SynchronizedPool<AccessibilityNodeInfo.RangeInfo>(MAX_POOL_SIZE);
3818
3819        private int mType;
3820        private float mMin;
3821        private float mMax;
3822        private float mCurrent;
3823
3824        /**
3825         * Obtains a pooled instance that is a clone of another one.
3826         *
3827         * @param other The instance to clone.
3828         *
3829         * @hide
3830         */
3831        public static RangeInfo obtain(RangeInfo other) {
3832            return obtain(other.mType, other.mMin, other.mMax, other.mCurrent);
3833        }
3834
3835        /**
3836         * Obtains a pooled instance.
3837         *
3838         * @param type The type of the range.
3839         * @param min The min value.
3840         * @param max The max value.
3841         * @param current The current value.
3842         */
3843        public static RangeInfo obtain(int type, float min, float max, float current) {
3844            RangeInfo info = sPool.acquire();
3845            if (info == null) {
3846                return new RangeInfo(type, min, max, current);
3847            }
3848
3849            info.mType = type;
3850            info.mMin = min;
3851            info.mMax = max;
3852            info.mCurrent = current;
3853            return info;
3854        }
3855
3856        /**
3857         * Creates a new range.
3858         *
3859         * @param type The type of the range.
3860         * @param min The min value.
3861         * @param max The max value.
3862         * @param current The current value.
3863         */
3864        private RangeInfo(int type, float min, float max, float current) {
3865            mType = type;
3866            mMin = min;
3867            mMax = max;
3868            mCurrent = current;
3869        }
3870
3871        /**
3872         * Gets the range type.
3873         *
3874         * @return The range type.
3875         *
3876         * @see #RANGE_TYPE_INT
3877         * @see #RANGE_TYPE_FLOAT
3878         * @see #RANGE_TYPE_PERCENT
3879         */
3880        public int getType() {
3881            return mType;
3882        }
3883
3884        /**
3885         * Gets the min value.
3886         *
3887         * @return The min value.
3888         */
3889        public float getMin() {
3890            return mMin;
3891        }
3892
3893        /**
3894         * Gets the max value.
3895         *
3896         * @return The max value.
3897         */
3898        public float getMax() {
3899            return mMax;
3900        }
3901
3902        /**
3903         * Gets the current value.
3904         *
3905         * @return The current value.
3906         */
3907        public float getCurrent() {
3908            return mCurrent;
3909        }
3910
3911        /**
3912         * Recycles this instance.
3913         */
3914        void recycle() {
3915            clear();
3916            sPool.release(this);
3917        }
3918
3919        private void clear() {
3920            mType = 0;
3921            mMin = 0;
3922            mMax = 0;
3923            mCurrent = 0;
3924        }
3925    }
3926
3927    /**
3928     * Class with information if a node is a collection. Use
3929     * {@link CollectionInfo#obtain(int, int, boolean)} to get an instance.
3930     * <p>
3931     * A collection of items has rows and columns and may be hierarchical.
3932     * For example, a horizontal list is a collection with one column, as
3933     * many rows as the list items, and is not hierarchical; A table is a
3934     * collection with several rows, several columns, and is not hierarchical;
3935     * A vertical tree is a hierarchical collection with one column and
3936     * as many rows as the first level children.
3937     * </p>
3938     */
3939    public static final class CollectionInfo {
3940        /** Selection mode where items are not selectable. */
3941        public static final int SELECTION_MODE_NONE = 0;
3942
3943        /** Selection mode where a single item may be selected. */
3944        public static final int SELECTION_MODE_SINGLE = 1;
3945
3946        /** Selection mode where multiple items may be selected. */
3947        public static final int SELECTION_MODE_MULTIPLE = 2;
3948
3949        private static final int MAX_POOL_SIZE = 20;
3950
3951        private static final SynchronizedPool<CollectionInfo> sPool =
3952                new SynchronizedPool<>(MAX_POOL_SIZE);
3953
3954        private int mRowCount;
3955        private int mColumnCount;
3956        private boolean mHierarchical;
3957        private int mSelectionMode;
3958
3959        /**
3960         * Obtains a pooled instance that is a clone of another one.
3961         *
3962         * @param other The instance to clone.
3963         * @hide
3964         */
3965        public static CollectionInfo obtain(CollectionInfo other) {
3966            return CollectionInfo.obtain(other.mRowCount, other.mColumnCount, other.mHierarchical,
3967                    other.mSelectionMode);
3968        }
3969
3970        /**
3971         * Obtains a pooled instance.
3972         *
3973         * @param rowCount The number of rows.
3974         * @param columnCount The number of columns.
3975         * @param hierarchical Whether the collection is hierarchical.
3976         */
3977        public static CollectionInfo obtain(int rowCount, int columnCount,
3978                boolean hierarchical) {
3979            return obtain(rowCount, columnCount, hierarchical, SELECTION_MODE_NONE);
3980        }
3981
3982        /**
3983         * Obtains a pooled instance.
3984         *
3985         * @param rowCount The number of rows.
3986         * @param columnCount The number of columns.
3987         * @param hierarchical Whether the collection is hierarchical.
3988         * @param selectionMode The collection's selection mode, one of:
3989         *            <ul>
3990         *            <li>{@link #SELECTION_MODE_NONE}
3991         *            <li>{@link #SELECTION_MODE_SINGLE}
3992         *            <li>{@link #SELECTION_MODE_MULTIPLE}
3993         *            </ul>
3994         */
3995        public static CollectionInfo obtain(int rowCount, int columnCount,
3996                boolean hierarchical, int selectionMode) {
3997           final CollectionInfo info = sPool.acquire();
3998            if (info == null) {
3999                return new CollectionInfo(rowCount, columnCount, hierarchical, selectionMode);
4000            }
4001
4002            info.mRowCount = rowCount;
4003            info.mColumnCount = columnCount;
4004            info.mHierarchical = hierarchical;
4005            info.mSelectionMode = selectionMode;
4006            return info;
4007        }
4008
4009        /**
4010         * Creates a new instance.
4011         *
4012         * @param rowCount The number of rows.
4013         * @param columnCount The number of columns.
4014         * @param hierarchical Whether the collection is hierarchical.
4015         * @param selectionMode The collection's selection mode.
4016         */
4017        private CollectionInfo(int rowCount, int columnCount, boolean hierarchical,
4018                int selectionMode) {
4019            mRowCount = rowCount;
4020            mColumnCount = columnCount;
4021            mHierarchical = hierarchical;
4022            mSelectionMode = selectionMode;
4023        }
4024
4025        /**
4026         * Gets the number of rows.
4027         *
4028         * @return The row count.
4029         */
4030        public int getRowCount() {
4031            return mRowCount;
4032        }
4033
4034        /**
4035         * Gets the number of columns.
4036         *
4037         * @return The column count.
4038         */
4039        public int getColumnCount() {
4040            return mColumnCount;
4041        }
4042
4043        /**
4044         * Gets if the collection is a hierarchically ordered.
4045         *
4046         * @return Whether the collection is hierarchical.
4047         */
4048        public boolean isHierarchical() {
4049            return mHierarchical;
4050        }
4051
4052        /**
4053         * Gets the collection's selection mode.
4054         *
4055         * @return The collection's selection mode, one of:
4056         *         <ul>
4057         *         <li>{@link #SELECTION_MODE_NONE}
4058         *         <li>{@link #SELECTION_MODE_SINGLE}
4059         *         <li>{@link #SELECTION_MODE_MULTIPLE}
4060         *         </ul>
4061         */
4062        public int getSelectionMode() {
4063            return mSelectionMode;
4064        }
4065
4066        /**
4067         * Recycles this instance.
4068         */
4069        void recycle() {
4070            clear();
4071            sPool.release(this);
4072        }
4073
4074        private void clear() {
4075            mRowCount = 0;
4076            mColumnCount = 0;
4077            mHierarchical = false;
4078            mSelectionMode = SELECTION_MODE_NONE;
4079        }
4080    }
4081
4082    /**
4083     * Class with information if a node is a collection item. Use
4084     * {@link CollectionItemInfo#obtain(int, int, int, int, boolean)}
4085     * to get an instance.
4086     * <p>
4087     * A collection item is contained in a collection, it starts at
4088     * a given row and column in the collection, and spans one or
4089     * more rows and columns. For example, a header of two related
4090     * table columns starts at the first row and the first column,
4091     * spans one row and two columns.
4092     * </p>
4093     */
4094    public static final class CollectionItemInfo {
4095        private static final int MAX_POOL_SIZE = 20;
4096
4097        private static final SynchronizedPool<CollectionItemInfo> sPool =
4098                new SynchronizedPool<>(MAX_POOL_SIZE);
4099
4100        /**
4101         * Obtains a pooled instance that is a clone of another one.
4102         *
4103         * @param other The instance to clone.
4104         * @hide
4105         */
4106        public static CollectionItemInfo obtain(CollectionItemInfo other) {
4107            return CollectionItemInfo.obtain(other.mRowIndex, other.mRowSpan, other.mColumnIndex,
4108                    other.mColumnSpan, other.mHeading, other.mSelected);
4109        }
4110
4111        /**
4112         * Obtains a pooled instance.
4113         *
4114         * @param rowIndex The row index at which the item is located.
4115         * @param rowSpan The number of rows the item spans.
4116         * @param columnIndex The column index at which the item is located.
4117         * @param columnSpan The number of columns the item spans.
4118         * @param heading Whether the item is a heading.
4119         */
4120        public static CollectionItemInfo obtain(int rowIndex, int rowSpan,
4121                int columnIndex, int columnSpan, boolean heading) {
4122            return obtain(rowIndex, rowSpan, columnIndex, columnSpan, heading, false);
4123        }
4124
4125        /**
4126         * Obtains a pooled instance.
4127         *
4128         * @param rowIndex The row index at which the item is located.
4129         * @param rowSpan The number of rows the item spans.
4130         * @param columnIndex The column index at which the item is located.
4131         * @param columnSpan The number of columns the item spans.
4132         * @param heading Whether the item is a heading.
4133         * @param selected Whether the item is selected.
4134         */
4135        public static CollectionItemInfo obtain(int rowIndex, int rowSpan,
4136                int columnIndex, int columnSpan, boolean heading, boolean selected) {
4137            final CollectionItemInfo info = sPool.acquire();
4138            if (info == null) {
4139                return new CollectionItemInfo(
4140                        rowIndex, rowSpan, columnIndex, columnSpan, heading, selected);
4141            }
4142
4143            info.mRowIndex = rowIndex;
4144            info.mRowSpan = rowSpan;
4145            info.mColumnIndex = columnIndex;
4146            info.mColumnSpan = columnSpan;
4147            info.mHeading = heading;
4148            info.mSelected = selected;
4149            return info;
4150        }
4151
4152        private boolean mHeading;
4153        private int mColumnIndex;
4154        private int mRowIndex;
4155        private int mColumnSpan;
4156        private int mRowSpan;
4157        private boolean mSelected;
4158
4159        /**
4160         * Creates a new instance.
4161         *
4162         * @param rowIndex The row index at which the item is located.
4163         * @param rowSpan The number of rows the item spans.
4164         * @param columnIndex The column index at which the item is located.
4165         * @param columnSpan The number of columns the item spans.
4166         * @param heading Whether the item is a heading.
4167         */
4168        private CollectionItemInfo(int rowIndex, int rowSpan, int columnIndex, int columnSpan,
4169                boolean heading, boolean selected) {
4170            mRowIndex = rowIndex;
4171            mRowSpan = rowSpan;
4172            mColumnIndex = columnIndex;
4173            mColumnSpan = columnSpan;
4174            mHeading = heading;
4175            mSelected = selected;
4176        }
4177
4178        /**
4179         * Gets the column index at which the item is located.
4180         *
4181         * @return The column index.
4182         */
4183        public int getColumnIndex() {
4184            return mColumnIndex;
4185        }
4186
4187        /**
4188         * Gets the row index at which the item is located.
4189         *
4190         * @return The row index.
4191         */
4192        public int getRowIndex() {
4193            return mRowIndex;
4194        }
4195
4196        /**
4197         * Gets the number of columns the item spans.
4198         *
4199         * @return The column span.
4200         */
4201        public int getColumnSpan() {
4202            return mColumnSpan;
4203        }
4204
4205        /**
4206         * Gets the number of rows the item spans.
4207         *
4208         * @return The row span.
4209         */
4210        public int getRowSpan() {
4211            return mRowSpan;
4212        }
4213
4214        /**
4215         * Gets if the collection item is a heading. For example, section
4216         * heading, table header, etc.
4217         *
4218         * @return If the item is a heading.
4219         */
4220        public boolean isHeading() {
4221            return mHeading;
4222        }
4223
4224        /**
4225         * Gets if the collection item is selected.
4226         *
4227         * @return If the item is selected.
4228         */
4229        public boolean isSelected() {
4230            return mSelected;
4231        }
4232
4233        /**
4234         * Recycles this instance.
4235         */
4236        void recycle() {
4237            clear();
4238            sPool.release(this);
4239        }
4240
4241        private void clear() {
4242            mColumnIndex = 0;
4243            mColumnSpan = 0;
4244            mRowIndex = 0;
4245            mRowSpan = 0;
4246            mHeading = false;
4247            mSelected = false;
4248        }
4249    }
4250
4251    /**
4252     * @see android.os.Parcelable.Creator
4253     */
4254    public static final Parcelable.Creator<AccessibilityNodeInfo> CREATOR =
4255            new Parcelable.Creator<AccessibilityNodeInfo>() {
4256        @Override
4257        public AccessibilityNodeInfo createFromParcel(Parcel parcel) {
4258            AccessibilityNodeInfo info = AccessibilityNodeInfo.obtain();
4259            info.initFromParcel(parcel);
4260            return info;
4261        }
4262
4263        @Override
4264        public AccessibilityNodeInfo[] newArray(int size) {
4265            return new AccessibilityNodeInfo[size];
4266        }
4267    };
4268}
4269