diff --git a/car-ui-lib/car-ui-lib/src/androidTest/AndroidManifest.xml b/car-ui-lib/car-ui-lib/src/androidTest/AndroidManifest.xml
index 81df306..2482a5b 100644
--- a/car-ui-lib/car-ui-lib/src/androidTest/AndroidManifest.xml
+++ b/car-ui-lib/car-ui-lib/src/androidTest/AndroidManifest.xml
@@ -23,6 +23,7 @@
         <activity android:name="com.android.car.ui.FocusAreaTestActivity" />
         <activity android:name="com.android.car.ui.FocusParkingViewTestActivity" />
         <activity android:name="com.android.car.ui.preference.PreferenceTestActivity" />
+        <activity android:name="com.android.car.ui.utils.ViewUtilsTestActivity" />
         <activity
             android:name="com.android.car.ui.toolbar.ToolbarTestActivity"
             android:theme="@style/Theme.CarUi.WithToolbar"/>
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusAreaTest.java b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusAreaTest.java
index 9c1ce88..51f166c 100644
--- a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusAreaTest.java
+++ b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusAreaTest.java
@@ -111,8 +111,6 @@
 
     @Test
     public void testFocusOnDefaultFocus() throws Exception {
-        assertThat(mDefaultFocus.isFocused()).isFalse();
-
         Bundle bundle = new Bundle();
         CountDownLatch latch = new CountDownLatch(1);
         mFocusArea.post(() -> {
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusParkingViewTest.java b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusParkingViewTest.java
index 887ac8e..9f24d6a 100644
--- a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusParkingViewTest.java
+++ b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/FocusParkingViewTest.java
@@ -46,7 +46,7 @@
     }
 
     @Test
-    public void testFocusParkingViewCanTakeFocus() throws Exception {
+    public void testFocusParkingViewCannotTakeFocus() throws Exception {
         FocusParkingView focusParkingView = mActivity.findViewById(R.id.focus_parking);
 
         CountDownLatch latch = new CountDownLatch(1);
@@ -58,7 +58,7 @@
         });
         latch.await(WAIT_TIME_MS, TimeUnit.MILLISECONDS);
 
-        assertThat(focusParkingView.isFocused()).isTrue();
+        assertThat(focusParkingView.isFocused()).isFalse();
     }
     @Test
     public void testFocusParkingViewFocusedWhenWindowLostFocus() throws Exception {
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTest.java b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTest.java
new file mode 100644
index 0000000..76797e3
--- /dev/null
+++ b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTest.java
@@ -0,0 +1,399 @@
+/*
+ * 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.View.GONE;
+import static android.view.View.INVISIBLE;
+import static android.view.View.VISIBLE;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import android.view.LayoutInflater;
+import android.view.View;
+import android.view.ViewGroup;
+import android.widget.TextView;
+
+import androidx.annotation.NonNull;
+import androidx.annotation.Nullable;
+import androidx.recyclerview.widget.LinearLayoutManager;
+import androidx.recyclerview.widget.RecyclerView;
+import androidx.test.rule.ActivityTestRule;
+
+import com.android.car.ui.FocusArea;
+import com.android.car.ui.FocusParkingView;
+import com.android.car.ui.recyclerview.CarUiRecyclerView;
+import com.android.car.ui.test.R;
+
+import org.junit.Before;
+import org.junit.Rule;
+import org.junit.Test;
+
+import java.util.Arrays;
+import java.util.List;
+
+/** Unit tests for {@link ViewUtils}. */
+public class ViewUtilsTest {
+
+    @Rule
+    public ActivityTestRule<ViewUtilsTestActivity> mActivityRule =
+            new ActivityTestRule<>(ViewUtilsTestActivity.class);
+
+    private ViewUtilsTestActivity mActivity;
+    private FocusArea mFocusArea1;
+    private FocusArea mFocusArea2;
+    private FocusArea mFocusArea3;
+    private FocusArea mFocusArea4;
+    private FocusArea mFocusArea5;
+    private FocusParkingView mFpv;
+    private View mView2;
+    private View mFocusedByDefault3;
+    private View mView4;
+    private View mDefaultFocus4;
+    private CarUiRecyclerView mList5;
+    private View mRoot;
+
+    @Before
+    public void setUp() {
+        mActivity = mActivityRule.getActivity();
+        mFocusArea1 = mActivity.findViewById(R.id.focus_area1);
+        mFocusArea2 = mActivity.findViewById(R.id.focus_area2);
+        mFocusArea3 = mActivity.findViewById(R.id.focus_area3);
+        mFocusArea4 = mActivity.findViewById(R.id.focus_area4);
+        mFocusArea5 = mActivity.findViewById(R.id.focus_area5);
+        mFpv = mActivity.findViewById(R.id.fpv);
+        mView2 = mActivity.findViewById(R.id.view2);
+        mFocusedByDefault3 = mActivity.findViewById(R.id.focused_by_default3);
+        mView4 = mActivity.findViewById(R.id.view4);
+        mDefaultFocus4 = mActivity.findViewById(R.id.default_focus4);
+        mList5 = mActivity.findViewById(R.id.list5);
+        mRoot = mFocusArea1.getRootView();
+
+        mRoot.post(() -> {
+            setUpRecyclerView(mList5);
+        });
+    }
+
+    @Test
+    public void testRootVisible() {
+        mRoot.post(() -> assertThat(mRoot.getVisibility()).isEqualTo(VISIBLE));
+    }
+
+    @Test
+    public void testFindFocusedByDefaultView() {
+        mRoot.post(() -> {
+            View focusedByDefault = ViewUtils.findFocusedByDefaultView(mRoot);
+            assertThat(focusedByDefault).isEqualTo(mFocusedByDefault3);
+        });
+    }
+
+    @Test
+    public void testFindFocusedByDefaultView_skipNotFocusable() {
+        mRoot.post(() -> {
+            mFocusedByDefault3.setFocusable(false);
+            View focusedByDefault = ViewUtils.findFocusedByDefaultView(mRoot);
+            assertThat(focusedByDefault).isNull();
+        });
+    }
+
+    @Test
+    public void testFindFocusedByDefaultView_skipInvisibleView() {
+        mRoot.post(() -> {
+            mFocusArea3.setVisibility(INVISIBLE);
+            assertThat(mFocusArea3.getVisibility()).isEqualTo(INVISIBLE);
+            View focusedByDefault = ViewUtils.findFocusedByDefaultView(mRoot);
+            assertThat(focusedByDefault).isNull();
+        });
+    }
+
+    @Test
+    public void testFindFocusedByDefaultView_skipInvisibleAncestor() {
+        mRoot.post(() -> {
+            mRoot.setVisibility(INVISIBLE);
+            View focusedByDefault = ViewUtils.findFocusedByDefaultView(mFocusArea3);
+            assertThat(focusedByDefault).isNull();
+        });
+    }
+
+    @Test
+    public void testFindImplicitDefaultFocusView_inRoot() {
+        mRoot.post(() -> {
+            View firstItem = mList5.getLayoutManager().findViewByPosition(0);
+            View implicitDefaultFocus = ViewUtils.findImplicitDefaultFocusView(mRoot);
+            assertThat(implicitDefaultFocus).isEqualTo(firstItem);
+        });
+    }
+
+    @Test
+    public void testFindImplicitDefaultFocusView_inFocusArea() {
+        mRoot.post(() -> {
+            View firstItem = mList5.getLayoutManager().findViewByPosition(0);
+            View implicitDefaultFocus = ViewUtils.findImplicitDefaultFocusView(mFocusArea5);
+            assertThat(implicitDefaultFocus).isEqualTo(firstItem);
+        });
+    }
+
+    @Test
+    public void testFindImplicitDefaultFocusView_skipInvisibleAncestor() {
+        mRoot.post(() -> {
+            mRoot.setVisibility(INVISIBLE);
+            View implicitDefaultFocus = ViewUtils.findImplicitDefaultFocusView(mFocusArea5);
+            assertThat(implicitDefaultFocus).isNull();
+        });
+    }
+
+    @Test
+    public void testFindFirstFocusableDescendant() {
+        mRoot.post(() -> {
+            mFocusArea2.setFocusable(true);
+            View firstFocusable = ViewUtils.findFirstFocusableDescendant(mRoot);
+            assertThat(firstFocusable).isEqualTo(mFocusArea2);
+        });
+    }
+
+    @Test
+    public void testFindFirstFocusableDescendant_skipItself() {
+        mRoot.post(() -> {
+            mFocusArea2.setFocusable(true);
+            View firstFocusable = ViewUtils.findFirstFocusableDescendant(mFocusArea2);
+            assertThat(firstFocusable).isEqualTo(mView2);
+        });
+    }
+
+    @Test
+    public void testFindFirstFocusableDescendant_skipInvisibleAndGoneView() {
+        mRoot.post(() -> {
+            mFocusArea2.setVisibility(INVISIBLE);
+            mFocusArea3.setVisibility(GONE);
+            View firstFocusable = ViewUtils.findFirstFocusableDescendant(mRoot);
+            assertThat(firstFocusable).isEqualTo(mView4);
+        });
+    }
+
+    @Test
+    public void testFindFirstFocusableDescendant_skipInvisibleAncestor() {
+        mRoot.post(() -> {
+            mRoot.setVisibility(INVISIBLE);
+            View firstFocusable = ViewUtils.findFirstFocusableDescendant(mFocusArea2);
+            assertThat(firstFocusable).isNull();
+        });
+    }
+
+    @Test
+    public void testIsImplicitDefaultFocusView_firstItem() {
+        mRoot.post(() -> {
+            View firstItem = mList5.getLayoutManager().findViewByPosition(0);
+            assertThat(ViewUtils.isImplicitDefaultFocusView(firstItem)).isTrue();
+        });
+    }
+
+    @Test
+    public void testIsImplicitDefaultFocusView_secondItem() {
+        mRoot.post(() -> {
+            View secondItem = mList5.getLayoutManager().findViewByPosition(1);
+            assertThat(ViewUtils.isImplicitDefaultFocusView(secondItem)).isFalse();
+        });
+    }
+
+    @Test
+    public void testIsImplicitDefaultFocusView_normalView() {
+        mRoot.post(() -> {
+            assertThat(ViewUtils.isImplicitDefaultFocusView(mView2)).isFalse();
+        });
+    }
+
+    @Test
+    public void testIsImplicitDefaultFocusView_skipInvisibleAncestor() {
+        mRoot.post(() -> {
+            mFocusArea5.setVisibility(INVISIBLE);
+            View firstItem = mList5.getLayoutManager().findViewByPosition(0);
+            assertThat(ViewUtils.isImplicitDefaultFocusView(firstItem)).isFalse();
+        });
+    }
+
+    @Test
+    public void testRequestFocus() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_nullView() {
+        mRoot.post(() -> {
+            assertRequestFocus(null, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_alreadyFocused() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+            // mView2 is already focused before requesting focus.
+            assertRequestFocus(mView2, true);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_notFocusable() {
+        mRoot.post(() -> {
+            mView2.setFocusable(false);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_disabled() {
+        mRoot.post(() -> {
+            mView2.setEnabled(false);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_notVisible() {
+        mRoot.post(() -> {
+            mView2.setVisibility(View.INVISIBLE);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_skipInvisibleAncestor() {
+        mRoot.post(() -> {
+            mFocusArea2.setVisibility(View.INVISIBLE);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_zeroWidth() {
+        mRoot.post(() -> {
+            mView2.setRight(mView2.getLeft());
+            assertThat(mView2.getWidth()).isEqualTo(0);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_detachedFromWindow() {
+        mRoot.post(() -> {
+            mFocusArea2.removeView(mView2);
+            assertRequestFocus(mView2, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_FocusParkingView() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+            assertRequestFocus(mFpv, false);
+        });
+    }
+
+    @Test
+    public void testRequestFocus_scrollableContainer() {
+        mRoot.post(() -> {
+            assertRequestFocus(mList5, false);
+        });
+    }
+
+    @Test
+    public void testAdjustFocus_inRoot() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+            ViewUtils.adjustFocus(mRoot, null);
+            assertThat(mFocusedByDefault3.isFocused()).isTrue();
+        });
+    }
+
+    @Test
+    public void testAdjustFocus_inFocusAreaWithDefaultFocus() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+            ViewUtils.adjustFocus(mFocusArea3, null);
+            assertThat(mFocusedByDefault3.isFocused()).isTrue();
+        });
+    }
+
+    @Test
+    public void testAdjustFocus_inFocusAreaWithoutDefaultFocus() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView4, true);
+            ViewUtils.adjustFocus(mFocusArea2, null);
+            assertThat(mView2.isFocused()).isTrue();
+        });
+    }
+
+    @Test
+    public void testAdjustFocus_inFocusAreaWithoutFocusableDescendant() {
+        mRoot.post(() -> {
+            assertRequestFocus(mView2, true);
+            boolean success = ViewUtils.adjustFocus(mFocusArea1, null);
+            assertThat(mFocusArea1.hasFocus()).isFalse();
+            assertThat(success).isFalse();
+        });
+    }
+
+    private static void assertRequestFocus(@Nullable View view, boolean focused) {
+        boolean result = ViewUtils.requestFocus(view);
+        assertThat(result).isEqualTo(focused);
+        if (view != null) {
+            assertThat(view.isFocused()).isEqualTo(focused);
+        }
+    }
+
+    private void setUpRecyclerView(@NonNull CarUiRecyclerView list) {
+        list.setLayoutManager(new LinearLayoutManager(mActivity));
+        list.setAdapter(new TestAdapter());
+    }
+
+    private static class TestAdapter extends RecyclerView.Adapter<TestViewHolder> {
+
+        private static final List<String> DATA = Arrays.asList("first", "second");
+
+        @NonNull
+        @Override
+        public TestViewHolder onCreateViewHolder(ViewGroup parent, int viewType) {
+            View view = LayoutInflater.from(parent.getContext())
+                    .inflate(R.layout.test_list_item, parent, false);
+            return new TestViewHolder(view);
+        }
+
+        @Override
+        public void onBindViewHolder(@NonNull TestViewHolder holder, int position) {
+            holder.bind(DATA.get(position));
+        }
+
+        @Override
+        public int getItemCount() {
+            return DATA.size();
+        }
+    }
+
+    private static class TestViewHolder extends RecyclerView.ViewHolder {
+        private final TextView mTextView;
+
+        TestViewHolder(View view) {
+            super(view);
+            mTextView = view.findViewById(R.id.text);
+        }
+
+        void bind(String text) {
+            mTextView.setText(text);
+        }
+    }
+}
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTestActivity.java b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTestActivity.java
new file mode 100644
index 0000000..87434d4
--- /dev/null
+++ b/car-ui-lib/car-ui-lib/src/androidTest/java/com/android/car/ui/utils/ViewUtilsTestActivity.java
@@ -0,0 +1,32 @@
+/*
+ * 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 android.app.Activity;
+import android.os.Bundle;
+
+import com.android.car.ui.test.R;
+
+/** An activity used for testing {@link ViewUtils}. */
+public class ViewUtilsTestActivity extends Activity {
+
+    @Override
+    protected void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+        setContentView(R.layout.view_utils_test_activity);
+    }
+}
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/res/layout/test_list_item.xml b/car-ui-lib/car-ui-lib/src/androidTest/res/layout/test_list_item.xml
index e789145..1fab70e 100644
--- a/car-ui-lib/car-ui-lib/src/androidTest/res/layout/test_list_item.xml
+++ b/car-ui-lib/car-ui-lib/src/androidTest/res/layout/test_list_item.xml
@@ -18,7 +18,8 @@
     xmlns:android="http://schemas.android.com/apk/res/android"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:orientation="horizontal">
+    android:orientation="horizontal"
+    android:focusable="true">
 
     <TextView
         android:layout_width="wrap_content"
diff --git a/car-ui-lib/car-ui-lib/src/androidTest/res/layout/view_utils_test_activity.xml b/car-ui-lib/car-ui-lib/src/androidTest/res/layout/view_utils_test_activity.xml
new file mode 100644
index 0000000..558dd9f
--- /dev/null
+++ b/car-ui-lib/car-ui-lib/src/androidTest/res/layout/view_utils_test_activity.xml
@@ -0,0 +1,96 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!--
+  ~ 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.
+  -->
+<LinearLayout
+    xmlns:android="http://schemas.android.com/apk/res/android"
+    xmlns:app="http://schemas.android.com/apk/res-auto"
+    android:layout_width="match_parent"
+    android:layout_height="match_parent">
+    <com.android.car.ui.FocusParkingView
+        android:id="@+id/fpv"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"/>
+    <com.android.car.ui.FocusArea
+        android:id="@+id/focus_area1"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+        <View
+            android:layout_width="100dp"
+            android:layout_height="100dp"/>
+    </com.android.car.ui.FocusArea>
+    <com.android.car.ui.FocusArea
+        android:id="@+id/focus_area2"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+        <View
+            android:layout_width="100dp"
+            android:layout_height="100dp"/>
+        <View
+            android:id="@+id/view2"
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"/>
+    </com.android.car.ui.FocusArea>
+    <com.android.car.ui.FocusArea
+        android:id="@+id/focus_area3"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+        <View
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"/>
+        <View
+            android:id="@+id/focused_by_default3"
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"
+            android:focusedByDefault="true"/>
+    </com.android.car.ui.FocusArea>
+    <com.android.car.ui.FocusArea
+        android:id="@+id/focus_area4"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="vertical"
+        app:defaultFocus="@+id/default_focus4">
+        <View
+            android:id="@+id/view4"
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"/>
+        <View
+            android:id="@+id/default_focus4"
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"/>
+    </com.android.car.ui.FocusArea>
+    <com.android.car.ui.FocusArea
+        android:id="@+id/focus_area5"
+        android:layout_width="wrap_content"
+        android:layout_height="wrap_content"
+        android:orientation="vertical">
+        <View
+            android:layout_width="100dp"
+            android:layout_height="100dp"
+            android:focusable="true"/>
+        <com.android.car.ui.recyclerview.CarUiRecyclerView
+            android:id="@+id/list5"
+            android:layout_width="wrap_content"
+            android:layout_height="wrap_content"/>
+    </com.android.car.ui.FocusArea>
+</LinearLayout>
diff --git a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusArea.java b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusArea.java
index b71b3ab..4f0fa94 100644
--- a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusArea.java
+++ b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusArea.java
@@ -25,11 +25,14 @@
 import static com.android.car.ui.utils.RotaryConstants.FOCUS_AREA_RIGHT_BOUND_OFFSET;
 import static com.android.car.ui.utils.RotaryConstants.FOCUS_AREA_TOP_BOUND_OFFSET;
 import static com.android.car.ui.utils.RotaryConstants.NUDGE_DIRECTION;
+import static com.android.car.ui.utils.ViewUtils.NO_FOCUS;
+import static com.android.car.ui.utils.ViewUtils.REGULAR_FOCUS;
 
 import android.content.Context;
 import android.content.res.Resources;
 import android.content.res.TypedArray;
 import android.graphics.Canvas;
+import android.graphics.Rect;
 import android.graphics.drawable.Drawable;
 import android.os.Bundle;
 import android.os.SystemClock;
@@ -38,7 +41,6 @@
 import android.view.KeyEvent;
 import android.view.View;
 import android.view.ViewGroup;
-import android.view.ViewParent;
 import android.view.accessibility.AccessibilityNodeInfo;
 import android.widget.LinearLayout;
 
@@ -289,7 +291,7 @@
             mPreviousFocusArea = null;
             return;
         }
-        mPreviousFocusArea = getAncestorFocusArea(oldFocus);
+        mPreviousFocusArea = ViewUtils.getAncestorFocusArea(oldFocus);
         if (mPreviousFocusArea == null) {
             Log.w(TAG, "No parent FocusArea for " + oldFocus);
         }
@@ -306,7 +308,7 @@
         if (!hasFocus || oldFocus == null) {
             return;
         }
-        FocusArea oldFocusArea = getAncestorFocusArea(oldFocus);
+        FocusArea oldFocusArea = ViewUtils.getAncestorFocusArea(oldFocus);
         if (oldFocusArea != this) {
             return;
         }
@@ -457,6 +459,28 @@
     }
 
     @Override
+    public void onWindowFocusChanged(boolean hasWindowFocus) {
+        // To ensure the focus is initialized properly in rotary mode when there is a window focus
+        // change, this FocusArea will grab the focus from the currently focused view if one of this
+        // FocusArea's descendants is a better focus candidate than the currently focused view.
+        if (hasWindowFocus && !isInTouchMode()) {
+            maybeAdjustFocus();
+        }
+        super.onWindowFocusChanged(hasWindowFocus);
+    }
+
+    /**
+     * Focuses on another view in this FocusArea if the view is a better focus candidate than the
+     * currently focused view.
+     */
+    private boolean maybeAdjustFocus() {
+        View root = getRootView();
+        View focus = root.findFocus();
+        return ViewUtils.adjustFocus(root, focus);
+    }
+
+
+    @Override
     public boolean performAccessibilityAction(int action, Bundle arguments) {
         switch (action) {
             case ACTION_FOCUS:
@@ -481,12 +505,6 @@
     }
 
     private boolean focusOnDescendant() {
-        if (focusOnFocusedByDefaultView()) {
-            return true;
-        }
-        if (focusOnPrimaryFocusView()) {
-            return true;
-        }
         if (mDefaultFocusOverridesHistory) {
             // Check mDefaultFocus before last focused view.
             if (focusDefaultFocusView() || focusOnLastFocusedView()) {
@@ -501,28 +519,26 @@
         return focusOnFirstFocusableView();
     }
 
-    private boolean focusOnFocusedByDefaultView() {
-        View focusedByDefaultView = ViewUtils.findFocusedByDefaultView(this);
-        return requestFocus(focusedByDefaultView);
-    }
-
-    private boolean focusOnPrimaryFocusView() {
-        View primaryFocus = ViewUtils.findPrimaryFocusView(this);
-        return requestFocus(primaryFocus);
-    }
-
     private boolean focusDefaultFocusView() {
-        return requestFocus(mDefaultFocusView);
+        return ViewUtils.adjustFocus(this, /* currentLevel= */ REGULAR_FOCUS);
+    }
+
+    /**
+     * Gets the {@code app:defaultFocus} view.
+     *
+     * @hidden
+     */
+    public View getDefaultFocusView() {
+        return mDefaultFocusView;
     }
 
     private boolean focusOnLastFocusedView() {
         View lastFocusedView = mRotaryCache.getFocusedView(SystemClock.uptimeMillis());
-        return requestFocus(lastFocusedView);
+        return ViewUtils.requestFocus(lastFocusedView);
     }
 
     private boolean focusOnFirstFocusableView() {
-        View firstFocusableView = ViewUtils.findFocusableDescendant(this);
-        return requestFocus(firstFocusableView);
+        return ViewUtils.adjustFocus(this, /* currentLevel= */ NO_FOCUS);
     }
 
     private boolean nudgeToShortcutView(Bundle arguments) {
@@ -541,7 +557,7 @@
             // nudge to another FocusArea.
             return false;
         }
-        return requestFocus(mNudgeShortcutView);
+        return ViewUtils.requestFocus(mNudgeShortcutView);
     }
 
     private boolean nudgeToAnotherFocusArea(Bundle arguments) {
@@ -597,17 +613,6 @@
                 + "FOCUS_UP, FOCUS_DOWN, FOCUS_LEFT, or FOCUS_RIGHT.");
     }
 
-    private static FocusArea getAncestorFocusArea(@NonNull View view) {
-        ViewParent parent = view.getParent();
-        while (parent != null) {
-            if (parent instanceof FocusArea) {
-                return (FocusArea) parent;
-            }
-            parent = parent.getParent();
-        }
-        return null;
-    }
-
     @Nullable
     private FocusArea getSpecifiedFocusArea(int direction) {
         maybeInitializeSpecifiedFocusAreas();
@@ -661,6 +666,16 @@
         bundle.putInt(FOCUS_AREA_BOTTOM_BOUND_OFFSET, mBottomOffset);
     }
 
+    @Override
+    protected boolean onRequestFocusInDescendants(int direction, Rect previouslyFocusedRect) {
+        return maybeAdjustFocus();
+    }
+
+    @Override
+    public boolean restoreDefaultFocus() {
+        return maybeAdjustFocus();
+    }
+
     private void maybeInitializeSpecifiedFocusAreas() {
         if (mSpecifiedNudgeFocusAreaMap != null) {
             return;
@@ -673,15 +688,6 @@
         }
     }
 
-    private boolean requestFocus(@Nullable View view) {
-        if (view == null || !view.isAttachedToWindow()) {
-            return false;
-        }
-        // 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, null);
-    }
-
     /** Sets the padding (in pixels) of the FocusArea highlight. */
     public void setHighlightPadding(int left, int top, int right, int bottom) {
         if (mPaddingLeft == left && mPaddingTop == top && mPaddingRight == right
diff --git a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusParkingView.java b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusParkingView.java
index 8a42cea..c0893bb 100644
--- a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusParkingView.java
+++ b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/FocusParkingView.java
@@ -21,10 +21,11 @@
 import static com.android.car.ui.utils.RotaryConstants.ACTION_RESTORE_DEFAULT_FOCUS;
 
 import android.content.Context;
+import android.graphics.Rect;
 import android.os.Bundle;
 import android.util.AttributeSet;
-import android.util.Log;
 import android.view.View;
+import android.view.ViewGroup;
 import android.view.inputmethod.InputMethodManager;
 
 import androidx.annotation.Nullable;
@@ -33,10 +34,11 @@
 
 /**
  * A transparent {@link View} that can take focus. It's used by {@link
- * com.android.car.rotary.RotaryService} to support rotary controller navigation. Each {@link
- * android.view.Window} should have one FocusParkingView as the first focusable view in the view
- * tree, and outside of all {@link FocusArea}s. If multiple FocusParkingView are added in the
- * window, only the first one will be focusable.
+ * com.android.car.rotary.RotaryService} to support rotary controller navigation. It's also used to
+ * initialize the focus when in rotary mode.
+ * <p>
+ * To support the rotary controller, each {@link android.view.Window} must have a FocusParkingView
+ * as the first focusable view in the view tree, and outside of all {@link FocusArea}s.
  * <p>
  * Android doesn't clear focus automatically when focus is set in another window. If we try to clear
  * focus in the previous window, Android will re-focus a view in that window, resulting in two
@@ -45,19 +47,33 @@
  * matter whether it's focused or not. It can take focus so that RotaryService can "park" the focus
  * on it to remove the focus highlight.
  * <p>
- * If the focused view is scrolled off the screen, Android will refocus the first focusable view in
- * the window. The FocusParkingView should be the first view so that it gets focus. The
- * RotaryService detects this and moves focus to the scrolling container.
- * <p>
  * If there is only one focus area in the current window, rotating the controller within the focus
  * area will cause RotaryService to move the focus around from the view on the right to the view on
  * the left or vice versa. Adding this view to each window can fix this issue. When RotaryService
  * finds out the focus target is a FocusParkingView, it will know a wrap-around is going to happen.
  * Then it will avoid the wrap-around by not moving focus.
+ * <p>
+ * To ensure the focus is initialized properly when there is a window change, the FocusParkingView
+ * will not get focused when the framework wants to focus on it. Instead, it will try to find a
+ * better focus target in the window and focus on the target. That said, the FocusParkingView can
+ * still be focused in order to clear focus highlight in the window, such as when RotaryService
+ * performs {@link android.view.accessibility.AccessibilityNodeInfo#ACTION_FOCUS} on the
+ * FocusParkingView, or the window has lost focus.
  */
 public class FocusParkingView extends View {
     private static final String TAG = "FocusParkingView";
 
+    /**
+     * The focused view in the window containing this FocusParkingView. It's null if no view is
+     * focused, or the focused view is a FocusParkingView.
+     */
+    @Nullable
+    private View mFocusedView;
+
+    /** The scrollable container that contains the {@link #mFocusedView}, if any. */
+    @Nullable
+    ViewGroup mScrollableContainer;
+
     public FocusParkingView(Context context) {
         super(context);
         init();
@@ -94,6 +110,12 @@
 
         // Prevent Android from drawing the default focus highlight for this view when it's focused.
         setDefaultFocusHighlightEnabled(false);
+
+        // Keep track of the focused view so that we can recover focus when it's removed.
+        getViewTreeObserver().addOnGlobalFocusChangeListener((oldFocus, newFocus) -> {
+            mFocusedView = newFocus instanceof FocusParkingView ? null : newFocus;
+            mScrollableContainer = ViewUtils.getAncestorScrollableContainer(mFocusedView);
+        });
     }
 
     @Override
@@ -107,12 +129,16 @@
     @Override
     public void onWindowFocusChanged(boolean hasWindowFocus) {
         if (!hasWindowFocus) {
-            // We need to clear the focus (by parking the focus on the FocusParkingView) once the
-            // current window goes to background. This can't be done by RotaryService because
-            // RotaryService sees the window as removed, thus can't perform any action (such as
-            // focus, clear focus) on the nodes in the window. So FocusParkingView has to grab the
-            // focus proactively.
-            requestFocus();
+            // We need to clear the focus highlight(by parking the focus on the FocusParkingView)
+            // once the current window goes to background. This can't be done by RotaryService
+            // because RotaryService sees the window as removed, thus can't perform any action
+            // (such as focus, clear focus) on the nodes in the window. So FocusParkingView has to
+            // grab the focus proactively.
+            super.requestFocus(FOCUS_DOWN, null);
+        } else if (isFocused()) {
+            // When FocusParkingView is focused and the window just gets focused, transfer the view
+            // focus to a non-FocusParkingView in the window.
+            restoreFocusInRoot();
         }
         super.onWindowFocusChanged(hasWindowFocus);
     }
@@ -126,21 +152,7 @@
     public boolean performAccessibilityAction(int action, Bundle arguments) {
         switch (action) {
             case ACTION_RESTORE_DEFAULT_FOCUS:
-                View root = getRootView();
-
-                // If there is a view focused by default and it can take focus, move focus to it.
-                View defaultFocus = ViewUtils.findFocusedByDefaultView(root);
-                if (defaultFocus != null) {
-                    return defaultFocus.requestFocus();
-                }
-
-                // If there is a primary focus view, move focus to it.
-                View primaryFocus = ViewUtils.findPrimaryFocusView(root);
-                if (primaryFocus != null) {
-                    return primaryFocus.requestFocus();
-                }
-
-                return false;
+                return restoreFocusInRoot();
             case ACTION_HIDE_IME:
                 InputMethodManager inputMethodManager =
                         getContext().getSystemService(InputMethodManager.class);
@@ -149,33 +161,37 @@
             case ACTION_FOCUS:
                 // Don't leave this to View to handle as it will exit touch mode.
                 if (!hasFocus()) {
-                    return requestFocus();
+                    return super.requestFocus(FOCUS_DOWN, null);
                 }
-                break;
+                return false;
         }
         return super.performAccessibilityAction(action, arguments);
     }
 
     @Override
-    protected void onAttachedToWindow() {
-        super.onAttachedToWindow();
+    public boolean requestFocus(int direction, Rect previouslyFocusedRect) {
+        // Find a better target to focus instead of focusing this FocusParkingView when the
+        // framework wants to focus it.
+        return restoreFocusInRoot();
+    }
 
-        // If there is a FocusParkingView already, make the one after in the view tree
-        // non-focusable.
-        boolean []isBefore = new boolean[1];
-        View anotherFpv = ViewUtils.depthFirstSearch(getRootView(), v -> {
-            if (this == v) {
-                isBefore[0] = true;
-            }
-            return v != this && v instanceof FocusParkingView && v.isFocusable();
-        });
-        if (anotherFpv != null) {
-            Log.w(TAG, "There should be only one FocusParkingView in the window");
-            if (isBefore[0]) {
-                anotherFpv.setFocusable(false);
-            } else {
-                setFocusable(false);
-            }
+    @Override
+    public boolean restoreDefaultFocus() {
+        // Find a better target to focus instead of focusing this FocusParkingView when the
+        // framework wants to focus it.
+        return restoreFocusInRoot();
+    }
+
+    private boolean restoreFocusInRoot() {
+        // The focused view was in a scrollable container and it was removed, e.g., it was scrolled
+        // off the screen. Let's focus on the scrollable container so that the rotary controller
+        // can scroll it.
+        if (mFocusedView != null && !mFocusedView.isAttachedToWindow()
+                && mScrollableContainer != null && mScrollableContainer.isAttachedToWindow()
+                && mScrollableContainer.isShown() && mScrollableContainer.requestFocus()) {
+            return true;
         }
+        // Otherwise find the best target view to focus.
+        return ViewUtils.adjustFocus(getRootView(), /* currentFocus= */ null);
     }
 }
diff --git a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/RotaryConstants.java b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/RotaryConstants.java
index 99154df..1f1de0a 100644
--- a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/RotaryConstants.java
+++ b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/RotaryConstants.java
@@ -70,7 +70,7 @@
     /** Action performed on a FocusArea to move focus to another FocusArea. */
     public static final int ACTION_NUDGE_TO_ANOTHER_FOCUS_AREA = 0x02000000;
 
-    /** Action performed on a FocusParkingView to restore the default focus. */
+    /** Action performed on a FocusParkingView to restore the focus in the window. */
     public static final int ACTION_RESTORE_DEFAULT_FOCUS = 0x04000000;
 
     /** Action performed on a FocusParkingView to hide the IME. */
diff --git a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/ViewUtils.java b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/ViewUtils.java
index 6dd993b..7c95577 100644
--- a/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/ViewUtils.java
+++ b/car-ui-lib/car-ui-lib/src/main/java/com/android/car/ui/utils/ViewUtils.java
@@ -16,7 +16,7 @@
 
 package com.android.car.ui.utils;
 
-import static android.view.View.VISIBLE;
+import static android.view.accessibility.AccessibilityNodeInfo.ACTION_FOCUS;
 
 import static com.android.car.ui.utils.RotaryConstants.ROTARY_HORIZONTALLY_SCROLLABLE;
 import static com.android.car.ui.utils.RotaryConstants.ROTARY_VERTICALLY_SCROLLABLE;
@@ -24,9 +24,18 @@
 import android.text.TextUtils;
 import android.view.View;
 import android.view.ViewGroup;
+import android.view.ViewParent;
 
+import androidx.annotation.IntDef;
 import androidx.annotation.NonNull;
 import androidx.annotation.Nullable;
+import androidx.annotation.VisibleForTesting;
+
+import com.android.car.ui.FocusArea;
+import com.android.car.ui.FocusParkingView;
+
+import java.lang.annotation.Retention;
+import java.lang.annotation.RetentionPolicy;
 
 /**
  * Utility class used by {@link com.android.car.ui.FocusArea} and {@link
@@ -36,50 +45,310 @@
  */
 public final class ViewUtils {
 
-    /** This is a utility class */
+    /**
+     * No view is focused, the focused view is not shown, or the focused view is a FocusParkingView.
+     */
+    public static final int NO_FOCUS = 1;
+
+    /** A regular view is focused. */
+    public static final int REGULAR_FOCUS = 2;
+
+    /**
+     * An implicit default focus view (i.e., the first focusable item in a scrollable container) is
+     * focused.
+     */
+    public static final int IMPLICIT_DEFAULT_FOCUS = 3;
+
+    /** The {@code app:defaultFocus} view is focused. */
+    public static final int DEFAULT_FOCUS = 4;
+
+    /** The {@code android:focusedByDefault} view is focused. */
+    public static final int FOCUSED_BY_DEFAULT = 5;
+
+    /**
+     * 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, REGULAR_FOCUS, IMPLICIT_DEFAULT_FOCUS,
+            DEFAULT_FOCUS, FOCUSED_BY_DEFAULT})
+    @Retention(RetentionPolicy.SOURCE)
+    public @interface FocusLevel {
+    }
+
+    /** This is a utility class. */
     private ViewUtils() {
     }
 
     /**
-     * Searches the {@code view} and its descendants in depth first order, and returns the first
-     * view that is focused by default, can take focus, but has no invisible ancestors. Returns null
-     * if not found.
+     * This is a functional interface and can therefore be used as the assignment target for a
+     * lambda expression or method reference.
+     *
+     * @param <T> the type of the input to the predicate
+     */
+    private interface Predicate<T> {
+        /** Evaluates this predicate on the given argument. */
+        boolean test(@NonNull T t);
+    }
+
+    /** Gets the ancestor FocusArea of the {@code view}, if any. Returns null if not found. */
+    @Nullable
+    public static FocusArea getAncestorFocusArea(@NonNull View view) {
+        ViewParent parent = view.getParent();
+        while (parent != null) {
+            if (parent instanceof FocusArea) {
+                return (FocusArea) 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 View findFocusedByDefaultView(@NonNull View view) {
-        return depthFirstSearch(view,
-                /* targetPredicate= */ v -> v.isFocusedByDefault() && canTakeFocus(v),
-                /* skipPredicate= */ v -> v.getVisibility() != VISIBLE);
+    public static ViewGroup getAncestorScrollableContainer(@Nullable View view) {
+        if (view == null) {
+            return null;
+        }
+        ViewParent parent = view.getParent();
+        // A scrollable container can't contain a FocusArea, so let's return earlier if we found
+        // a FocusArea.
+        while (parent != null && parent instanceof ViewGroup && !(parent instanceof FocusArea)) {
+            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.
+     *
+     * @return whether the view is focused
+     */
+    public static boolean adjustFocus(@NonNull View root, @Nullable View currentFocus) {
+        @FocusLevel int level = getFocusLevel(currentFocus);
+        return adjustFocus(root, level);
+    }
+
+    /**
+     * 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
+     */
+    public static boolean adjustFocus(@NonNull View root, @FocusLevel int currentLevel) {
+        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 < REGULAR_FOCUS) {
+            return focusOnFirstFocus(root);
+        }
+        return false;
+    }
+
+    @FocusLevel
+    private 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;
+        }
+        return REGULAR_FOCUS;
+    }
+
+    /** Returns whether the {@code view} is a {@code app:defaultFocus} view. */
+    private static boolean isDefaultFocus(@NonNull View view) {
+        FocusArea parent = getAncestorFocusArea(view);
+        return parent != null && view == parent.getDefaultFocusView();
+    }
+
+    /**
+     * Returns whether the {@code view} is an implicit default focus view, i.e., the first focusable
+     * item in a scrollable container.
+     */
+    @VisibleForTesting
+    static boolean isImplicitDefaultFocusView(@NonNull View view) {
+        ViewGroup scrollableContainer = null;
+        ViewParent parent = view.getParent();
+        while (parent != null && parent instanceof ViewGroup) {
+            ViewGroup viewGroup = (ViewGroup) parent;
+            if (isScrollableContainer(viewGroup)) {
+                scrollableContainer = viewGroup;
+                break;
+            }
+            parent = parent.getParent();
+        }
+        if (scrollableContainer == null) {
+            return false;
+        }
+        return findFirstFocusableDescendant(scrollableContainer) == view;
+    }
+
+    private static boolean isScrollableContainer(@NonNull View view) {
+        CharSequence contentDescription = view.getContentDescription();
+        return TextUtils.equals(contentDescription, ROTARY_VERTICALLY_SCROLLABLE)
+                || TextUtils.equals(contentDescription, ROTARY_HORIZONTALLY_SCROLLABLE);
+    }
+
+    /**
+     * Focuses on the first {@code app:defaultFocus} view in the view tree, if any.
+     *
+     * @param root the root of the view tree
+     * @return whether succeeded
+     */
+    private static boolean focusOnDefaultFocusView(@NonNull View root) {
+        View defaultFocus = findDefaultFocusView(root);
+        return requestFocus(defaultFocus);
+    }
+
+    /**
+     * Focuses on the first {@code android:focusedByDefault} view in the view tree, if any.
+     *
+     * @param root the root of the view tree
+     * @return whether succeeded
+     */
+    private static boolean focusOnFocusedByDefaultView(@NonNull View root) {
+        View focusedByDefault = findFocusedByDefaultView(root);
+        return requestFocus(focusedByDefault);
+    }
+
+    /**
+     * Focuses on the first implicit default focus view in the view tree, if any.
+     *
+     * @param root the root of the view tree
+     * @return whether succeeded
+     */
+    private static boolean focusOnImplicitDefaultFocusView(@NonNull View root) {
+        View implicitDefaultFocus = findImplicitDefaultFocusView(root);
+        return requestFocus(implicitDefaultFocus);
+    }
+
+    /**
+     * Tries to focus on the first focusable view in the view tree in depth first order. If failed,
+     * keeps trying other views in depth first order until succeeded.
+     *
+     * @param root the root of the view tree
+     * @return whether succeeded
+     */
+    private static boolean focusOnFirstFocus(@NonNull View root) {
+        View focusedView = ViewUtils.depthFirstSearch(root,
+                /* targetPredicate= */ v -> canTakeFocus(v) && requestFocus(v),
+                /* skipPredicate= */ v -> !v.isShown());
+        return focusedView != null;
+    }
+
+    /**
+     * 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 FocusArea) {
+            FocusArea focusArea = (FocusArea) 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} and its descendants in depth first order, and returns the first
-     * primary focus view, i.e., the first focusable item in a scrollable container. Returns null
-     * if not found.
+     * {@code android:focusedByDefault} view that can take focus. Returns null if not found.
      */
-    public static View findPrimaryFocusView(@NonNull View view) {
+    @VisibleForTesting
+    @Nullable
+    static View findFocusedByDefaultView(@NonNull View view) {
+        return depthFirstSearch(view,
+                /* targetPredicate= */ v -> v.isFocusedByDefault() && canTakeFocus(v),
+                /* skipPredicate= */ v -> !v.isShown());
+    }
+
+    /**
+     * Searches the {@code view} and its descendants in depth first order, and returns the first
+     * implicit default focus view, i.e., the first focusable item in the first scrollable
+     * container. Returns null if not found.
+     */
+    @VisibleForTesting
+    @Nullable
+    static View findImplicitDefaultFocusView(@NonNull View view) {
         View scrollableContainer = findScrollableContainer(view);
-        return scrollableContainer == null ? null : findFocusableDescendant(scrollableContainer);
+        return scrollableContainer == null
+                ? null
+                : findFirstFocusableDescendant(scrollableContainer);
     }
 
     /**
      * Searches the {@code view}'s descendants in depth first order, and returns the first view
-     * that can take focus but has no invisible ancestors, or null if not found.
+     * that can take focus, or null if not found.
      */
+    @VisibleForTesting
     @Nullable
-    public static View findFocusableDescendant(@NonNull View view) {
+    static View findFirstFocusableDescendant(@NonNull View view) {
         return depthFirstSearch(view,
                 /* targetPredicate= */ v -> v != view && canTakeFocus(v),
-                /* skipPredicate= */ v -> v.getVisibility() != VISIBLE);
+                /* skipPredicate= */ v -> !v.isShown());
     }
 
     /**
      * Searches the {@code view} and its descendants in depth first order, and returns the first
-     * view that meets the given condition. Returns null if not found.
+     * scrollable container shown on the screen. Returns null if not found.
      */
     @Nullable
-    public static View depthFirstSearch(@NonNull View view, @NonNull Predicate<View> predicate) {
-        return depthFirstSearch(view, predicate, /* skipPredicate= */ null);
+    private static View findScrollableContainer(@NonNull View view) {
+        return depthFirstSearch(view,
+                /* targetPredicate= */ v -> isScrollableContainer(v),
+                /* skipPredicate= */ v -> !v.isShown());
     }
 
     /**
@@ -90,7 +359,7 @@
     @Nullable
     private static View depthFirstSearch(@NonNull View view,
             @NonNull Predicate<View> targetPredicate,
-            @NonNull Predicate<View> skipPredicate) {
+            @Nullable Predicate<View> skipPredicate) {
         if (skipPredicate != null && skipPredicate.test(view)) {
             return null;
         }
@@ -110,35 +379,13 @@
         return null;
     }
 
-    /**
-     * This is a functional interface and can therefore be used as the assignment target for a
-     * lambda expression or method reference.
-     *
-     * @param <T> the type of the input to the predicate
-     */
-    public interface Predicate<T> {
-        /** Evaluates this predicate on the given argument. */
-        boolean test(@NonNull T t);
-    }
-
-    /**
-     * Searches the {@code view} and its descendants in depth first order, and returns the first
-     * scrollable container that has no invisible ancestors. Returns null if not found.
-     */
-    @Nullable
-    private static View findScrollableContainer(@NonNull View view) {
-        return depthFirstSearch(view,
-                /* targetPredicate= */ v -> {
-                    CharSequence contentDescription = v.getContentDescription();
-                    return TextUtils.equals(contentDescription, ROTARY_VERTICALLY_SCROLLABLE)
-                            || TextUtils.equals(contentDescription, ROTARY_HORIZONTALLY_SCROLLABLE);
-                },
-                /* skipPredicate= */ v -> v.getVisibility() != VISIBLE);
-    }
-
     /** Returns whether {@code view} can be focused. */
     private static boolean canTakeFocus(@NonNull View view) {
-        return view.isFocusable() && view.isEnabled() && view.getVisibility() == VISIBLE
-                && view.getWidth() > 0 && view.getHeight() > 0;
+        return view.isFocusable() && 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);
     }
 }
diff --git a/car-ui-lib/car-ui-lib/src/main/res/values/attrs.xml b/car-ui-lib/car-ui-lib/src/main/res/values/attrs.xml
index e823bdf..ab238cc 100644
--- a/car-ui-lib/car-ui-lib/src/main/res/values/attrs.xml
+++ b/car-ui-lib/car-ui-lib/src/main/res/values/attrs.xml
@@ -147,9 +147,30 @@
 
     <!-- Attributes for FocusArea. -->
     <declare-styleable name="FocusArea">
-        <!-- The ID of a focusable descendant view which should be focused when the user nudges to
-             this FocusArea, if there was no view focused in the FocusArea or
-             car_ui_focus_area_default_focus_overrides_history is true. -->
+        <!-- The ID of the default focus view. The view will be prioritized when searching for a
+             focus target.
+             (1) When the user nudges the rotary controller, it will search for a target FocusArea,
+                 then search for a target view within the target FocusArea, and focus on the target
+                 view. The target view is chosen in the following order:
+                   1. the "android:focusedByDefault" view, if any
+                   2. the "app:defaultFocus" view, if any
+                   3. the first focusable item in a scrollable container, if any
+                   4. previously focused view, if any and the cache is not stale
+                   5. the first focusable view, if any
+                 Note that 4 will be prioritized over 1&2&3 when
+                 car_ui_focus_area_default_focus_overrides_history is false.
+             (2) When it needs to initialize the focus (such as when a window is opened), it will
+                 search for a view in the window and focus on it. The view is chosen in the
+                 following order:
+                   1. the first "android:focusedByDefault" view, if any
+                   2. the first "app:defaultFocus" view, if any
+                   3. the first focusable item in a scrollable container, if any
+                   4. the first focusable view that is not a FocusParkingView, if any
+             If there is only one FocusArea that needs to set default focus, you can use either
+             "app:defaultFocus" or "android:focusedByDefault". If there are more than one, you
+             should use "android:focusedByDefault" in the primary FocusArea, and use
+             "app:defaultFocus" in other FocusAreas. -->
+
         <attr name="defaultFocus" format="reference"/>
 
         <!-- The paddings of FocusArea highlight. It does't impact the paddings on its child views,