xref: /aosp12/packages/apps/Car/libs/car-ui-lib/car-rotary-lib/src/main/java/com/android/car/ui/utils/ViewUtils.java

/*
 * Copyright (C) 2020 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 com.android.car.ui.utils;

import static android.view.accessibility.AccessibilityNodeInfo.ACTION_FOCUS;

import static com.android.car.ui.utils.RotaryConstants.ROTARY_CONTAINER;
import static com.android.car.ui.utils.RotaryConstants.ROTARY_FOCUS_DELEGATING_CONTAINER;
import static com.android.car.ui.utils.RotaryConstants.ROTARY_HORIZONTALLY_SCROLLABLE;
import static com.android.car.ui.utils.RotaryConstants.ROTARY_VERTICALLY_SCROLLABLE;

import android.app.Activity;
import android.content.Context;
import android.content.ContextWrapper;
import android.text.TextUtils;
import android.util.Log;
import android.view.View;
import android.view.ViewGroup;
import android.view.ViewParent;
import android.view.ViewTreeObserver;

import androidx.annotation.IntDef;
import androidx.annotation.NonNull;
import androidx.annotation.Nullable;
import androidx.annotation.VisibleForTesting;

import com.android.car.ui.FocusParkingView;
import com.android.car.ui.IFocusArea;

import java.lang.annotation.Retention;
import java.lang.annotation.RetentionPolicy;
import java.util.function.Predicate;

/** Utility class for helpful methods related to {@link View} objects. */
@SuppressWarnings("AndroidJdkLibsChecker")
public final class ViewUtils {

    private static final String TAG = "ViewUtils";

    /**
     * How many milliseconds to wait before trying to restore the focus inside the LazyLayoutView
     * the second time.
     */
    @VisibleForTesting
    static final int RESTORE_FOCUS_RETRY_DELAY_MS = 3000;

    /**
     * No view is focused, the focused view is not shown, or the focused view is a FocusParkingView.
     */
    @VisibleForTesting
    static final int NO_FOCUS = 1;

    /** A scrollable container is focused. */
    @VisibleForTesting
    static final int SCROLLABLE_CONTAINER_FOCUS = 2;

    /**
     * A regular view is focused. A regular View is a View that is neither a FocusParkingView nor a
     * scrollable container.
     */
    @VisibleForTesting
    static final int REGULAR_FOCUS = 3;

    /** The selected view is focused. */
    @VisibleForTesting
    static final int SELECTED_FOCUS = 4;

    /**
     * An implicit default focus view (i.e., the selected item or the first focusable item in a
     * scrollable container) is focused.
     */
    @VisibleForTesting
    static final int IMPLICIT_DEFAULT_FOCUS = 5;

    /** The {@code app:defaultFocus} view is focused. */
    @VisibleForTesting
    static final int DEFAULT_FOCUS = 6;

    /** The {@code android:focusedByDefault} view is focused. */
    @VisibleForTesting
    static final int FOCUSED_BY_DEFAULT = 7;

    /**
     * Focus level of a view. When adjusting the focus, the view with the highest focus level will
     * be focused.
     */
    @IntDef(flag = true, value = {NO_FOCUS, SCROLLABLE_CONTAINER_FOCUS, REGULAR_FOCUS,
            SELECTED_FOCUS, IMPLICIT_DEFAULT_FOCUS, DEFAULT_FOCUS, FOCUSED_BY_DEFAULT})
    @Retention(RetentionPolicy.SOURCE)
    private @interface FocusLevel {
    }

    /** This is a utility class. */
    private ViewUtils() {
    }

    /**
     * An interface used to restore focus inside a view when its layout is completed.
     * <p>
     * The view that needs to restore focus lazily should implement this interface.
     */
    public interface LazyLayoutView {

        /**
         * Returns whether the view's layout is completed and ready to restore focus inside it.
         */
        boolean isLayoutCompleted();

        /**
         * Adds a listener to be called when the view's layout is completed.
         */
        void addOnLayoutCompleteListener(@Nullable Runnable runnable);

        /**
         * Removes a listener to be called when the view's layout is completed.
         */
        void removeOnLayoutCompleteListener(@Nullable Runnable runnable);
    }

    /** Returns whether the {@code view} is in multi-window mode. */
    public static boolean isInMultiWindowMode(@NonNull View view) {
        Context context = view.getContext();
        // Find the Activity context in case the view was inflated with Hilt dependency injector.
        Activity activity = findActivity(context);
        return activity != null && activity.isInMultiWindowMode();
    }

    /** Returns the Activity of the given {@code context}. */
    @Nullable
    public static Activity findActivity(@Nullable Context context) {
        while (context instanceof ContextWrapper
                && !(context instanceof Activity)) {
            context = ((ContextWrapper) context).getBaseContext();
        }
        if (context instanceof Activity) {
            return (Activity) context;
        }
        return null;
    }

    /** Returns whether the {@code descendant} view is a descendant of the {@code view}. */
    public static boolean isDescendant(@Nullable View descendant, @Nullable View view) {
        if (descendant == null || view == null) {
            return false;
        }
        ViewParent parent = descendant.getParent();
        while (parent != null) {
            if (parent == view) {
                return true;
            }
            parent = parent.getParent();
        }
        return false;
    }

    /**
     * Hides the focus by searching the view tree for the {@link FocusParkingView}
     * and focusing on it.
     *
     * @param root the root view to search from
     * @return true if the FocusParkingView was successfully found and focused
     *         or if it was already focused
     */
    public static boolean hideFocus(@NonNull View root) {
        FocusParkingView fpv = findFocusParkingView(root);
        if (fpv == null) {
            return false;
        }
        if (fpv.isFocused()) {
            return true;
        }
        return fpv.performAccessibilityAction(ACTION_FOCUS, /* arguments= */ null);
    }

    /**
     * Returns the first {@link FocusParkingView} of the view tree, if any. Returns null if not
     * found.
     */
    @VisibleForTesting
    public static FocusParkingView findFocusParkingView(@NonNull View root) {
        return (FocusParkingView) depthFirstSearch(root,
                /* targetPredicate= */ v -> v instanceof FocusParkingView,
                /* skipPredicate= */ null);
    }

    /** Gets the ancestor IFocusArea of the {@code view}, if any. Returns null if not found. */
    @Nullable
    public static IFocusArea getAncestorFocusArea(@NonNull View view) {
        ViewParent parent = view.getParent();
        while (parent != null) {
            if (parent instanceof IFocusArea) {
                return (IFocusArea) parent;
            }
            parent = parent.getParent();
        }
        return null;
    }

    /**
     * Gets the ancestor scrollable container of the {@code view}, if any. Returns null if not
     * found.
     */
    @Nullable
    public static ViewGroup getAncestorScrollableContainer(@Nullable View view) {
        if (view == null) {
            return null;
        }
        ViewParent parent = view.getParent();
        // A scrollable container can't contain an IFocusArea, so let's return earlier if we found
        // an IFocusArea.
        while (parent != null && parent instanceof ViewGroup && !(parent instanceof IFocusArea)) {
            ViewGroup viewGroup = (ViewGroup) parent;
            if (isScrollableContainer(viewGroup)) {
                return viewGroup;
            }
            parent = parent.getParent();
        }
        return null;
    }

    /**
     * Focuses on the {@code view} if it can be focused.
     *
     * @return whether it was successfully focused or already focused
     */
    public static boolean requestFocus(@Nullable View view) {
        if (view == null || !canTakeFocus(view)) {
            return false;
        }
        if (view.isFocused()) {
            return true;
        }
        // Exit touch mode and focus the view. The view may not be focusable in touch mode, so we
        // need to exit touch mode before focusing it.
        return view.performAccessibilityAction(ACTION_FOCUS, /* arguments= */ null);
    }

    /**
     * Searches the {@code root}'s descendants for a view with the highest {@link FocusLevel}. If
     * the view's FocusLevel is higher than the {@code currentFocus}'s FocusLevel, focuses on the
     * view. If it tried to focus on a LazyLayoutView but failed, requests to adjust the focus
     * inside the LazyLayoutView later.
     *
     * @return whether the view is focused
     */
    public static boolean adjustFocus(@NonNull View root, @Nullable View currentFocus) {
        @FocusLevel int currentLevel = getFocusLevel(currentFocus);
        return adjustFocus(root, currentLevel, /* cachedFocusedView= */ null,
                /* defaultFocusOverridesHistory= */ false);
    }

    /**
     * Similar to {@link #adjustFocus(View, View)} but without requesting to adjust the focus
     * inside the LazyLayoutView later.
     */
    public static boolean adjustFocusImmediately(@NonNull View root, @Nullable View currentFocus) {
        @FocusLevel int currentLevel = getFocusLevel(currentFocus);
        return adjustFocus(root, currentLevel, /* cachedFocusedView= */ null,
                /* defaultFocusOverridesHistory= */ false, /* delayed= */ false);
    }

    /**
     * If the {@code currentFocus}'s FocusLevel is lower than REGULAR_FOCUS, adjusts focus within
     * {@code root}. See {@link #adjustFocus(View, int)}. Otherwise no-op.
     *
     * @return whether the focus has changed
     */
    public static boolean initFocus(@NonNull View root, @Nullable View currentFocus) {
        @FocusLevel int currentLevel = getFocusLevel(currentFocus);
        if (currentLevel >= REGULAR_FOCUS) {
            return false;
        }
        return adjustFocus(root, currentLevel, /* cachedFocusedView= */ null,
                /* defaultFocusOverridesHistory= */ false);
    }

    /**
     * Searches the {@code root}'s descendants for a view with the highest {@link FocusLevel}. If
     * the view's FocusLevel is higher than {@code currentLevel}, focuses on the view.
     *
     * @return whether the view is focused
     */
    @VisibleForTesting
    static boolean adjustFocus(@NonNull View root, @FocusLevel int currentLevel) {
        return adjustFocus(root, currentLevel, /* cachedFocusedView= */ null,
                /* defaultFocusOverridesHistory= */ false);
    }

    /**
     * Searches the {@code root}'s descendants for a view with the highest {@link FocusLevel} and
     * focuses on it or the {@code cachedFocusedView}.
     *
     * @return whether the view is focused
     */
    public static boolean adjustFocus(@NonNull View root,
            @Nullable View cachedFocusedView,
            boolean defaultFocusOverridesHistory) {
        return adjustFocus(root, NO_FOCUS, cachedFocusedView, defaultFocusOverridesHistory);
    }

    private static boolean adjustFocus(@NonNull View root,
            @FocusLevel int currentLevel,
            @Nullable View cachedFocusedView,
            boolean defaultFocusOverridesHistory) {
        return adjustFocus(root, currentLevel, cachedFocusedView, defaultFocusOverridesHistory,
                /* delayed= */ true);
    }

    /**
     * Searches the {@code root}'s descendants for a view with the highest {@link FocusLevel}. If
     * the view's FocusLevel is higher than {@code currentLevel}, focuses on the view or {@code
     * cachedFocusedView}.
     *
     * @return whether the view is focused
     */
    private static boolean adjustFocus(@NonNull View root,
            @FocusLevel int currentLevel,
            @Nullable View cachedFocusedView,
            boolean defaultFocusOverridesHistory,
            boolean delayed) {
        // If the previously focused view has higher priority than the default focus, try to focus
        // on the previously focused view.
        if (!defaultFocusOverridesHistory && requestFocus(cachedFocusedView)) {
            return true;
        }

        // Try to focus on the default focus view.
        if (currentLevel < FOCUSED_BY_DEFAULT && focusOnFocusedByDefaultView(root)) {
            return true;
        }
        if (currentLevel < DEFAULT_FOCUS && focusOnDefaultFocusView(root)) {
            return true;
        }
        if (currentLevel < IMPLICIT_DEFAULT_FOCUS && focusOnImplicitDefaultFocusView(root)) {
            return true;
        }
        if (currentLevel < SELECTED_FOCUS && focusOnSelectedView(root)) {
            return true;
        }

        // When delayed is true, if there is a LazyLayoutView but it failed to adjust focus
        // inside it because it hasn't loaded yet or it's loaded but has no descendants, request to
        // restore focus inside it later, and return false for now.
        if (delayed && currentLevel < IMPLICIT_DEFAULT_FOCUS) {
            LazyLayoutView lazyLayoutView = findLazyLayoutView(root);
            if (lazyLayoutView != null && !lazyLayoutView.isLayoutCompleted()) {
                initFocusDelayed(lazyLayoutView);
                return false;
            }
        }

        // If the previously focused view has lower priority than the default focus, try to focus
        // on the previously focused view.
        if (defaultFocusOverridesHistory && requestFocus(cachedFocusedView)) {
            return true;
        }

        // Try to focus on other views with low focus levels.
        if (currentLevel < REGULAR_FOCUS && focusOnFirstRegularView(root)) {
            return true;
        }
        if (currentLevel < SCROLLABLE_CONTAINER_FOCUS) {
            return focusOnScrollableContainer(root);
        }
        return false;
    }

    /**
     * If the {code lazyLayoutView} has a focusable descendant and no visible view is focused,
     * focuses on the descendant. Otherwise tries again when the {code lazyLayoutView} completes
     * layout, shows up on the screen, or after a timeout, whichever comes first.
     */
    public static void initFocus(@NonNull LazyLayoutView lazyLayoutView) {
        if (initFocusImmediately(lazyLayoutView)) {
            return;
        }
        initFocusDelayed(lazyLayoutView);
    }

    private static void initFocusDelayed(@NonNull LazyLayoutView lazyLayoutView) {
        if (!(lazyLayoutView instanceof View)) {
            return;
        }
        View lazyView = (View) lazyLayoutView;
        Runnable[] onLayoutCompleteListener = new Runnable[1];
        Runnable[] delayedTask = new Runnable[1];
        ViewTreeObserver.OnGlobalLayoutListener[] onGlobalLayoutListener =
                new ViewTreeObserver.OnGlobalLayoutListener[1];

        // If the lazyLayoutView has not completed layout yet, try to restore focus inside it once
        // it's completed.
        if (!lazyLayoutView.isLayoutCompleted()) {
            Log.v(TAG, "The lazyLayoutView has not completed layout: " + lazyLayoutView);
            onLayoutCompleteListener[0] = () -> {
                Log.v(TAG, "The lazyLayoutView completed layout: "
                        + lazyLayoutView);
                if (initFocusImmediately(lazyLayoutView)) {
                    Log.v(TAG, "Focus restored after lazyLayoutView completed layout");
                    // Remove the other tasks only when onLayoutCompleteListener has initialized the
                    // focus successfully, because the other tasks need to kick in when it fails,
                    // such as when it has completed layout but has no descendants to take focus,
                    // or it's not shown (e.g., its ancestor is invisible). In the former case,
                    // the delayedTask needs to run after a timeout, while in the latter case the
                    // onGlobalLayoutListener needs to run when it shows up on the screen.
                    removeCallbacks(lazyLayoutView, onGlobalLayoutListener,
                            onLayoutCompleteListener, delayedTask);
                }
            };
            lazyLayoutView.addOnLayoutCompleteListener(onLayoutCompleteListener[0]);
        }

        // If the lazyLayoutView is not shown yet, try to restore focus inside it once it's shown.
        if (!lazyView.isShown()) {
            Log.d(TAG, "The lazyLayoutView is not shown: " + lazyLayoutView);
            onGlobalLayoutListener[0] = () -> {
                Log.d(TAG, "onGlobalLayoutListener is called");
                if (lazyView.isShown()) {
                    Log.d(TAG, "The lazyLayoutView is shown");
                    if (initFocusImmediately(lazyLayoutView)) {
                        Log.v(TAG, "Focus restored after showing lazyLayoutView");
                        removeCallbacks(lazyLayoutView, onGlobalLayoutListener,
                                onLayoutCompleteListener, delayedTask);
                    }
                }
            };
            lazyView.getViewTreeObserver()
                    .addOnGlobalLayoutListener(onGlobalLayoutListener[0]);
        }

        // Run a delayed task as fallback.
        delayedTask[0] = () -> {
            Log.d(TAG, "Starting delayedTask");
            removeCallbacks(lazyLayoutView, onGlobalLayoutListener,
                    onLayoutCompleteListener, delayedTask);
            if (!hasVisibleFocusInRoot(lazyView)) {
                // Make one last attempt to restore focus inside the lazyLayoutView. For example,
                // in ViewUtilsTest.testInitFocus_inLazyLayoutView5(), when lazyLayoutView's parent
                // becomes visible, onGlobalLayoutListener won't be triggered, so it won't try to
                // restore focus there.
                if (lazyLayoutView.isLayoutCompleted() && lazyView.isShown()) {
                    Log.d(TAG, "Last attempt to restore focus inside the lazyLayoutView");
                    if (initFocusImmediately(lazyLayoutView)) {
                        Log.d(TAG, "Restored focus inside the lazyLayoutView");
                        return;
                    }
                }
                // Search the view tree and find the view to focus when it failed to restore focus
                // inside the lazyLayoutView.
                adjustFocus(lazyView.getRootView(), NO_FOCUS, /* cachedFocusedView= */ null,
                        /* defaultFocusOverridesHistory= */ false, /* delayed= */ false);
            }
        };
        lazyView.postDelayed(delayedTask[0], RESTORE_FOCUS_RETRY_DELAY_MS);
    }

    private static void removeCallbacks(@NonNull LazyLayoutView lazyLayoutView,
            ViewTreeObserver.OnGlobalLayoutListener[] onGlobalLayoutListener,
            Runnable[] onLayoutCompleteListener,
            Runnable[] delayedTask) {
        lazyLayoutView.removeOnLayoutCompleteListener(onLayoutCompleteListener[0]);
        if (!(lazyLayoutView instanceof View)) {
            return;
        }
        View lazyView = (View) lazyLayoutView;
        lazyView.removeCallbacks(delayedTask[0]);
        lazyView.getViewTreeObserver()
                .removeOnGlobalLayoutListener(onGlobalLayoutListener[0]);
    }

    private static boolean initFocusImmediately(@NonNull LazyLayoutView lazyLayoutView) {
        if (!(lazyLayoutView instanceof View)) {
            return false;
        }
        View lazyView = (View) lazyLayoutView;
        // If there is a visible view focused in the view tree, just return true.
        if (hasVisibleFocusInRoot(lazyView)) {
            return true;
        }
        return ViewUtils.adjustFocusImmediately(lazyView, /* currentFocus= */ null);
    }

    private static boolean hasVisibleFocusInRoot(@NonNull View view) {
        View focus = view.getRootView().findFocus();
        return focus != null && !(focus instanceof FocusParkingView);
    }

    @VisibleForTesting
    @FocusLevel
    static int getFocusLevel(@Nullable View view) {
        if (view == null || view instanceof FocusParkingView || !view.isShown()) {
            return NO_FOCUS;
        }
        if (view.isFocusedByDefault()) {
            return FOCUSED_BY_DEFAULT;
        }
        if (isDefaultFocus(view)) {
            return DEFAULT_FOCUS;
        }
        if (isImplicitDefaultFocusView(view)) {
            return IMPLICIT_DEFAULT_FOCUS;
        }
        if (view.isSelected()) {
            return SELECTED_FOCUS;
        }
        if (isScrollableContainer(view)) {
            return SCROLLABLE_CONTAINER_FOCUS;
        }
        return REGULAR_FOCUS;
    }

    /** Returns whether the {@code view} is a {@code app:defaultFocus} view. */
    private static boolean isDefaultFocus(@NonNull View view) {
        IFocusArea parent = getAncestorFocusArea(view);
        return parent != null && view == parent.getDefaultFocusView();
    }

    /**
     * Returns whether the {@code view} is an implicit default focus view, i.e., the selected
     * item or the first focusable item in a rotary container.
     */
    @VisibleForTesting
    static boolean isImplicitDefaultFocusView(@NonNull View view) {
        ViewGroup rotaryContainer = null;
        ViewParent parent = view.getParent();
        while (parent != null && parent instanceof ViewGroup) {
            ViewGroup viewGroup = (ViewGroup) parent;
            if (isRotaryContainer(viewGroup)) {
                rotaryContainer = viewGroup;
                break;
            }
            parent = parent.getParent();
        }
        if (rotaryContainer == null) {
            return false;
        }
        return findFirstSelectedFocusableDescendant(rotaryContainer) == view
                || findFirstFocusableDescendant(rotaryContainer) == view;
    }

    private static boolean isRotaryContainer(@NonNull View view) {
        CharSequence contentDescription = view.getContentDescription();
        return TextUtils.equals(contentDescription, ROTARY_CONTAINER)
                || TextUtils.equals(contentDescription, ROTARY_VERTICALLY_SCROLLABLE)
                || TextUtils.equals(contentDescription, ROTARY_HORIZONTALLY_SCROLLABLE);
    }

    private static boolean isScrollableContainer(@NonNull View view) {
        CharSequence contentDescription = view.getContentDescription();
        return TextUtils.equals(contentDescription, ROTARY_VERTICALLY_SCROLLABLE)
                || TextUtils.equals(contentDescription, ROTARY_HORIZONTALLY_SCROLLABLE);
    }

    private static boolean isFocusDelegatingContainer(@NonNull View view) {
        CharSequence contentDescription = view.getContentDescription();
        return TextUtils.equals(contentDescription, ROTARY_FOCUS_DELEGATING_CONTAINER);
    }

    /**
     * Searches the {@code root}'s descendants for the first {@code app:defaultFocus} view and
     * focuses on it, if any.
     *
     * @param root the root view to search from
     * @return whether succeeded
     */
    private static boolean focusOnDefaultFocusView(@NonNull View root) {
        View defaultFocus = findDefaultFocusView(root);
        return requestFocus(defaultFocus);
    }

    /**
     * Searches the {@code root}'s descendants for the first {@code android:focusedByDefault} view
     * and focuses on it if any.
     *
     * @param root the root view to search from
     * @return whether succeeded
     */
    private static boolean focusOnFocusedByDefaultView(@NonNull View root) {
        View focusedByDefault = findFocusedByDefaultView(root);
        return requestFocus(focusedByDefault);
    }

    /**
     * Searches the {@code root}'s descendants for the first implicit default focus view and focuses
     * on it, if any.
     *
     * @param root the root view to search from
     * @return whether succeeded
     */
    private static boolean focusOnImplicitDefaultFocusView(@NonNull View root) {
        View implicitDefaultFocus = findImplicitDefaultFocusView(root);
        return requestFocus(implicitDefaultFocus);
    }

    /**
     * Searches the {@code root}'s descendants for the first selected view and focuses on it, if
     * any.
     *
     * @param root the root view to search from
     * @return whether succeeded
     */
    private static boolean focusOnSelectedView(@NonNull View root) {
        View selectedView = findFirstSelectedFocusableDescendant(root);
        return requestFocus(selectedView);
    }

    /**
     * Searches the {@code root}'s descendants for the focusable view in depth first order
     * (excluding the FocusParkingView and scrollable containers), and tries to focus on it.
     * If focusing on the first such view fails, keeps trying other views in depth first order
     * until succeeds or there are no more such views.
     *
     * @param root the root view to search from
     * @return whether succeeded
     */
    public static boolean focusOnFirstRegularView(@NonNull View root) {
        View focusedView = ViewUtils.depthFirstSearch(root,
                /* targetPredicate= */
                v -> v != root && !isScrollableContainer(v) && canTakeFocus(v) && requestFocus(v),
                /* skipPredicate= */ v -> !v.isShown());
        return focusedView != null;
    }

    /**
     * Focuses on the first scrollable container in the view tree, if any.
     *<p>
     * Unlike other similar methods, don't skip the {@code root} because some callers may pass
     * a scrollable container as parameter.
     *
     * @param root the root of the view tree
     * @return whether succeeded
     */
    private static boolean focusOnScrollableContainer(@NonNull View root) {
        View focusedView = ViewUtils.depthFirstSearch(root,
                /* targetPredicate= */ v -> isScrollableContainer(v) && canTakeFocus(v),
                /* skipPredicate= */ v -> !v.isShown());
        return requestFocus(focusedView);
    }

    /**
     * Searches the {@code root}'s descendants in depth first order, and returns the first
     * {@code app:defaultFocus} view that can take focus. Returns null if not found.
     */
    @Nullable
    private static View findDefaultFocusView(@NonNull View view) {
        if (!view.isShown()) {
            return null;
        }
        if (view instanceof IFocusArea) {
            IFocusArea focusArea = (IFocusArea) view;
            View defaultFocus = focusArea.getDefaultFocusView();
            if (defaultFocus != null && canTakeFocus(defaultFocus)) {
                return defaultFocus;
            }
        } else if (view instanceof ViewGroup) {
            ViewGroup parent = (ViewGroup) view;
            for (int i = 0; i < parent.getChildCount(); i++) {
                View child = parent.getChildAt(i);
                View defaultFocus = findDefaultFocusView(child);
                if (defaultFocus != null) {
                    return defaultFocus;
                }
            }
        }
        return null;
    }

    /**
     * Searches the {@code view}'s descendants in depth first order, and returns the first
     * {@code android:focusedByDefault} view that can take focus. Returns null if not found.
     */
    @VisibleForTesting
    @Nullable
    static View findFocusedByDefaultView(@NonNull View view) {
        return depthFirstSearch(view,
                /* targetPredicate= */ v -> v != view && v.isFocusedByDefault() && canTakeFocus(v),
                /* skipPredicate= */ v -> !v.isShown());
    }

    /**
     * Searches the {@code view}'s descendants in depth first order, and returns the first
     * implicit default focus view, i.e., the selected item or the first focusable item in the
     * first rotary container. Returns null if not found.
     */
    @VisibleForTesting
    @Nullable
    static View findImplicitDefaultFocusView(@NonNull View view) {
        View rotaryContainer = findRotaryContainer(view);
        if (rotaryContainer == null) {
            return null;
        }

        View selectedItem = findFirstSelectedFocusableDescendant(rotaryContainer);

        return selectedItem != null
                ? selectedItem
                : findFirstFocusableDescendant(rotaryContainer);
    }

    /**
     * Searches the {@code view}'s descendants in depth first order, and returns the first view
     * that can take focus, or null if not found.
     */
    @VisibleForTesting
    @Nullable
    static View findFirstFocusableDescendant(@NonNull View view) {
        return depthFirstSearch(view,
                /* targetPredicate= */ v -> v != view && canTakeFocus(v),
                /* skipPredicate= */ v -> !v.isShown());
    }

    /**
     * Searches the {@code view}'s descendants in depth first order, and returns the first view
     * that is selected and can take focus, or null if not found.
     */
    @VisibleForTesting
    @Nullable
    static View findFirstSelectedFocusableDescendant(@NonNull View view) {
        return depthFirstSearch(view,
                /* targetPredicate= */ v -> v != view && v.isSelected() && canTakeFocus(v),
                /* skipPredicate= */ v -> !v.isShown());
    }

    /**
     * Searches the {@code view} and its descendants in depth first order, and returns the first
     * rotary container shown on the screen. If the rotary containers are LazyLayoutViews, returns
     * the first layout completed one. Returns null if not found.
     * <p>
     * Unlike other similar methods, don't skip the {@code root} because some callers may pass
     * a rotary container as parameter.
     */
    @Nullable
    private static View findRotaryContainer(@NonNull View view) {
        return depthFirstSearch(view,
                /* targetPredicate= */ ViewUtils::isRotaryContainer,
                /* skipPredicate= */ v -> {
                    if (!v.isShown()) {
                        return true;
                    }
                    if (v instanceof LazyLayoutView) {
                        LazyLayoutView lazyLayoutView = (LazyLayoutView) v;
                        return !lazyLayoutView.isLayoutCompleted();
                    }
                    return false;
                });
    }

    /**
     * Searches the {@code view} and its descendants in depth first order, and returns the first
     * LazyLayoutView shown on the screen. Returns null if not found.
     * <p>
     * Unlike other similar methods, don't skip the {@code root} because some callers may pass
     * a LazyLayoutView as parameter.
     */
    @Nullable
    private static LazyLayoutView findLazyLayoutView(@NonNull View view) {
        return (LazyLayoutView) depthFirstSearch(view,
                /* targetPredicate= */ v -> v instanceof LazyLayoutView,
                /* skipPredicate= */ v -> !v.isShown());
    }

    /**
     * Searches the {@code view} and its descendants in depth first order, skips the views that
     * match {@code skipPredicate} and their descendants, and returns the first view that matches
     * {@code targetPredicate}. Returns null if not found.
     */
    @Nullable
    private static View depthFirstSearch(@NonNull View view,
            @NonNull Predicate<View> targetPredicate,
            @Nullable Predicate<View> skipPredicate) {
        if (skipPredicate != null && skipPredicate.test(view)) {
            return null;
        }
        if (targetPredicate.test(view)) {
            return view;
        }
        if (view instanceof ViewGroup) {
            ViewGroup parent = (ViewGroup) view;
            for (int i = 0; i < parent.getChildCount(); i++) {
                View child = parent.getChildAt(i);
                View target = depthFirstSearch(child, targetPredicate, skipPredicate);
                if (target != null) {
                    return target;
                }
            }
        }
        return null;
    }

    /** Returns whether {@code view} can be focused. */
    private static boolean canTakeFocus(@NonNull View view) {
        boolean focusable = view.isFocusable() || isFocusDelegatingContainer(view);
        return focusable && view.isEnabled() && view.isShown()
                && view.getWidth() > 0 && view.getHeight() > 0 && view.isAttachedToWindow()
                && !(view instanceof FocusParkingView)
                // If it's a scrollable container, it can be focused only when it has no focusable
                // descendants. We focus on it so that the rotary controller can scroll it.
                && (!isScrollableContainer(view) || findFirstFocusableDescendant(view) == null);
    }

    /**
     * Enables rotary scrolling for {@code view}, either vertically (if {@code isVertical} is true)
     * or horizontally (if {@code isVertical} is false). With rotary scrolling enabled, rotating the
     * rotary controller will scroll rather than moving the focus when moving the focus would cause
     * a lot of scrolling. Rotary scrolling should be enabled for scrolling views which contain
     * content which the user may want to see but can't interact with, either alone or along with
     * interactive (focusable) content.
     */
    public static void setRotaryScrollEnabled(@NonNull View view, boolean isVertical) {
        view.setContentDescription(
                isVertical ? ROTARY_VERTICALLY_SCROLLABLE : ROTARY_HORIZONTALLY_SCROLLABLE);
    }
}