/*
 * Copyright (C) 2009 The Android Open Source Project
 *
 * Licensed under the Apache License, Version 2.0 (the "License");
 * you may not use this file except in compliance with the License.
 * You may obtain a copy of the License at
 *
 *      http://www.apache.org/licenses/LICENSE-2.0
 *
 * Unless required by applicable law or agreed to in writing, software
 * distributed under the License is distributed on an "AS IS" BASIS,
 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
 * See the License for the specific language governing permissions and
 * limitations under the License.
 */

package android.view.accessibility;

import android.annotation.IntDef;
import android.annotation.NonNull;
import android.compat.annotation.UnsupportedAppUsage;
import android.os.Build;
import android.os.Parcel;
import android.os.Parcelable;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;

import com.android.internal.util.BitUtils;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.ArrayList;
import java.util.List;

/**
 * <p>
 * This class represents accessibility events that are sent by the system when
 * something notable happens in the user interface. For example, when a
 * {@link android.widget.Button} is clicked, a {@link android.view.View} is focused, etc.
 * </p>
 * <p>
 * An accessibility event is fired by an individual view which populates the event with
 * data for its state and requests from its parent to send the event to interested
 * parties. The parent can optionally modify or even block the event based on its broader
 * understanding of the user interface's context.
 * </p>
 * <p>
 * The main purpose of an accessibility event is to communicate changes in the UI to an
 * {@link android.accessibilityservice.AccessibilityService}. If needed, the service may then
 * inspect the user interface by examining the View hierarchy through the event's
 * {@link #getSource() source}, as represented by a tree of {@link AccessibilityNodeInfo}s (snapshot
 * of a View state) which can be used for exploring the window content. Note that the privilege for
 * accessing an event's source, thus the window content, has to be explicitly requested. For more
 * details refer to {@link android.accessibilityservice.AccessibilityService}. If an
 * accessibility service has not requested to retrieve the window content the event will
 * not contain reference to its source. <strong>Note: </strong> for events of type
 * {@link #TYPE_NOTIFICATION_STATE_CHANGED} the source is never available, and Views that set
 * {@link android.view.View#isAccessibilityDataSensitive()} may not populate all event properties on
 * events sent from higher up in the view hierarchy.
 * </p>
 * <p>
 * This class represents various semantically different accessibility event
 * types. Each event type has an associated set of related properties. In other
 * words, each event type is characterized via a subset of the properties exposed
 * by this class. For each event type there is a corresponding constant defined
 * in this class. Follows a specification of the event types and their associated properties:
 * </p>
 * <div class="special reference">
 * <h3>Developer Guides</h3>
 * <p>For more information about creating and processing AccessibilityEvents, read the
 * <a href="{@docRoot}guide/topics/ui/accessibility/index.html">Accessibility</a>
 * developer guide.</p>
 * </div>
 * <p>
 * <b>VIEW TYPES</b></br>
 * </p>
 * <p>
 * <b>View clicked</b> - represents the event of clicking on a {@link android.view.View}
 * like {@link android.widget.Button}, {@link android.widget.CompoundButton}, etc.</br>
 * <em>Type:</em>{@link #TYPE_VIEW_CLICKED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View long clicked</b> - represents the event of long clicking on a {@link android.view.View}
 * like {@link android.widget.Button}, {@link android.widget.CompoundButton}, etc </br>
 * <em>Type:</em>{@link #TYPE_VIEW_LONG_CLICKED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View selected</b> - represents the event of selecting an item usually in
 * the context of an {@link android.widget.AdapterView}.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_SELECTED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View focused</b> - represents the event of focusing a
 * {@link android.view.View}.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_FOCUSED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View text changed</b> - represents the event of changing the text of an
 * {@link android.widget.EditText}.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_TEXT_CHANGED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getText()} - The new text of the source.</li>
 *   <li>{@link #getBeforeText()} - The text of the source before the change.</li>
 *   <li>{@link #getFromIndex()} - The text change start index.</li>
 *   <li>{@link #getAddedCount()} - The number of added characters.</li>
 *   <li>{@link #getRemovedCount()} - The number of removed characters.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View text selection changed</b> - represents the event of changing the text
 * selection of an {@link android.widget.EditText}.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_TEXT_SELECTION_CHANGED} </br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <b>View text traversed at movement granularity</b> - represents the event of traversing the
 * text of a view at a given granularity. For example, moving to the next word.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY} </br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getMovementGranularity()} - Sets the granularity at which a view's text
 *       was traversed.</li>
 *   <li>{@link #getText()} -  The text of the source's sub-tree.</li>
 *   <li>{@link #getFromIndex()} - The start the text that was skipped over in this movement.
 *       This is the starting point when moving forward through the text, but not when moving
 *       back.</li>
 *   <li>{@link #getToIndex()} - The end of the text that was skipped over in this movement.
 *       This is the ending point when moving forward through the text, but not when moving
 *       back.</li>
 *   <li>{@link #getAction()} - Gets traversal action which specifies the direction.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View scrolled</b> - represents the event of scrolling a view. </br>
 * <em>Type:</em> {@link #TYPE_VIEW_SCROLLED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getScrollDeltaX()} - The difference in the horizontal position.</li>
 *   <li>{@link #getScrollDeltaY()} - The difference in the vertical position.</li>
 *   <li>{@link #getMaxScrollX()} ()} -  The max scroll offset of the source left edge</li>
 *   <li>{@link #getMaxScrollY()} ()} - The max scroll offset of the source top edge.</li>
 * </ul>
 * </p>
 * <p>
 * <b>TRANSITION TYPES</b></br>
 * </p>
 * <p>
 * <b>Window state changed</b> - represents the event of a change to a section of
 * the user interface that is visually distinct. Should be sent from either the
 * root view of a window or from a view that is marked as a pane
 * {@link android.view.View#setAccessibilityPaneTitle(CharSequence)}. Note that changes
 * to true windows are represented by {@link #TYPE_WINDOWS_CHANGED}.</br>
 * <em>Type:</em> {@link #TYPE_WINDOW_STATE_CHANGED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getContentChangeTypes()} - The type of state changes.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getText()} - The text of the source's sub-tree, including the pane titles.</li>
 * </ul>
 * </p>
 * <p>
 * <b>Window content changed</b> - represents the event of change in the
 * content of a window. This change can be adding/removing view, changing
 * a view size, etc.</br>
 * </p>
 * <p>
 * <em>Type:</em> {@link #TYPE_WINDOW_CONTENT_CHANGED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getContentChangeTypes()} - The type of content changes.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>Windows changed</b> - represents a change in the windows shown on
 * the screen such as a window appeared, a window disappeared, a window size changed,
 * a window layer changed, etc. These events should only come from the system, which is responsible
 * for managing windows. The list of windows is available from
 * {@link android.accessibilityservice.AccessibilityService#getWindows()}.
 * For regions of the user interface that are presented as windows but are
 * controlled by an app's process, use {@link #TYPE_WINDOW_STATE_CHANGED}.</br>
 * <em>Type:</em> {@link #TYPE_WINDOWS_CHANGED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getEventTime()} - The event time.</li>
 *   <li>{@link #getWindowChanges()}</li> - The specific change to the source window
 * </ul>
 * <em>Note:</em> You can retrieve the {@link AccessibilityWindowInfo} for the window
 * source of the event by looking through the list returned by
 * {@link android.accessibilityservice.AccessibilityService#getWindows()} for the window whose ID
 * matches {@link #getWindowId()}.
 * </p>
 * <p>
 * <b>NOTIFICATION TYPES</b></br>
 * </p>
 * <p>
 * <b>Notification state changed</b> - represents the event showing a transient piece of information
 * to the user. This information may be a {@link android.app.Notification} or
 * {@link android.widget.Toast}.</br>
 * <em>Type:</em> {@link #TYPE_NOTIFICATION_STATE_CHANGED}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getParcelableData()} - The posted {@link android.app.Notification}, if
 *   applicable.</li>
 *   <li>{@link #getText()} - Displayed text of the {@link android.widget.Toast}, if applicable,
 *   or may contain text from the {@link android.app.Notification}, although
 *   {@link #getParcelableData()} is a richer set of data for {@link android.app.Notification}.</li>
 * </ul>
 * </p>
 * <p>
 * <b>EXPLORATION TYPES</b></br>
 * </p>
 * <p>
 * <b>View hover enter</b> - represents the event of beginning to hover
 * over a {@link android.view.View}. The hover may be generated via
 * exploring the screen by touch or via a pointing device.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_HOVER_ENTER}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <b>View hover exit</b> - represents the event of stopping to hover
 * over a {@link android.view.View}. The hover may be generated via
 * exploring the screen by touch or via a pointing device.</br>
 * <em>Type:</em> {@link #TYPE_VIEW_HOVER_EXIT}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>View scrolled to</b> - represents the event of a target node brought on screen by
 * ACTION_SCROLL_IN_DIRECTION.
 * <em>Type:</em> {@link #TYPE_VIEW_TARGETED_BY_SCROLL}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients). This represents the node
 *   that is brought on screen as a result of the scroll.</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 * <p>
 * <b>Touch interaction start</b> - represents the event of starting a touch
 * interaction, which is the user starts touching the screen.</br>
 * <em>Type:</em> {@link #TYPE_TOUCH_INTERACTION_START}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>Touch interaction end</b> - represents the event of ending a touch
 * interaction, which is the user stops touching the screen.</br>
 * <em>Type:</em> {@link #TYPE_TOUCH_INTERACTION_END}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>Touch exploration gesture start</b> - represents the event of starting a touch
 * exploring gesture.</br>
 * <em>Type:</em> {@link #TYPE_TOUCH_EXPLORATION_GESTURE_START}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>Touch exploration gesture end</b> - represents the event of ending a touch
 * exploring gesture.</br>
 * <em>Type:</em> {@link #TYPE_TOUCH_EXPLORATION_GESTURE_END}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>Touch gesture detection start</b> - represents the event of starting a user
 * gesture detection.</br>
 * <em>Type:</em> {@link #TYPE_GESTURE_DETECTION_START}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>Touch gesture detection end</b> - represents the event of ending a user
 * gesture detection.</br>
 * <em>Type:</em> {@link #TYPE_GESTURE_DETECTION_END}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 * </ul>
 * <em>Note:</em> This event is fired only by the system and is not passed to the
 * view tree to be populated.</br>
 * </p>
 * <p>
 * <b>MISCELLANEOUS TYPES</b></br>
 * </p>
 * <p>
 * <b>Announcement</b> - represents the event of an application requesting a screen reader to make
 * an announcement. Because the event carries no semantic meaning, this event is appropriate only
 * in exceptional situations where additional screen reader output is needed but other types of
 * accessibility services do not need to be aware of the change.</br>
 * <em>Type:</em> {@link #TYPE_ANNOUNCEMENT}</br>
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getEventType()} - The type of the event.</li>
 *   <li>{@link #getSource()} - The source info (for registered clients).</li>
 *   <li>{@link #getClassName()} - The class name of the source.</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 *   <li>{@link #getText()} - The text of the announcement.</li>
 * </ul>
 * </p>
  * <p>
 * <b>speechStateChanged</b>
 * <em>Type:</em> {@link #TYPE_SPEECH_STATE_CHANGE}</br>
 * Represents a change in the speech state defined by the
 * bit mask of the speech state change types.
 * A change in the speech state occurs when an application wants to signal that
 * it is either speaking or listening for human speech.
 * This event helps avoid conflicts where two applications want to speak or one listens
 * when another speaks.
 * When sending this event, the sender should ensure that  the accompanying state change types
 * make sense. For example, the sender should not send
 * {@link #SPEECH_STATE_SPEAKING_START} and {@link #SPEECH_STATE_SPEAKING_END} together.
 * <em>Properties:</em></br>
 * <ul>
 *   <li>{@link #getSpeechStateChangeTypes()} - The type of state changes</li>
 *   <li>{@link #getPackageName()} - The package name of the source.</li>
 *   <li>{@link #getEventTime()}  - The event time.</li>
 * </ul>
 * </p>
 *
 * @see android.view.accessibility.AccessibilityManager
 * @see android.accessibilityservice.AccessibilityService
 * @see AccessibilityNodeInfo
 */
public final class AccessibilityEvent extends AccessibilityRecord implements Parcelable {
    private static final String LOG_TAG = "AccessibilityEvent";

    private static final boolean DEBUG = Log.isLoggable(LOG_TAG, Log.DEBUG) && Build.IS_DEBUGGABLE;

    /** @hide */
    public static final boolean DEBUG_ORIGIN = false;

    /**
     * Invalid selection/focus position.
     *
     * @see #getCurrentItemIndex()
     */
    public static final int INVALID_POSITION = -1;

    /**
     * Maximum length of the text fields.
     *
     * @see #getBeforeText()
     * @see #getText()
     * </br>
     * Note: This constant is no longer needed since there
     *       is no limit on the length of text that is contained
     *       in an accessibility event anymore.
     */
    @Deprecated
    public static final int MAX_TEXT_LENGTH = 500;

    // Event types.

    /**
     * Represents the event of clicking on a {@link android.view.View} like
     * {@link android.widget.Button}, {@link android.widget.CompoundButton}, etc.
     * <p>See {@link AccessibilityNodeInfo.AccessibilityAction#ACTION_CLICK} for more
     * details.
     */
    public static final int TYPE_VIEW_CLICKED = 1 /* << 0 */;;

    /**
     * Represents the event of long clicking on a {@link android.view.View} like
     * {@link android.widget.Button}, {@link android.widget.CompoundButton}, etc.
     * <p>See {@link AccessibilityNodeInfo.AccessibilityAction#ACTION_LONG_CLICK} for more
     * details.
     */
    public static final int TYPE_VIEW_LONG_CLICKED = 1 << 1;

    /**
     * Represents the event of selecting an item usually in the context of an
     * {@link android.widget.AdapterView}.
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_SELECT
     */
    public static final int TYPE_VIEW_SELECTED = 1 << 2;

    /**
     * Represents the event of setting input focus of a {@link android.view.View}.
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_ACCESSIBILITY_FOCUS for the difference
     * between input and accessibility focus.
     */
    public static final int TYPE_VIEW_FOCUSED = 1 << 3;

    /**
     * Represents the event of changing the text of an {@link android.widget.EditText}.
     * @see AccessibilityNodeInfo#setText(CharSequence)
     */
    public static final int TYPE_VIEW_TEXT_CHANGED = 1 << 4;

    /**
     * Represents the event of a change to a visually distinct section of the user interface.
     * <p>
     * These events should only be dispatched from {@link android.view.View}s that have
     * accessibility pane titles, and replaces {@link #TYPE_WINDOW_CONTENT_CHANGED} for those
     * sources. Details about the change are available from {@link #getContentChangeTypes()}.
     * <p>
     * Do not use this to get an accessibility service to make non-pane announcements. Instead,
     * follow the practices described in {@link View#announceForAccessibility(CharSequence)}.
     * <b>Note:</b> this does not suggest calling announceForAccessibility(), but using the
     * suggestions listed in its documentation.
     */
    public static final int TYPE_WINDOW_STATE_CHANGED = 1 << 5;

    /**
     * Represents the event showing a {@link android.app.Notification}.
     */
    public static final int TYPE_NOTIFICATION_STATE_CHANGED = 1 << 6;

    /**
     * Represents the event of a hover enter over a {@link android.view.View}.
     */
    public static final int TYPE_VIEW_HOVER_ENTER = 1 << 7;

    /**
     * Represents the event of a hover exit over a {@link android.view.View}.
     */
    public static final int TYPE_VIEW_HOVER_EXIT = 1 << 8;

    /**
     * Represents the event of starting a touch exploration gesture.
     */
    public static final int TYPE_TOUCH_EXPLORATION_GESTURE_START = 1 << 9;

    /**
     * Represents the event of ending a touch exploration gesture.
     */
    public static final int TYPE_TOUCH_EXPLORATION_GESTURE_END = 1 << 10;

    /**
     * Represents the event of changing the content of a window and more
     * specifically the sub-tree rooted at the event's source.
     */
    public static final int TYPE_WINDOW_CONTENT_CHANGED = 1 << 11;

    /**
     * Represents the event of scrolling a view. This event type is generally not sent directly. In
     * the View system, this is sent in
     * {@link android.view.View#onScrollChanged(int, int, int, int)}
     * <p>In addition to the source and package name, the event should populate scroll-specific
     * properties like {@link #setScrollDeltaX(int)}, {@link #setScrollDeltaY(int)},
     * {@link #setMaxScrollX(int)}, and {@link #setMaxScrollY(int)}.
     * <p>Services are encouraged to rely on the source to query UI state over AccessibilityEvents
     * properties. For example, to check after a scroll if the bottom of the scrolling UI element
     * has been reached, check if the source node is scrollable and has the
     * {@link AccessibilityNodeInfo.AccessibilityAction#ACTION_SCROLL_BACKWARD} action but not the
     * {@link AccessibilityNodeInfo.AccessibilityAction#ACTION_SCROLL_FORWARD} action.
     * For scrolling to a target, use {@link #TYPE_VIEW_TARGETED_BY_SCROLL}.
     */
    public static final int TYPE_VIEW_SCROLLED = 1 << 12;

    /**
     * Represents the event of changing the selection in an {@link android.widget.EditText}.
     */
    public static final int TYPE_VIEW_TEXT_SELECTION_CHANGED = 1 << 13;

    /**
     * Represents the event of an application making an announcement.
     * <p>
     * In general, follow the practices described in
     * {@link View#announceForAccessibility(CharSequence)}.
     */
    public static final int TYPE_ANNOUNCEMENT = 1 << 14;

    /**
     * Represents the event of gaining accessibility focus.
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_ACCESSIBILITY_FOCUS for the difference
     * between input and accessibility focus.
     */
    public static final int TYPE_VIEW_ACCESSIBILITY_FOCUSED = 1 << 15;

    /**
     * Represents the event of clearing accessibility focus.
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_ACCESSIBILITY_FOCUS for the difference
     * between input and accessibility focus.
     */
    public static final int TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED = 1 << 16;

    /**
     * Represents the event of traversing the text of a view at a given movement granularity.
     */
    public static final int TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY = 1 << 17;

    /**
     * Represents the event of beginning gesture detection.
     */
    public static final int TYPE_GESTURE_DETECTION_START = 1 << 18;

    /**
     * Represents the event of ending gesture detection.
     */
    public static final int TYPE_GESTURE_DETECTION_END = 1 << 19;

    /**
     * Represents the event of the user starting to touch the screen.
     */
    public static final int TYPE_TOUCH_INTERACTION_START = 1 << 20;

    /**
     * Represents the event of the user ending to touch the screen.
     */
    public static final int TYPE_TOUCH_INTERACTION_END = 1 << 21;

    /**
     * Represents the event change in the system windows shown on the screen. This event type should
     * only be dispatched by the system.
     */
    public static final int TYPE_WINDOWS_CHANGED = 1 << 22;

    /**
     * Represents the event of a context click on a {@link android.view.View}.
     * <p>See {@link AccessibilityNodeInfo.AccessibilityAction#ACTION_CONTEXT_CLICK} for more
     * details.
     */
    public static final int TYPE_VIEW_CONTEXT_CLICKED = 1 << 23;

    /**
     * Represents the event of the assistant currently reading the users screen context.
     */
    public static final int TYPE_ASSIST_READING_CONTEXT = 1 << 24;

    /**
     * Represents a change in the speech state defined by the speech state change types.
     * A change in the speech state occurs when an application wants to signal that it is either
     * speaking or listening for human speech.
     * This event helps avoid conflicts where two applications want to speak or one listens
     * when another speaks.
     * When sending this event, the sender should ensure that  the accompanying state change types
     * make sense. For example, the sender should not send
     * {@link #SPEECH_STATE_SPEAKING_START} and {@link #SPEECH_STATE_SPEAKING_END} together.
     * @see #SPEECH_STATE_SPEAKING_START
     * @see #SPEECH_STATE_SPEAKING_END
     * @see #SPEECH_STATE_LISTENING_START
     * @see #SPEECH_STATE_LISTENING_END
     * @see #getSpeechStateChangeTypes
     * @see #setSpeechStateChangeTypes
     */
    public static final int TYPE_SPEECH_STATE_CHANGE = 1 << 25;

    /**
     * Represents the event of a scroll having completed and brought the target node on screen.
     */
    public static final int TYPE_VIEW_TARGETED_BY_SCROLL = 1 << 26;

    // Content change types.

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event: The type of change is not
     * defined.
     */
    public static final int CONTENT_CHANGE_TYPE_UNDEFINED = 0;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * One or more content changes occurred in the the subtree rooted at the source node,
     * or the subtree's structure changed when a node was added or removed.
     */
    public static final int CONTENT_CHANGE_TYPE_SUBTREE = 1 /* << 0 */;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * The node's text changed.
     * @see AccessibilityNodeInfo#setText(CharSequence)
     */
    public static final int CONTENT_CHANGE_TYPE_TEXT = 1 << 1;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * The node's content description changed.
     */
    public static final int CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION = 1 << 2;

    /**
     * Change type for {@link #TYPE_WINDOW_STATE_CHANGED} event:
     * The node's pane title changed.
     * <p>
     * If this makes the pane appear, {@link #CONTENT_CHANGE_TYPE_PANE_APPEARED} is sent
     * instead. If this makes the pane disappear, {@link #CONTENT_CHANGE_TYPE_PANE_DISAPPEARED}
     * is sent.
     * @see View#setAccessibilityPaneTitle(CharSequence)
     */
    public static final int CONTENT_CHANGE_TYPE_PANE_TITLE = 1 << 3;

    /**
     * Change type for {@link #TYPE_WINDOW_STATE_CHANGED} event:
     * The node has a pane title, and either just appeared or just was assigned a title when it
     * had none before.
     * @see View#setAccessibilityPaneTitle(CharSequence)
     */
    public static final int CONTENT_CHANGE_TYPE_PANE_APPEARED = 1 << 4;

    /**
     * Change type for {@link #TYPE_WINDOW_STATE_CHANGED} event:
     * Can mean one of two slightly different things. The primary meaning is that the node has
     * a pane title, and was removed from the node hierarchy. It will also be sent if the pane
     * title is set to {@code null} after it contained a title.
     * No source will be returned if the node is no longer on the screen. To make the change more
     * clear for the user, the first entry in {@link #getText()} will return the value that would
     * have been returned by {@code getSource().getPaneTitle()}.
     * @see View#setAccessibilityPaneTitle(CharSequence)
     */
    public static final int CONTENT_CHANGE_TYPE_PANE_DISAPPEARED = 1 << 5;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * state description of the node as returned by
     * {@link AccessibilityNodeInfo#getStateDescription} changed. If part of the state description
     * changes, the changed part can be put into event text. For example, if state description
     * changed from "on, wifi signal full" to "on, wifi three bars", "wifi three bars" can be put
     * into the event text.
     * @see View#setStateDescription(CharSequence)
     */
    public static final int CONTENT_CHANGE_TYPE_STATE_DESCRIPTION = 1 << 6;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * A drag has started while accessibility is enabled. This is either via an
     * AccessibilityAction, or via touch events. This is sent from the source that initiated the
     * drag.
     *
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_DRAG_START
     */
    public static final int CONTENT_CHANGE_TYPE_DRAG_STARTED = 1 << 7;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * A drag in with accessibility enabled has ended. This means the content has been
     * successfully dropped. This is sent from the target that accepted the dragged content.
     *
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_DRAG_DROP
     */
    public static final int CONTENT_CHANGE_TYPE_DRAG_DROPPED = 1 << 8;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * A drag in with accessibility enabled has ended. This means the content has been
     * unsuccessfully dropped, the user has canceled the action via an AccessibilityAction, or
     * no drop has been detected within a timeout and the drag was automatically cancelled. This is
     * sent from the source that initiated the drag.
     *
     * @see AccessibilityNodeInfo.AccessibilityAction#ACTION_DRAG_CANCEL
     */
    public static final int CONTENT_CHANGE_TYPE_DRAG_CANCELLED = 1 << 9;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * The source node changed its content validity returned by
     * {@link AccessibilityNodeInfo#isContentInvalid}.
     * The view changing content validity should call
     * {@link AccessibilityNodeInfo#setContentInvalid} and then send this event.
     *
     * @see AccessibilityNodeInfo#isContentInvalid
     * @see AccessibilityNodeInfo#setContentInvalid
     */
    public static final int CONTENT_CHANGE_TYPE_CONTENT_INVALID = 1 << 10;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * The source node changed its erroneous content's error message returned by
     * {@link AccessibilityNodeInfo#getError}.
     * The view changing erroneous content's error message should call
     * {@link AccessibilityNodeInfo#setError} and then send this event.
     *
     * @see AccessibilityNodeInfo#getError
     * @see AccessibilityNodeInfo#setError
     */
    public static final int CONTENT_CHANGE_TYPE_ERROR = 1 << 11;

    /**
     * Change type for {@link #TYPE_WINDOW_CONTENT_CHANGED} event:
     * The source node changed its ability to interact returned by
     * {@link AccessibilityNodeInfo#isEnabled}.
     * The view changing content's ability to interact should call
     * {@link AccessibilityNodeInfo#setEnabled} and then send this event.
     *
     * @see AccessibilityNodeInfo#isEnabled
     * @see AccessibilityNodeInfo#setEnabled
     */
    public static final int CONTENT_CHANGE_TYPE_ENABLED = 1 << 12;

    // Speech state change types.

    /** Change type for {@link #TYPE_SPEECH_STATE_CHANGE} event: another service is speaking. */
    public static final int SPEECH_STATE_SPEAKING_START = 1 /* << 0 */;;

    /**
     * Change type for {@link #TYPE_SPEECH_STATE_CHANGE} event: another service is no longer
     * speaking.
     */
    public static final int SPEECH_STATE_SPEAKING_END = 1 << 1;

    /**
     * Change type for {@link #TYPE_SPEECH_STATE_CHANGE} event: another service is listening to the
     * microphone.
     */
    public static final int SPEECH_STATE_LISTENING_START = 1 << 2;

    /**
     * Change type for {@link #TYPE_SPEECH_STATE_CHANGE} event: another service is no longer
     * listening to the microphone.
     */
    public static final int SPEECH_STATE_LISTENING_END = 1 << 3;

    // Windows change types.

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window was added.
     */
    public static final int WINDOWS_CHANGE_ADDED = 1 /* << 0 */;;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * A window was removed.
     */
    public static final int WINDOWS_CHANGE_REMOVED = 1 << 1;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's title changed.
     */
    public static final int WINDOWS_CHANGE_TITLE = 1 << 2;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's bounds changed.
     * <p>
     * Starting in {@link android.os.Build.VERSION_CODES#R R}, this event implies the window's
     * region changed. It's also possible that region changed but bounds doesn't.
     * </p>
     */
    public static final int WINDOWS_CHANGE_BOUNDS = 1 << 3;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's layer changed.
     */
    public static final int WINDOWS_CHANGE_LAYER = 1 << 4;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's {@link AccessibilityWindowInfo#isActive()} changed.
     */
    public static final int WINDOWS_CHANGE_ACTIVE = 1 << 5;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's {@link AccessibilityWindowInfo#isFocused()} changed.
     */
    public static final int WINDOWS_CHANGE_FOCUSED = 1 << 6;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's {@link AccessibilityWindowInfo#isAccessibilityFocused()} changed.
     */
    public static final int WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED = 1 << 7;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's parent changed.
     */
    public static final int WINDOWS_CHANGE_PARENT = 1 << 8;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window's children changed.
     */
    public static final int WINDOWS_CHANGE_CHILDREN = 1 << 9;

    /**
     * Change type for {@link #TYPE_WINDOWS_CHANGED} event:
     * The window either entered or exited picture-in-picture mode.
     */
    public static final int WINDOWS_CHANGE_PIP = 1 << 10;

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(flag = true, prefix = { "WINDOWS_CHANGE_" }, value = {
            WINDOWS_CHANGE_ADDED,
            WINDOWS_CHANGE_REMOVED,
            WINDOWS_CHANGE_TITLE,
            WINDOWS_CHANGE_BOUNDS,
            WINDOWS_CHANGE_LAYER,
            WINDOWS_CHANGE_ACTIVE,
            WINDOWS_CHANGE_FOCUSED,
            WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED,
            WINDOWS_CHANGE_PARENT,
            WINDOWS_CHANGE_CHILDREN,
            WINDOWS_CHANGE_PIP
    })
    public @interface WindowsChangeTypes {}

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
            flag = true,
            prefix = {"CONTENT_CHANGE_TYPE_"},
            value = {
                CONTENT_CHANGE_TYPE_UNDEFINED,
                CONTENT_CHANGE_TYPE_SUBTREE,
                CONTENT_CHANGE_TYPE_TEXT,
                CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION,
                CONTENT_CHANGE_TYPE_STATE_DESCRIPTION,
                CONTENT_CHANGE_TYPE_PANE_TITLE,
                CONTENT_CHANGE_TYPE_PANE_APPEARED,
                CONTENT_CHANGE_TYPE_PANE_DISAPPEARED,
                CONTENT_CHANGE_TYPE_DRAG_STARTED,
                CONTENT_CHANGE_TYPE_DRAG_DROPPED,
                CONTENT_CHANGE_TYPE_DRAG_CANCELLED,
                CONTENT_CHANGE_TYPE_CONTENT_INVALID,
                CONTENT_CHANGE_TYPE_ERROR,
                CONTENT_CHANGE_TYPE_ENABLED,
            })
    public @interface ContentChangeTypes {}

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
            flag = true,
            prefix = {"SPEECH_STATE_"},
            value = {
                SPEECH_STATE_SPEAKING_START,
                SPEECH_STATE_SPEAKING_END,
                SPEECH_STATE_LISTENING_START,
                SPEECH_STATE_LISTENING_END
            })
    public @interface SpeechStateChangeTypes {}

    /** @hide */
    @Retention(RetentionPolicy.SOURCE)
    @IntDef(
            flag = true,
            prefix = {"TYPE_"},
            value = {
                TYPE_VIEW_CLICKED,
                TYPE_VIEW_LONG_CLICKED,
                TYPE_VIEW_SELECTED,
                TYPE_VIEW_FOCUSED,
                TYPE_VIEW_TEXT_CHANGED,
                TYPE_WINDOW_STATE_CHANGED,
                TYPE_NOTIFICATION_STATE_CHANGED,
                TYPE_VIEW_HOVER_ENTER,
                TYPE_VIEW_HOVER_EXIT,
                TYPE_TOUCH_EXPLORATION_GESTURE_START,
                TYPE_TOUCH_EXPLORATION_GESTURE_END,
                TYPE_WINDOW_CONTENT_CHANGED,
                TYPE_VIEW_SCROLLED,
                TYPE_VIEW_TEXT_SELECTION_CHANGED,
                TYPE_ANNOUNCEMENT,
                TYPE_VIEW_ACCESSIBILITY_FOCUSED,
                TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED,
                TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY,
                TYPE_GESTURE_DETECTION_START,
                TYPE_GESTURE_DETECTION_END,
                TYPE_TOUCH_INTERACTION_START,
                TYPE_TOUCH_INTERACTION_END,
                TYPE_WINDOWS_CHANGED,
                TYPE_VIEW_CONTEXT_CLICKED,
                TYPE_ASSIST_READING_CONTEXT,
                TYPE_SPEECH_STATE_CHANGE,
                TYPE_VIEW_TARGETED_BY_SCROLL
            })
    public @interface EventType {}

    /**
     * Mask for {@link AccessibilityEvent} all types.
     *
     * @see #TYPE_VIEW_CLICKED
     * @see #TYPE_VIEW_LONG_CLICKED
     * @see #TYPE_VIEW_SELECTED
     * @see #TYPE_VIEW_FOCUSED
     * @see #TYPE_VIEW_TEXT_CHANGED
     * @see #TYPE_WINDOW_STATE_CHANGED
     * @see #TYPE_NOTIFICATION_STATE_CHANGED
     * @see #TYPE_VIEW_HOVER_ENTER
     * @see #TYPE_VIEW_HOVER_EXIT
     * @see #TYPE_TOUCH_EXPLORATION_GESTURE_START
     * @see #TYPE_TOUCH_EXPLORATION_GESTURE_END
     * @see #TYPE_WINDOW_CONTENT_CHANGED
     * @see #TYPE_VIEW_SCROLLED
     * @see #TYPE_VIEW_TEXT_SELECTION_CHANGED
     * @see #TYPE_ANNOUNCEMENT
     * @see #TYPE_VIEW_ACCESSIBILITY_FOCUSED
     * @see #TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED
     * @see #TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY
     * @see #TYPE_GESTURE_DETECTION_START
     * @see #TYPE_GESTURE_DETECTION_END
     * @see #TYPE_TOUCH_INTERACTION_START
     * @see #TYPE_TOUCH_INTERACTION_END
     * @see #TYPE_WINDOWS_CHANGED
     * @see #TYPE_VIEW_CONTEXT_CLICKED
     * @see #TYPE_ASSIST_READING_CONTEXT
     * @see #TYPE_SPEECH_STATE_CHANGE
     * @see #TYPE_VIEW_TARGETED_BY_SCROLL
     */
    public static final int TYPES_ALL_MASK = 0xFFFFFFFF;

    @UnsupportedAppUsage
    @EventType
    private int mEventType;
    private CharSequence mPackageName;
    private long mEventTime;
    int mMovementGranularity;
    @UnsupportedAppUsage(maxTargetSdk = Build.VERSION_CODES.P, trackingBug = 115609023)
    int mAction;
    int mContentChangeTypes;
    int mWindowChangeTypes;
    int mSpeechStateChangeTypes;

    /**
     * The stack trace describing where this event originated from on the app side.
     * Only populated if {@link #DEBUG_ORIGIN} is enabled
     * Can be inspected(e.g. printed) from an
     * {@link android.accessibilityservice.AccessibilityService} to trace where particular events
     * are being dispatched from.
     *
     * @hide
     */
    public StackTraceElement[] originStackTrace = null;

    private ArrayList<AccessibilityRecord> mRecords;

    /**
     * Creates a new {@link AccessibilityEvent}.
     */
    public AccessibilityEvent() {
        if (DEBUG_ORIGIN) originStackTrace = Thread.currentThread().getStackTrace();
    }


    /**
     * Creates a new {@link AccessibilityEvent} with the given <code>eventType</code>.
     *
     * @param eventType The event type.
     */
    public AccessibilityEvent(int eventType) {
        mEventType = eventType;
        if (DEBUG_ORIGIN) originStackTrace = Thread.currentThread().getStackTrace();
    }

    /**
     * Copy constructor. Creates a new {@link AccessibilityEvent}, and this instance is initialized
     * from the given <code>event</code>.
     *
     * @param event The other event.
     */
    public AccessibilityEvent(@NonNull AccessibilityEvent event) {
        init(event);
    }

    /**
     * Initialize an event from another one.
     *
     * @param event The event to initialize from.
     */
    void init(AccessibilityEvent event) {
        super.init(event);
        mEventType = event.mEventType;
        mMovementGranularity = event.mMovementGranularity;
        mAction = event.mAction;
        mContentChangeTypes = event.mContentChangeTypes;
        mSpeechStateChangeTypes = event.mSpeechStateChangeTypes;
        mWindowChangeTypes = event.mWindowChangeTypes;
        mEventTime = event.mEventTime;
        mPackageName = event.mPackageName;
        if (event.mRecords != null) {
            mRecords = new ArrayList<>(event.mRecords.size());
            for (AccessibilityRecord record : event.mRecords) {
                final AccessibilityRecord recordClone = new AccessibilityRecord(record);
                mRecords.add(recordClone);
            }
        }
        if (DEBUG_ORIGIN) originStackTrace = event.originStackTrace;
    }

    /**
     * Sets if this instance is sealed.
     *
     * @param sealed Whether is sealed.
     *
     * @hide
     */
    @Override
    public void setSealed(boolean sealed) {
        super.setSealed(sealed);
        final List<AccessibilityRecord> records = mRecords;
        if (records != null) {
            for (AccessibilityRecord record : records) {
                record.setSealed(sealed);
            }
        }
    }

    /**
     * Gets the number of records contained in the event.
     *
     * @return The number of records.
     */
    public int getRecordCount() {
        return mRecords == null ? 0 : mRecords.size();
    }

    /**
     * Appends an {@link AccessibilityRecord} to the end of event records.
     *
     * @param record The record to append.
     *
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    public void appendRecord(AccessibilityRecord record) {
        enforceNotSealed();
        if (mRecords == null) {
            mRecords = new ArrayList<AccessibilityRecord>();
        }
        mRecords.add(record);
    }

    /**
     * Gets the record at a given index.
     *
     * @param index The index.
     * @return The record at the specified index.
     */
    public AccessibilityRecord getRecord(int index) {
        if (mRecords == null) {
            throw new IndexOutOfBoundsException("Invalid index " + index + ", size is 0");
        }
        return mRecords.get(index);
    }

    /**
     * Gets the event type.
     *
     * @return The event type.
     */
    @EventType
    public int getEventType() {
        return mEventType;
    }

    /**
     * Gets the bit mask of change types signaled by a
     * {@link #TYPE_WINDOW_CONTENT_CHANGED} event or {@link #TYPE_WINDOW_STATE_CHANGED}. A single
     * event may represent multiple change types.
     *
     * @return The bit mask of change types. One or more of:
     *         <ul>
     *         <li>{@link #CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION}
     *         <li>{@link #CONTENT_CHANGE_TYPE_STATE_DESCRIPTION}
     *         <li>{@link #CONTENT_CHANGE_TYPE_SUBTREE}
     *         <li>{@link #CONTENT_CHANGE_TYPE_TEXT}
     *         <li>{@link #CONTENT_CHANGE_TYPE_PANE_TITLE}
     *         <li>{@link #CONTENT_CHANGE_TYPE_UNDEFINED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_PANE_APPEARED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_PANE_DISAPPEARED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_DRAG_STARTED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_DRAG_DROPPED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_DRAG_CANCELLED}
     *         <li>{@link #CONTENT_CHANGE_TYPE_CONTENT_INVALID}
     *         <li>{@link #CONTENT_CHANGE_TYPE_ERROR}
     *         <li>{@link #CONTENT_CHANGE_TYPE_ENABLED}
     *         </ul>
     */
    @ContentChangeTypes
    public int getContentChangeTypes() {
        return mContentChangeTypes;
    }

    private static String contentChangeTypesToString(int types) {
        return BitUtils.flagsToString(types, AccessibilityEvent::singleContentChangeTypeToString);
    }

    private static String singleContentChangeTypeToString(int type) {
        switch (type) {
            case CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION:
                return "CONTENT_CHANGE_TYPE_CONTENT_DESCRIPTION";
            case CONTENT_CHANGE_TYPE_STATE_DESCRIPTION:
                return "CONTENT_CHANGE_TYPE_STATE_DESCRIPTION";
            case CONTENT_CHANGE_TYPE_SUBTREE: return "CONTENT_CHANGE_TYPE_SUBTREE";
            case CONTENT_CHANGE_TYPE_TEXT: return "CONTENT_CHANGE_TYPE_TEXT";
            case CONTENT_CHANGE_TYPE_PANE_TITLE: return "CONTENT_CHANGE_TYPE_PANE_TITLE";
            case CONTENT_CHANGE_TYPE_UNDEFINED: return "CONTENT_CHANGE_TYPE_UNDEFINED";
            case CONTENT_CHANGE_TYPE_PANE_APPEARED: return "CONTENT_CHANGE_TYPE_PANE_APPEARED";
            case CONTENT_CHANGE_TYPE_PANE_DISAPPEARED:
                return "CONTENT_CHANGE_TYPE_PANE_DISAPPEARED";
            case CONTENT_CHANGE_TYPE_DRAG_STARTED: return "CONTENT_CHANGE_TYPE_DRAG_STARTED";
            case CONTENT_CHANGE_TYPE_DRAG_DROPPED: return "CONTENT_CHANGE_TYPE_DRAG_DROPPED";
            case CONTENT_CHANGE_TYPE_DRAG_CANCELLED: return "CONTENT_CHANGE_TYPE_DRAG_CANCELLED";
            case CONTENT_CHANGE_TYPE_CONTENT_INVALID:
                return "CONTENT_CHANGE_TYPE_CONTENT_INVALID";
            case CONTENT_CHANGE_TYPE_ERROR: return "CONTENT_CHANGE_TYPE_ERROR";
            case CONTENT_CHANGE_TYPE_ENABLED: return "CONTENT_CHANGE_TYPE_ENABLED";
            default: return Integer.toHexString(type);
        }
    }

    /**
     * Sets the bit mask of node tree changes signaled by an
     * {@link #TYPE_WINDOW_CONTENT_CHANGED} event.
     *
     * @param changeTypes The bit mask of change types.
     * @throws IllegalStateException If called from an AccessibilityService.
     * @see #getContentChangeTypes()
     */
    public void setContentChangeTypes(@ContentChangeTypes int changeTypes) {
        enforceNotSealed();
        mContentChangeTypes = changeTypes;
    }

    /**
     * Whether the event should only be delivered to an
     * {@link android.accessibilityservice.AccessibilityService} with the
     * {@link android.accessibilityservice.AccessibilityServiceInfo#isAccessibilityTool} property
     * set to true.
     *
     * <p>
     * Initial value matches the {@link android.view.View#isAccessibilityDataSensitive} property
     * from the event's source node, if present, or false by default.
     * </p>
     *
     * @return True if the event should be delivered only to isAccessibilityTool services, false
     * otherwise.
     * @see #setAccessibilityDataSensitive
     */
    @Override
    public boolean isAccessibilityDataSensitive() {
        return super.isAccessibilityDataSensitive();
    }

    /**
     * Sets whether the event should only be delivered to an
     * {@link android.accessibilityservice.AccessibilityService} with the
     * {@link android.accessibilityservice.AccessibilityServiceInfo#isAccessibilityTool} property
     * set to true.
     *
     * <p>
     * This will be set automatically based on the event's source (if present). If creating and
     * sending an event directly through {@link AccessibilityManager} (where an event may have
     * no source) then this method must be called explicitly if you want non-default behavior.
     * </p>
     *
     * @param accessibilityDataSensitive True if the event should be delivered only to
     *                                 isAccessibilityTool services, false otherwise.
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    @Override
    public void setAccessibilityDataSensitive(boolean accessibilityDataSensitive) {
        super.setAccessibilityDataSensitive(accessibilityDataSensitive);
    }

    /**
     * Gets the bit mask of the speech state signaled by a {@link #TYPE_SPEECH_STATE_CHANGE} event.
     *
     * @return The bit mask of speech change types.
     *
     * @see #SPEECH_STATE_SPEAKING_START
     * @see #SPEECH_STATE_SPEAKING_END
     * @see #SPEECH_STATE_LISTENING_START
     * @see #SPEECH_STATE_LISTENING_END
     */
    public int getSpeechStateChangeTypes() {
        return mSpeechStateChangeTypes;
    }

    private static String speechStateChangeTypesToString(int types) {
        return BitUtils.flagsToString(
                types, AccessibilityEvent::singleSpeechStateChangeTypeToString);
    }

    private static String singleSpeechStateChangeTypeToString(int type) {
        switch (type) {
            case SPEECH_STATE_SPEAKING_START:
                return "SPEECH_STATE_SPEAKING_START";
            case SPEECH_STATE_LISTENING_START:
                return "SPEECH_STATE_LISTENING_START";
            case SPEECH_STATE_SPEAKING_END:
                return "SPEECH_STATE_SPEAKING_END";
            case SPEECH_STATE_LISTENING_END:
                return "SPEECH_STATE_LISTENING_END";
            default:
                return Integer.toHexString(type);
        }
    }

    /**
     * Sets the bit mask of the speech state change types
     * signaled by a {@link #TYPE_SPEECH_STATE_CHANGE} event.
     * The sender is responsible for ensuring that  the state change types  make sense. For example,
     * the sender should not send
     * {@link #SPEECH_STATE_SPEAKING_START} and {@link #SPEECH_STATE_SPEAKING_END} together.
     *
     * @see #SPEECH_STATE_SPEAKING_START
     * @see #SPEECH_STATE_SPEAKING_END
     * @see #SPEECH_STATE_LISTENING_START
     * @see #SPEECH_STATE_LISTENING_END
     */
    public void setSpeechStateChangeTypes(@SpeechStateChangeTypes int state) {
        enforceNotSealed();
        mSpeechStateChangeTypes = state;
    }

    /**
     * Get the bit mask of change types signaled by a {@link #TYPE_WINDOWS_CHANGED} event. A
     * single event may represent multiple change types.
     *
     * @return The bit mask of change types.
     *
     * @see #WINDOWS_CHANGE_ADDED
     * @see #WINDOWS_CHANGE_REMOVED
     * @see #WINDOWS_CHANGE_TITLE
     * @see #WINDOWS_CHANGE_BOUNDS
     * @see #WINDOWS_CHANGE_LAYER
     * @see #WINDOWS_CHANGE_ACTIVE
     * @see #WINDOWS_CHANGE_FOCUSED
     * @see #WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED
     * @see #WINDOWS_CHANGE_PARENT
     * @see #WINDOWS_CHANGE_CHILDREN
     * @see #WINDOWS_CHANGE_PIP
     */
    @WindowsChangeTypes
    public int getWindowChanges() {
        return mWindowChangeTypes;
    }

    /** @hide  */
    public void setWindowChanges(@WindowsChangeTypes int changes) {
        mWindowChangeTypes = changes;
    }

    private static String windowChangeTypesToString(@WindowsChangeTypes int types) {
        return BitUtils.flagsToString(types, AccessibilityEvent::singleWindowChangeTypeToString);
    }

    private static String singleWindowChangeTypeToString(int type) {
        switch (type) {
            case WINDOWS_CHANGE_ADDED: return "WINDOWS_CHANGE_ADDED";
            case WINDOWS_CHANGE_REMOVED: return "WINDOWS_CHANGE_REMOVED";
            case WINDOWS_CHANGE_TITLE: return "WINDOWS_CHANGE_TITLE";
            case WINDOWS_CHANGE_BOUNDS: return "WINDOWS_CHANGE_BOUNDS";
            case WINDOWS_CHANGE_LAYER: return "WINDOWS_CHANGE_LAYER";
            case WINDOWS_CHANGE_ACTIVE: return "WINDOWS_CHANGE_ACTIVE";
            case WINDOWS_CHANGE_FOCUSED: return "WINDOWS_CHANGE_FOCUSED";
            case WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED:
                return "WINDOWS_CHANGE_ACCESSIBILITY_FOCUSED";
            case WINDOWS_CHANGE_PARENT: return "WINDOWS_CHANGE_PARENT";
            case WINDOWS_CHANGE_CHILDREN: return "WINDOWS_CHANGE_CHILDREN";
            case WINDOWS_CHANGE_PIP: return "WINDOWS_CHANGE_PIP";
            default: return Integer.toHexString(type);
        }
    }

    /**
     * Sets the event type.
     *
     * <b>Note: An event must represent a single event type.</b>
     * @param eventType The event type.
     *
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    public void setEventType(@EventType int eventType) {
        enforceNotSealed();
        mEventType = eventType;
    }

    /**
     * Gets the time in which this event was sent.
     *
     * @return The event time.
     */
    public long getEventTime() {
        return mEventTime;
    }

    /**
     * Sets the time in which this event was sent.
     *
     * @param eventTime The event time.
     *
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    public void setEventTime(long eventTime) {
        enforceNotSealed();
        mEventTime = eventTime;
    }

    /**
     * Gets the package name of the source.
     *
     * @return The package name.
     */
    public CharSequence getPackageName() {
        return mPackageName;
    }

    /**
     * Sets the package name of the source.
     *
     * @param packageName The package name.
     *
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    public void setPackageName(CharSequence packageName) {
        enforceNotSealed();
        mPackageName = packageName;
    }

    /**
     * Sets the movement granularity that was traversed.
     *
     * @param granularity The granularity.
     *
     * @throws IllegalStateException If called from an AccessibilityService.
     */
    public void setMovementGranularity(int granularity) {
        enforceNotSealed();
        mMovementGranularity = granularity;
    }

    /**
     * Gets the movement granularity that was traversed.
     *
     * @return The granularity.
     */
    public int getMovementGranularity() {
        return mMovementGranularity;
    }

    /**
     * Sets the performed action that triggered this event.
     * <p>
     * Valid actions are defined in {@link AccessibilityNodeInfo}:
     * <ul>
     * <li>{@link AccessibilityNodeInfo#ACTION_ACCESSIBILITY_FOCUS}
     * <li>{@link AccessibilityNodeInfo#ACTION_CLEAR_ACCESSIBILITY_FOCUS}
     * <li>{@link AccessibilityNodeInfo#ACTION_CLEAR_FOCUS}
     * <li>{@link AccessibilityNodeInfo#ACTION_CLEAR_SELECTION}
     * <li>{@link AccessibilityNodeInfo#ACTION_CLICK}
     * <li>{@link AccessibilityNodeInfo#ACTION_LONG_CLICK}
     * <li>{@link AccessibilityNodeInfo#ACTION_NEXT_AT_MOVEMENT_GRANULARITY}
     * <li>{@link AccessibilityNodeInfo#ACTION_PREVIOUS_AT_MOVEMENT_GRANULARITY}
     * <li>{@link AccessibilityNodeInfo#ACTION_NEXT_HTML_ELEMENT}
     * <li>{@link AccessibilityNodeInfo#ACTION_PREVIOUS_HTML_ELEMENT}
     * <li>{@link AccessibilityNodeInfo#ACTION_SCROLL_FORWARD}
     * <li>{@link AccessibilityNodeInfo#ACTION_SCROLL_BACKWARD}
     * <li>{@link AccessibilityNodeInfo#ACTION_COPY}
     * <li>{@link AccessibilityNodeInfo#ACTION_PASTE}
     * <li>{@link AccessibilityNodeInfo#ACTION_CUT}
     * <li>{@link AccessibilityNodeInfo#ACTION_SET_SELECTION}
     * <li>{@link AccessibilityNodeInfo#ACTION_EXPAND}
     * <li>{@link AccessibilityNodeInfo#ACTION_COLLAPSE}
     * <li>{@link AccessibilityNodeInfo#ACTION_DISMISS}
     * <li>{@link AccessibilityNodeInfo#ACTION_SET_TEXT}
     * <li>etc.
     * </ul>
     *
     * @param action The action.
     * @throws IllegalStateException If called from an AccessibilityService.
     * @see AccessibilityNodeInfo#performAction(int)
     */
    public void setAction(int action) {
        enforceNotSealed();
        mAction = action;
    }

    /**
     * Gets the performed action that triggered this event.
     *
     * @return The action.
     */
    public int getAction() {
        return mAction;
    }

    /**
     * Convenience method to obtain a {@link #TYPE_WINDOWS_CHANGED} event for a specific window and
     * change set.
     *
     * @param displayId The ID of the display from which the event comes from
     * @param windowId The ID of the window that changed
     * @param windowChangeTypes The changes to populate
     * @return An instance of a TYPE_WINDOWS_CHANGED, populated with the requested fields and with
     *         importantForAccessibility set to {@code true}.
     *
     * @hide
     */
    public static AccessibilityEvent obtainWindowsChangedEvent(
            int displayId, int windowId, int windowChangeTypes) {
        final AccessibilityEvent event = new AccessibilityEvent(TYPE_WINDOWS_CHANGED);
        event.setDisplayId(displayId);
        event.setWindowId(windowId);
        event.setWindowChanges(windowChangeTypes);
        event.setImportantForAccessibility(true);
        return event;
    }

    /**
     * Instantiates a new AccessibilityEvent instance with its type property set.
     *
     * @deprecated Object pooling has been discontinued. Create a new instance using the
     * constructor {@link #AccessibilityEvent()} instead.
     * @param eventType The event type.
     * @return An instance.
     */
    @Deprecated
    public static AccessibilityEvent obtain(int eventType) {
        AccessibilityEvent event = new AccessibilityEvent();
        event.setEventType(eventType);
        return event;
    }

    /**
     * Instantiates a new AccessibilityEvent instance.
     * The returned instance is initialized from the given
     * <code>event</code>.
     *
     * @deprecated Object pooling has been discontinued. Create a new instance using the
     * constructor {@link #AccessibilityEvent()} instead.
     * @param event The other event.
     * @return An instance.
     */
    @Deprecated
    public static AccessibilityEvent obtain(AccessibilityEvent event) {
        AccessibilityEvent eventClone = new AccessibilityEvent();
        eventClone.init(event);
        return eventClone;
    }

    /**
     * Instantiates a new AccessibilityEvent instance.
     *
     * @deprecated Object pooling has been discontinued. Create a new instance using the
     * constructor {@link #AccessibilityEvent()} instead.
     * @return An instance.
     */
    @Deprecated
    public static AccessibilityEvent obtain() {
        return new AccessibilityEvent();
    }

    /**
     * Previously would recycle an instance back to be reused.
     *
     * @deprecated Object pooling has been discontinued. Calling this function now will have
     * no effect.
     */
    @Override
    @Deprecated
    public void recycle() {}

    /**
     * Clears the state of this instance.
     *
     * @hide
     */
    @Override
    protected void clear() {
        super.clear();
        mEventType = 0;
        mMovementGranularity = 0;
        mAction = 0;
        mContentChangeTypes = 0;
        mWindowChangeTypes = 0;
        mSpeechStateChangeTypes = 0;
        mPackageName = null;
        mEventTime = 0;
        if (mRecords != null) {
            while (!mRecords.isEmpty()) {
                AccessibilityRecord record = mRecords.remove(0);
            }
        }
        if (DEBUG_ORIGIN) originStackTrace = null;
    }

    /**
     * Creates a new instance from a {@link Parcel}.
     *
     * @param parcel A parcel containing the state of a {@link AccessibilityEvent}.
     */
    public void initFromParcel(Parcel parcel) {
        mSealed = (parcel.readInt() == 1);
        mEventType = parcel.readInt();
        mMovementGranularity = parcel.readInt();
        mAction = parcel.readInt();
        mContentChangeTypes = parcel.readInt();
        mWindowChangeTypes = parcel.readInt();
        mSpeechStateChangeTypes = parcel.readInt();
        mPackageName = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
        mEventTime = parcel.readLong();
        mConnectionId = parcel.readInt();
        readAccessibilityRecordFromParcel(this, parcel);

        // Read the records.
        final int recordCount = parcel.readInt();
        if (recordCount > 0) {
            mRecords = new ArrayList<>(recordCount);
            for (int i = 0; i < recordCount; i++) {
                AccessibilityRecord record = new AccessibilityRecord();
                readAccessibilityRecordFromParcel(record, parcel);
                record.mConnectionId = mConnectionId;
                mRecords.add(record);
            }
        }

        if (DEBUG_ORIGIN) {
            originStackTrace = new StackTraceElement[parcel.readInt()];
            for (int i = 0; i < originStackTrace.length; i++) {
                originStackTrace[i] = new StackTraceElement(
                        parcel.readString(),
                        parcel.readString(),
                        parcel.readString(),
                        parcel.readInt());
            }
        }
    }

    /**
     * Reads an {@link AccessibilityRecord} from a parcel.
     *
     * @param record The record to initialize.
     * @param parcel The parcel to read from.
     */
    private void readAccessibilityRecordFromParcel(AccessibilityRecord record,
            Parcel parcel) {
        record.mBooleanProperties = parcel.readInt();
        record.mCurrentItemIndex = parcel.readInt();
        record.mItemCount = parcel.readInt();
        record.mFromIndex = parcel.readInt();
        record.mToIndex = parcel.readInt();
        record.mScrollX = parcel.readInt();
        record.mScrollY =  parcel.readInt();
        record.mScrollDeltaX =  parcel.readInt();
        record.mScrollDeltaY =  parcel.readInt();
        record.mMaxScrollX = parcel.readInt();
        record.mMaxScrollY =  parcel.readInt();
        record.mAddedCount = parcel.readInt();
        record.mRemovedCount = parcel.readInt();
        record.mClassName = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
        record.mContentDescription = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
        record.mBeforeText = TextUtils.CHAR_SEQUENCE_CREATOR.createFromParcel(parcel);
        record.mParcelableData = parcel.readParcelable(null);
        parcel.readList(record.mText, null, java.lang.CharSequence.class);
        record.mSourceWindowId = parcel.readInt();
        record.mSourceNodeId = parcel.readLong();
        record.mSourceDisplayId = parcel.readInt();
        record.mSealed = (parcel.readInt() == 1);
    }

    /**
     * {@inheritDoc}
     */
    public void writeToParcel(Parcel parcel, int flags) {
        parcel.writeInt(isSealed() ? 1 : 0);
        parcel.writeInt(mEventType);
        parcel.writeInt(mMovementGranularity);
        parcel.writeInt(mAction);
        parcel.writeInt(mContentChangeTypes);
        parcel.writeInt(mWindowChangeTypes);
        parcel.writeInt(mSpeechStateChangeTypes);
        TextUtils.writeToParcel(mPackageName, parcel, 0);
        parcel.writeLong(mEventTime);
        parcel.writeInt(mConnectionId);
        writeAccessibilityRecordToParcel(this, parcel, flags);

        // Write the records.
        final int recordCount = getRecordCount();
        parcel.writeInt(recordCount);
        for (int i = 0; i < recordCount; i++) {
            AccessibilityRecord record = mRecords.get(i);
            writeAccessibilityRecordToParcel(record, parcel, flags);
        }

        if (DEBUG_ORIGIN) {
            if (originStackTrace == null) originStackTrace = Thread.currentThread().getStackTrace();
            parcel.writeInt(originStackTrace.length);
            for (StackTraceElement element : originStackTrace) {
                parcel.writeString(element.getClassName());
                parcel.writeString(element.getMethodName());
                parcel.writeString(element.getFileName());
                parcel.writeInt(element.getLineNumber());
            }
        }
    }

    /**
     * Writes an {@link AccessibilityRecord} to a parcel.
     *
     * @param record The record to write.
     * @param parcel The parcel to which to write.
     */
    private void writeAccessibilityRecordToParcel(AccessibilityRecord record, Parcel parcel,
            int flags) {
        parcel.writeInt(record.mBooleanProperties);
        parcel.writeInt(record.mCurrentItemIndex);
        parcel.writeInt(record.mItemCount);
        parcel.writeInt(record.mFromIndex);
        parcel.writeInt(record.mToIndex);
        parcel.writeInt(record.mScrollX);
        parcel.writeInt(record.mScrollY);
        parcel.writeInt(record.mScrollDeltaX);
        parcel.writeInt(record.mScrollDeltaY);
        parcel.writeInt(record.mMaxScrollX);
        parcel.writeInt(record.mMaxScrollY);
        parcel.writeInt(record.mAddedCount);
        parcel.writeInt(record.mRemovedCount);
        TextUtils.writeToParcel(record.mClassName, parcel, flags);
        TextUtils.writeToParcel(record.mContentDescription, parcel, flags);
        TextUtils.writeToParcel(record.mBeforeText, parcel, flags);
        parcel.writeParcelable(record.mParcelableData, flags);
        parcel.writeList(record.mText);
        parcel.writeInt(record.mSourceWindowId);
        parcel.writeLong(record.mSourceNodeId);
        parcel.writeInt(record.mSourceDisplayId);
        parcel.writeInt(record.mSealed ? 1 : 0);
    }

    /**
     * {@inheritDoc}
     */
    public int describeContents() {
        return 0;
    }

    @Override
    public String toString() {
        StringBuilder builder = new StringBuilder();
        builder.append("EventType: ").append(eventTypeToString(mEventType));
        builder.append("; EventTime: ").append(mEventTime);
        builder.append("; PackageName: ").append(mPackageName);
        if (!DEBUG_CONCISE_TOSTRING || mMovementGranularity != 0) {
            builder.append("; MovementGranularity: ").append(mMovementGranularity);
        }
        if (!DEBUG_CONCISE_TOSTRING || mAction != 0) {
            builder.append("; Action: ").append(mAction);
        }
        if (!DEBUG_CONCISE_TOSTRING || mContentChangeTypes != 0) {
            builder.append("; ContentChangeTypes: ").append(
                    contentChangeTypesToString(mContentChangeTypes));
        }
        if (!DEBUG_CONCISE_TOSTRING || mWindowChangeTypes != 0) {
            builder.append("; WindowChangeTypes: ").append(
                    windowChangeTypesToString(mWindowChangeTypes));
        }
        super.appendTo(builder);
        if (DEBUG || DEBUG_CONCISE_TOSTRING) {
            if (!DEBUG_CONCISE_TOSTRING) {
                builder.append("\n");
            }
            if (DEBUG) {
                builder.append("; SourceWindowId: 0x").append(Long.toHexString(mSourceWindowId));
                builder.append("; SourceNodeId: 0x").append(Long.toHexString(mSourceNodeId));
                builder.append("; SourceDisplayId: ").append(mSourceDisplayId);
            }
            for (int i = 0; i < getRecordCount(); i++) {
                builder.append("  Record ").append(i).append(":");
                getRecord(i).appendTo(builder).append("\n");
            }
        } else {
            builder.append("; recordCount: ").append(getRecordCount());
        }
        return builder.toString();
    }

    /**
     * Returns the string representation of an event type. For example,
     * {@link #TYPE_VIEW_CLICKED} is represented by the string TYPE_VIEW_CLICKED.
     *
     * @param eventType The event type
     * @return The string representation.
     */
    public static String eventTypeToString(int eventType) {
        if (eventType == TYPES_ALL_MASK) {
            return "TYPES_ALL_MASK";
        }
        StringBuilder builder = new StringBuilder();
        int eventTypeCount = 0;
        while (eventType != 0) {
            final int eventTypeFlag = 1 << Integer.numberOfTrailingZeros(eventType);
            eventType &= ~eventTypeFlag;

            if (eventTypeCount > 0) {
                builder.append(", ");
            }
            builder.append(singleEventTypeToString(eventTypeFlag));

            eventTypeCount++;
        }
        if (eventTypeCount > 1) {
            builder.insert(0, '[');
            builder.append(']');
        }
        return builder.toString();
    }

    private static String singleEventTypeToString(int eventType) {
        switch (eventType) {
            case TYPE_VIEW_CLICKED: return "TYPE_VIEW_CLICKED";
            case TYPE_VIEW_LONG_CLICKED: return "TYPE_VIEW_LONG_CLICKED";
            case TYPE_VIEW_SELECTED: return "TYPE_VIEW_SELECTED";
            case TYPE_VIEW_FOCUSED: return "TYPE_VIEW_FOCUSED";
            case TYPE_VIEW_TEXT_CHANGED: return "TYPE_VIEW_TEXT_CHANGED";
            case TYPE_WINDOW_STATE_CHANGED: return "TYPE_WINDOW_STATE_CHANGED";
            case TYPE_VIEW_HOVER_ENTER: return "TYPE_VIEW_HOVER_ENTER";
            case TYPE_VIEW_HOVER_EXIT: return "TYPE_VIEW_HOVER_EXIT";
            case TYPE_NOTIFICATION_STATE_CHANGED: return "TYPE_NOTIFICATION_STATE_CHANGED";
            case TYPE_TOUCH_EXPLORATION_GESTURE_START: {
                return "TYPE_TOUCH_EXPLORATION_GESTURE_START";
            }
            case TYPE_TOUCH_EXPLORATION_GESTURE_END: return "TYPE_TOUCH_EXPLORATION_GESTURE_END";
            case TYPE_WINDOW_CONTENT_CHANGED: return "TYPE_WINDOW_CONTENT_CHANGED";
            case TYPE_VIEW_TEXT_SELECTION_CHANGED: return "TYPE_VIEW_TEXT_SELECTION_CHANGED";
            case TYPE_VIEW_SCROLLED: return "TYPE_VIEW_SCROLLED";
            case TYPE_ANNOUNCEMENT: return "TYPE_ANNOUNCEMENT";
            case TYPE_VIEW_ACCESSIBILITY_FOCUSED: return "TYPE_VIEW_ACCESSIBILITY_FOCUSED";
            case TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED: {
                return "TYPE_VIEW_ACCESSIBILITY_FOCUS_CLEARED";
            }
            case TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY: {
                return "TYPE_VIEW_TEXT_TRAVERSED_AT_MOVEMENT_GRANULARITY";
            }
            case TYPE_GESTURE_DETECTION_START: return "TYPE_GESTURE_DETECTION_START";
            case TYPE_GESTURE_DETECTION_END: return "TYPE_GESTURE_DETECTION_END";
            case TYPE_TOUCH_INTERACTION_START: return "TYPE_TOUCH_INTERACTION_START";
            case TYPE_TOUCH_INTERACTION_END: return "TYPE_TOUCH_INTERACTION_END";
            case TYPE_WINDOWS_CHANGED: return "TYPE_WINDOWS_CHANGED";
            case TYPE_VIEW_CONTEXT_CLICKED: return "TYPE_VIEW_CONTEXT_CLICKED";
            case TYPE_ASSIST_READING_CONTEXT: return "TYPE_ASSIST_READING_CONTEXT";
            case TYPE_SPEECH_STATE_CHANGE: return "TYPE_SPEECH_STATE_CHANGE";
            case TYPE_VIEW_TARGETED_BY_SCROLL: return "TYPE_VIEW_TARGETED_BY_SCROLL";
            default: return Integer.toHexString(eventType);
        }
    }

    /**
     * @see Parcelable.Creator
     */
    @NonNull
    public static final Parcelable.Creator<AccessibilityEvent> CREATOR =
            new Parcelable.Creator<AccessibilityEvent>() {
        public AccessibilityEvent createFromParcel(Parcel parcel) {
            AccessibilityEvent event = new AccessibilityEvent();
            event.initFromParcel(parcel);
            return event;
        }

        public AccessibilityEvent[] newArray(int size) {
            return new AccessibilityEvent[size];
        }
    };
}