Merge "Remove unnecessary @inheritDoc, add missing @Override to ViewGroup"

        mGroupFlags |= (focusability & FLAG_MASK_FOCUSABILITY);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    void handleFocusGainInternal(int direction, Rect previouslyFocusedRect) {

        if (mFocused != null) {

        super.handleFocusGainInternal(direction, previouslyFocusedRect);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void requestChildFocus(View child, View focused) {

        if (DBG) {

            System.out.println(this + " requestChildFocus()");

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void focusableViewAvailable(View v) {

        if (mParent != null

                // shortcut: don't report a new focusable view if we block our descendants from

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean showContextMenuForChild(View originalView) {

        return mParent != null && mParent.showContextMenuForChild(originalView);

    }

        return mParent != null && mParent.showContextMenuForChild(originalView, x, y);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ActionMode startActionModeForChild(View originalView, ActionMode.Callback callback) {

        if ((mGroupFlags & FLAG_START_ACTION_MODE_FOR_CHILD_IS_TYPED) == 0) {

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public ActionMode startActionModeForChild(

            View originalView, ActionMode.Callback callback, int type) {

     * @param direction One of FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, and

     *        FOCUS_RIGHT, or 0 for not applicable.

     */

    @Override

    public View focusSearch(View focused, int direction) {

        if (isRootNamespace()) {

            // root namespace means we should consider ourselves the top of the

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean requestChildRectangleOnScreen(View child, Rect rectangle, boolean immediate) {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean requestSendAccessibilityEvent(View child, AccessibilityEvent event) {

        ViewParent parent = mParent;

    /**

     * Called when a child view has changed whether or not it is tracking transient state.

     */

    @Override

    public void childHasTransientStateChanged(View child, boolean childHasTransientState) {

        final boolean oldHasTransientState = hasTransientState();

        if (childHasTransientState) {

        return mChildCountWithTransientState > 0 || super.hasTransientState();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchUnhandledMove(View focused, int direction) {

        return mFocused != null &&

                mFocused.dispatchUnhandledMove(focused, direction);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void clearChildFocus(View child) {

        if (DBG) {

            System.out.println(this + " clearChildFocus()");

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void clearFocus() {

        if (DBG) {

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    void unFocus(View focused) {

        if (DBG) {

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean hasFocusable() {

        if ((mViewFlags & VISIBILITY_MASK) != VISIBLE) {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void addFocusables(ArrayList<View> views, int direction, int focusableMode) {

        final int focusableCount = views.size();

        return null;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchWindowFocusChanged(boolean hasFocus) {

        super.dispatchWindowFocusChanged(hasFocus);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void addTouchables(ArrayList<View> views) {

        super.addTouchables(views);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchDisplayHint(int hint) {

        super.dispatchDisplayHint(hint);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void dispatchVisibilityChanged(View changedView, int visibility) {

        super.dispatchVisibilityChanged(changedView, visibility);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchWindowVisibilityChanged(int visibility) {

        super.dispatchWindowVisibilityChanged(visibility);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchConfigurationChanged(Configuration newConfig) {

        super.dispatchConfigurationChanged(newConfig);

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void recomputeViewAttributes(View child) {

        if (mAttachInfo != null && !mAttachInfo.mRecomputeGlobalAttributes) {

            ViewParent parent = mParent;

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void bringChildToFront(View child) {

        final int index = indexOfChild(child);

        if (index >= 0) {

        return mLocalPoint;

    }

    /**

     * {@inheritDoc}

     */

    // TODO: Write real docs

    @Override

    public boolean dispatchDragEvent(DragEvent event) {

        return changed;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchKeyEventPreIme(KeyEvent event) {

        if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS))

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchKeyEvent(KeyEvent event) {

        if (mInputEventConsistencyVerifier != null) {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchKeyShortcutEvent(KeyEvent event) {

        if ((mPrivateFlags & (PFLAG_FOCUSED | PFLAG_HAS_BOUNDS))

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchTrackballEvent(MotionEvent event) {

        if (mInputEventConsistencyVerifier != null) {

        return super.getPointerIcon(event, x, y);

    }

    /**

     * {@inheritDoc}

     */

    @SuppressWarnings({"ConstantConditions"})

    @Override

    protected boolean dispatchHoverEvent(MotionEvent event) {

        return MotionEvent.obtainNoHistory(event);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected boolean dispatchGenericPointerEvent(MotionEvent event) {

        // Send the event to the child under the pointer.

        return super.dispatchGenericPointerEvent(event);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected boolean dispatchGenericFocusedEvent(MotionEvent event) {

        // Send the event to the focused child or to this view group if it has focus.

        return handled;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean dispatchTouchEvent(MotionEvent ev) {

        if (mInputEventConsistencyVerifier != null) {

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void requestDisallowInterceptTouchEvent(boolean disallowIntercept) {

        if (disallowIntercept == ((mGroupFlags & FLAG_DISALLOW_INTERCEPT) != 0)) {

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    void dispatchAttachedToWindow(AttachInfo info, int visibility) {

        mGroupFlags |= FLAG_PREVENT_DISPATCH_ATTACHED_TO_WINDOW;

     * adds in all child views of the view group, in addition to calling the default View

     * implementation.

     */

    @Override

    public void dispatchProvideStructure(ViewStructure structure) {

        super.dispatchProvideStructure(structure);

        if (!isAssistBlocked()) {

        return false;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    void dispatchDetachedFromWindow() {

        // If we still have a touch target, we are still in the process of

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void dispatchSaveInstanceState(SparseArray<Parcelable> container) {

        super.dispatchSaveInstanceState(container);

        super.dispatchSaveInstanceState(container);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void dispatchRestoreInstanceState(SparseArray<Parcelable> container) {

        super.dispatchRestoreInstanceState(container);

        return mLayoutMode == LAYOUT_MODE_OPTICAL_BOUNDS;

    }

    @Override

    Insets computeOpticalInsets() {

        if (isLayoutModeOptical()) {

            int left = 0;

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void dispatchDraw(Canvas canvas) {

        boolean usingRenderNodeProperties = canvas.isRecordingFor(mRenderNode);

            // drawChild() after the animation is over

            mGroupFlags |= FLAG_NOTIFY_ANIMATION_LISTENER;

            final Runnable end = new Runnable() {

               @Override

               public void run() {

                   notifyAnimationListener();

               }

        if (mAnimationListener != null) {

           final Runnable end = new Runnable() {

               @Override

               public void run() {

                   mAnimationListener.onAnimationEnd(mLayoutAnimationController.getAnimation());

               }

        return hasBooleanFlag(FLAG_CLIP_TO_PADDING);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchSetSelected(boolean selected) {

        final View[] children = mChildren;

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void dispatchSetActivated(boolean activated) {

        final View[] children = mChildren;

     * @param child the child view to add

     * @param params the layout parameters to set on the child

     */

    @Override

    public void addView(View child, LayoutParams params) {

        addView(child, -1, params);

    }

        addViewInner(child, index, params, false);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void updateViewLayout(View view, ViewGroup.LayoutParams params) {

        if (!checkLayoutParams(params)) {

            throw new IllegalArgumentException("Invalid LayoutParams supplied to " + this);

        view.setLayoutParams(params);

    }

    /**

     * {@inheritDoc}

     */

    protected boolean checkLayoutParams(ViewGroup.LayoutParams p) {

        return  p != null;

    }

     * {@link #draw(android.graphics.Canvas)}, {@link #onDraw(android.graphics.Canvas)},

     * {@link #dispatchDraw(android.graphics.Canvas)} or any related method.</p>

     */

    @Override

    public void removeView(View view) {

        if (removeViewInternal(view)) {

            requestLayout();

     * Don't call or override this method. It is used for the implementation of

     * the view hierarchy.

     */

    @Override

    public final void invalidateChild(View child, final Rect dirty) {

        ViewParent parent = this;

     * if this ViewGroup is already fully invalidated or if the dirty rectangle

     * does not intersect with this ViewGroup's bounds.

     */

    @Override

    public ViewParent invalidateChildInParent(final int[] location, final Rect dirty) {

        if ((mPrivateFlags & PFLAG_DRAWN) == PFLAG_DRAWN ||

                (mPrivateFlags & PFLAG_DRAWING_CACHE_VALID) == PFLAG_DRAWING_CACHE_VALID) {

        notifySubtreeAccessibilityStateChangedIfNeeded();

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean getChildVisibleRect(View child, Rect r, android.graphics.Point offset) {

        // It doesn't make a whole lot of sense to call this on a view that isn't attached,

        // but for some simple tests it can be useful. If we don't have attach info this

        return rectIsVisible;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public final void layout(int l, int t, int r, int b) {

        if (!mSuppressLayout && (mTransition == null || !mTransition.isChangingLayout())) {

        }

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected abstract void onLayout(boolean changed,

            int l, int t, int r, int b);

        return new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT);

    }

    /**

     * {@inheritDoc}

     */

    @Override

    protected void debug(int depth) {

        super.debug(depth);

        return mSuppressLayout;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public boolean gatherTransparentRegion(Region region) {

        // If no transparent regions requested, we are always opaque.

        return meOpaque || noneOfTheChildrenAreTransparent;

    }

    /**

     * {@inheritDoc}

     */

    @Override

    public void requestTransparentRegion(View child) {

        if (child != null) {

            child.mPrivateFlags |= View.PFLAG_REQUEST_TRANSPARENT_REGIONS;

     * If {@link #addStatesFromChildren} is true, refreshes this group's

     * drawable state (to include the states from its children).

     */

    @Override

    public void childDrawableStateChanged(View child) {

        if ((mGroupFlags & FLAG_ADD_STATES_FROM_CHILDREN) != 0) {

            refreshDrawableState();

            a.recycle();

        }

        /**

         * {@inheritDoc}

         */

        public MarginLayoutParams(int width, int height) {

            super(width, height);

            this.mMarginFlags = source.mMarginFlags;

        }

        /**

         * {@inheritDoc}

         */

        public MarginLayoutParams(LayoutParams source) {

            super(source);