Add controllers for default app shortcut preferences.

For AppInfoDashboardFragment:
- add the default app shortcut preferences into the preference screen
instead of creating them dynamically.
- add controller for each of the shortcut preference.

Bug: 69384089
Test: make RunSettingsRoboTests
Change-Id: I1e81944a3bc867fd6a3a0d484bab77c3ad0e6441

res/xml/app_info_settings.xml

@@ -39,21 +39,18 @@
 
     <Preference
         android:key="notification_settings"
-        android:title="@string/notifications_label"
-        android:selectable="true"/>
+        android:title="@string/notifications_label"/>
 
     <com.android.settings.widget.FixedLineSummaryPreference
         android:key="permission_settings"
         android:title="@string/permissions_label"
         android:summary="@string/summary_placeholder"
-        android:selectable="true"
         app:summaryLineCount="1" />
 
     <Preference
         android:key="storage_settings"
         android:title="@string/storage_settings"
-        android:summary="@string/summary_placeholder"
-        android:selectable="true"/>
+        android:summary="@string/summary_placeholder"/>
 
     <com.android.settings.applications.AppDomainsPreference
         android:key="instant_app_launch_supported_domain_urls"
@@ -63,14 +60,12 @@
     <Preference
         android:key="data_settings"
         android:title="@string/data_usage_summary_title"
-        android:summary="@string/summary_placeholder"
-        android:selectable="true"/>
+        android:summary="@string/summary_placeholder"/>
 
     <Preference
         android:key="battery"
         android:title="@string/power_usage_summary_title"
-        android:summary="@string/summary_placeholder"
-        android:selectable="true"/>
+        android:summary="@string/summary_placeholder"/>
 
     <Preference
         android:key="preferred_settings"
@@ -82,8 +77,33 @@
         android:key="memory"
         android:title="@string/memory_settings_title"
         android:summary="@string/summary_placeholder"
-        android:enabled="false"
-        android:selectable="true"/>
+        android:enabled="false"/>
+
+    <!-- Default apps shortcuts -->
+    <Preference
+        android:key="default_home"
+        android:title="@string/home_app"
+        android:summary="@string/summary_placeholder" />
+
+    <Preference
+        android:key="default_browser"
+        android:title="@string/default_browser_title"
+        android:summary="@string/summary_placeholder" />
+
+    <Preference
+        android:key="default_phone_app"
+        android:title="@string/default_phone_title"
+        android:summary="@string/default_phone_title" />
+
+    <Preference
+        android:key="default_emergency_app"
+        android:title="@string/default_emergency_app"
+        android:summary="@string/summary_placeholder" />
+
+    <Preference
+        android:key="default_sms_app"
+        android:title="@string/sms_application_title"
+        android:summary="@string/summary_placeholder" />
 
     <Preference
         android:key="app_version"

src/com/android/settings/applications/AppInfoDashboardFragment.java

@@ -50,7 +50,6 @@ import android.support.v7.preference.Preference;
 import android.support.v7.preference.Preference.OnPreferenceClickListener;
 import android.support.v7.preference.PreferenceCategory;
 import android.support.v7.preference.PreferenceScreen;
-import android.text.BidiFormatter;
 import android.text.TextUtils;
 import android.util.Log;
 import android.view.Menu;
@@ -74,6 +73,11 @@ import com.android.settings.applications.appinfo.AppOpenByDefaultPreferenceContr
 import com.android.settings.applications.appinfo.AppPermissionPreferenceController;
 import com.android.settings.applications.appinfo.AppStoragePreferenceController;
 import com.android.settings.applications.appinfo.AppVersionPreferenceController;
+import com.android.settings.applications.appinfo.DefaultBrowserShortcutPreferenceController;
+import com.android.settings.applications.appinfo.DefaultEmergencyShortcutPreferenceController;
+import com.android.settings.applications.appinfo.DefaultHomeShortcutPreferenceController;
+import com.android.settings.applications.appinfo.DefaultPhoneShortcutPreferenceController;
+import com.android.settings.applications.appinfo.DefaultSmsShortcutPreferenceController;
 import com.android.settings.applications.defaultapps.DefaultBrowserPreferenceController;
 import com.android.settings.applications.defaultapps.DefaultEmergencyPreferenceController;
 import com.android.settings.applications.defaultapps.DefaultHomePreferenceController;
@@ -394,6 +398,12 @@ public class AppInfoDashboardFragment extends DashboardFragment
         // state when app state changes.
         controllers.add(new AppBatteryPreferenceController(context, this, packageName, lifecycle));
         controllers.add(new AppMemoryPreferenceController(context, this, lifecycle));
+        controllers.add(new DefaultHomeShortcutPreferenceController(context, packageName));
+        controllers.add(new DefaultBrowserShortcutPreferenceController(context, packageName));
+        controllers.add(new DefaultPhoneShortcutPreferenceController(context, packageName));
+        controllers.add(new DefaultEmergencyShortcutPreferenceController(context, packageName));
+        controllers.add(new DefaultSmsShortcutPreferenceController(context, packageName));
+
         return controllers;
     }
 
@@ -863,31 +873,6 @@ public class AppInfoDashboardFragment extends DashboardFragment
         }
         final PreferenceScreen screen = getPreferenceScreen();
         final Context context = getContext();
-        if (DefaultHomePreferenceController.hasHomePreference(mPackageName, context)) {
-            screen.addPreference(new ShortcutPreference(getPrefContext(),
-                    DefaultAppSettings.class, "default_home", R.string.home_app,
-                    R.string.configure_apps));
-        }
-        if (DefaultBrowserPreferenceController.hasBrowserPreference(mPackageName, context)) {
-            screen.addPreference(new ShortcutPreference(getPrefContext(),
-                    DefaultAppSettings.class, "default_browser", R.string.default_browser_title,
-                    R.string.configure_apps));
-        }
-        if (DefaultPhonePreferenceController.hasPhonePreference(mPackageName, context)) {
-            screen.addPreference(new ShortcutPreference(getPrefContext(),
-                    DefaultAppSettings.class, "default_phone_app", R.string.default_phone_title,
-                    R.string.configure_apps));
-        }
-        if (DefaultEmergencyPreferenceController.hasEmergencyPreference(mPackageName, context)) {
-            screen.addPreference(new ShortcutPreference(getPrefContext(),
-                    DefaultAppSettings.class, "default_emergency_app",
-                    R.string.default_emergency_app, R.string.configure_apps));
-        }
-        if (DefaultSmsPreferenceController.hasSmsPreference(mPackageName, context)) {
-            screen.addPreference(new ShortcutPreference(getPrefContext(),
-                    DefaultAppSettings.class, "default_sms_app", R.string.sms_application_title,
-                    R.string.configure_apps));
-        }
 
         // Get the package info with the activities
         PackageInfo packageInfoWithActivities = null;
@@ -1037,36 +1022,7 @@ public class AppInfoDashboardFragment extends DashboardFragment
 
     private void updateDynamicPrefs() {
         final Context context = getContext();
-        Preference pref = findPreference("default_home");
-
-        if (pref != null) {
-            pref.setSummary(DefaultHomePreferenceController.isHomeDefault(mPackageName,
-                    new PackageManagerWrapper(context.getPackageManager()))
-                    ? R.string.yes : R.string.no);
-        }
-        pref = findPreference("default_browser");
-        if (pref != null) {
-            pref.setSummary(new DefaultBrowserPreferenceController(context)
-                    .isBrowserDefault(mPackageName, mUserId)
-                    ? R.string.yes : R.string.no);
-        }
-        pref = findPreference("default_phone_app");
-        if (pref != null) {
-            pref.setSummary(
-                    DefaultPhonePreferenceController.isPhoneDefault(mPackageName, context)
-                    ? R.string.yes : R.string.no);
-        }
-        pref = findPreference("default_emergency_app");
-        if (pref != null) {
-            pref.setSummary(DefaultEmergencyPreferenceController.isEmergencyDefault(mPackageName,
-                    getContext()) ? R.string.yes : R.string.no);
-        }
-        pref = findPreference("default_sms_app");
-        if (pref != null) {
-            pref.setSummary(DefaultSmsPreferenceController.isSmsDefault(mPackageName, context)
-                    ? R.string.yes : R.string.no);
-        }
-        pref = findPreference("system_alert_window");
+        Preference pref = findPreference("system_alert_window");
         if (pref != null) {
             pref.setSummary(DrawOverlayDetails.getSummary(getContext(), mAppEntry));
         }

src/com/android/settings/applications/ShortcutPreference.java

@@ -21,7 +21,12 @@ import android.support.v7.preference.Preference;
 import com.android.internal.logging.nano.MetricsProto;
 import com.android.settings.SettingsActivity;
 import com.android.settings.Utils;
+import com.android.settings.applications.appinfo.DefaultAppShortcutPreferenceControllerBase;
 
+/**
+ * deprecated in favor of {@link DefaultAppShortcutPreferenceControllerBase}
+ */
+@Deprecated
 public class ShortcutPreference extends Preference {
 
     private final Class mTarget;

src/com/android/settings/applications/appinfo/DefaultAppShortcutPreferenceControllerBase.java

@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.app.slice.Slice;
+import android.content.Context;
+import android.os.Bundle;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+import android.text.TextUtils;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.Utils;
+import com.android.settings.applications.DefaultAppSettings;
+import com.android.settings.core.BasePreferenceController;
+
+/*
+ * Abstract base controller for the default app shortcut preferences that launches the default app
+ * settings with the corresponding default app highlighted.
+ */
+public abstract class DefaultAppShortcutPreferenceControllerBase extends BasePreferenceController {
+
+    protected final String mPackageName;
+
+    public DefaultAppShortcutPreferenceControllerBase(Context context, String preferenceKey,
+            String packageName) {
+        super(context, preferenceKey);
+        mPackageName = packageName;
+    }
+
+    @Override
+    public int getAvailabilityStatus() {
+        if (UserManager.get(mContext).isManagedProfile()) {
+            return DISABLED_FOR_USER;
+        }
+        return hasAppCapability() ? AVAILABLE : DISABLED_UNSUPPORTED;
+    }
+
+    @Override
+    public Slice getSettingSlice() {
+        return null;
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        preference.setSummary(isDefaultApp() ? R.string.yes : R.string.no);
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (TextUtils.equals(mPreferenceKey, preference.getKey())) {
+            Bundle bundle = new Bundle();
+            bundle.putString(SettingsActivity.EXTRA_FRAGMENT_ARG_KEY, mPreferenceKey);
+            Utils.startWithFragment(mContext, DefaultAppSettings.class.getName(), bundle, null, 0,
+                    R.string.configure_apps, null, MetricsProto.MetricsEvent.VIEW_UNKNOWN);
+            return true;
+        }
+        return false;
+    }
+
+    /**
+     * Check whether the app has the default app capability
+     * @return true if the app has the default app capability
+     */
+    protected abstract boolean hasAppCapability();
+
+    /**
+     * Check whether the app is the default app
+     * @return true if the app is the default app
+     */
+    protected abstract boolean isDefaultApp();
+
+}

src/com/android/settings/applications/appinfo/DefaultBrowserShortcutPreferenceController.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.content.Context;
+import android.os.UserHandle;
+
+import com.android.settings.applications.defaultapps.DefaultBrowserPreferenceController;
+
+public class DefaultBrowserShortcutPreferenceController
+        extends DefaultAppShortcutPreferenceControllerBase {
+
+    private static final String KEY = "default_browser";
+
+    public DefaultBrowserShortcutPreferenceController(Context context, String packageName) {
+        super(context, KEY, packageName);
+    }
+
+    @Override
+    protected boolean hasAppCapability() {
+        return DefaultBrowserPreferenceController.hasBrowserPreference(mPackageName, mContext);
+    }
+
+    @Override
+    protected boolean isDefaultApp() {
+        return new DefaultBrowserPreferenceController(mContext)
+                .isBrowserDefault(mPackageName, UserHandle.myUserId());
+    }
+
+}

src/com/android/settings/applications/appinfo/DefaultEmergencyShortcutPreferenceController.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.content.Context;
+
+import com.android.settings.applications.defaultapps.DefaultEmergencyPreferenceController;
+
+public class DefaultEmergencyShortcutPreferenceController
+        extends DefaultAppShortcutPreferenceControllerBase {
+
+    private static final String KEY = "default_emergency_app";
+
+    public DefaultEmergencyShortcutPreferenceController(Context context, String packageName) {
+        super(context, KEY, packageName);
+    }
+
+    @Override
+    protected boolean hasAppCapability() {
+        return DefaultEmergencyPreferenceController.hasEmergencyPreference(mPackageName, mContext);
+    }
+
+    @Override
+    protected boolean isDefaultApp() {
+        return DefaultEmergencyPreferenceController.isEmergencyDefault(mPackageName, mContext);
+    }
+
+}

src/com/android/settings/applications/appinfo/DefaultHomeShortcutPreferenceController.java

@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.content.Context;
+
+import com.android.settings.applications.defaultapps.DefaultHomePreferenceController;
+import com.android.settingslib.wrapper.PackageManagerWrapper;
+
+public class DefaultHomeShortcutPreferenceController
+        extends DefaultAppShortcutPreferenceControllerBase {
+
+    private static final String KEY = "default_home";
+
+    public DefaultHomeShortcutPreferenceController(Context context, String packageName) {
+        super(context, KEY, packageName);
+    }
+
+    @Override
+    protected boolean hasAppCapability() {
+        return DefaultHomePreferenceController.hasHomePreference(mPackageName, mContext);
+    }
+
+    @Override
+    protected boolean isDefaultApp() {
+        return DefaultHomePreferenceController.isHomeDefault(mPackageName,
+                new PackageManagerWrapper(mContext.getPackageManager()));
+    }
+
+}

src/com/android/settings/applications/appinfo/DefaultPhoneShortcutPreferenceController.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.content.Context;
+
+import com.android.settings.applications.defaultapps.DefaultPhonePreferenceController;
+
+public class DefaultPhoneShortcutPreferenceController
+        extends DefaultAppShortcutPreferenceControllerBase {
+
+    private static final String KEY = "default_phone_app";
+
+    public DefaultPhoneShortcutPreferenceController(Context context, String packageName) {
+        super(context, KEY, packageName);
+    }
+
+    @Override
+    protected boolean hasAppCapability() {
+        return DefaultPhonePreferenceController.hasPhonePreference(mPackageName, mContext);
+    }
+
+    @Override
+    protected boolean isDefaultApp() {
+        return DefaultPhonePreferenceController.isPhoneDefault(mPackageName, mContext);
+    }
+
+}

src/com/android/settings/applications/appinfo/DefaultSmsShortcutPreferenceController.java

@@ -0,0 +1,40 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import android.content.Context;
+
+import com.android.settings.applications.defaultapps.DefaultSmsPreferenceController;
+
+public class DefaultSmsShortcutPreferenceController
+        extends DefaultAppShortcutPreferenceControllerBase {
+
+    private static final String KEY = "default_sms_app";
+
+    public DefaultSmsShortcutPreferenceController(Context context, String packageName) {
+        super(context, KEY, packageName);
+    }
+
+    @Override
+    protected boolean hasAppCapability() {
+        return DefaultSmsPreferenceController.hasSmsPreference(mPackageName, mContext);
+    }
+
+    @Override
+    protected boolean isDefaultApp() {
+        return DefaultSmsPreferenceController.isSmsDefault(mPackageName, mContext);
+    }
+
+}

tests/robotests/src/com/android/settings/applications/AppInfoDashboardFragmentTest.java

@@ -73,8 +73,7 @@ import java.util.HashSet;
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(
     manifest = TestConfig.MANIFEST_PATH,
-    sdk = TestConfig.SDK_VERSION_O,
-    shadows = AppInfoDashboardFragmentTest.ShadowUtils.class
+    sdk = TestConfig.SDK_VERSION_O
 )
 public final class AppInfoDashboardFragmentTest {
 
@@ -369,6 +368,7 @@ public final class AppInfoDashboardFragmentTest {
     }
 
     @Test
+    @Config(shadows = ShadowUtils.class)
     public void handleDisableable_appIsEnabled_buttonShouldWork() {
         final ApplicationInfo info = new ApplicationInfo();
         info.packageName = "pkg";
@@ -411,6 +411,7 @@ public final class AppInfoDashboardFragmentTest {
     }
 
     @Test
+    @Config(shadows = ShadowUtils.class)
     public void handleDisableable_appIsEnabledAndInKeepEnabledWhitelist_buttonShouldNotWork() {
         final ApplicationInfo info = new ApplicationInfo();
         info.packageName = "pkg";

tests/robotests/src/com/android/settings/applications/appinfo/DefaultAppShortcutPreferenceControllerBaseTest.java

@@ -0,0 +1,145 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.verify;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.os.UserManager;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.PreferenceScreen;
+
+import com.android.settings.R;
+import com.android.settings.SettingsActivity;
+import com.android.settings.TestConfig;
+import com.android.settings.applications.AppInfoDashboardFragment;
+import com.android.settings.applications.DefaultAppSettings;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultAppShortcutPreferenceControllerBaseTest {
+
+    @Mock
+    private UserManager mUserManager;
+    @Mock
+    private AppInfoDashboardFragment mFragment;
+    @Mock
+    private PreferenceScreen mScreen;
+    @Mock
+    private Preference mPreference;
+
+    private Context mContext;
+    private TestPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getSystemService(Context.USER_SERVICE)).thenReturn(mUserManager);
+        mController = new TestPreferenceController(mContext, mFragment);
+        final String key = mController.getPreferenceKey();
+        when(mPreference.getKey()).thenReturn(key);
+    }
+
+    @Test
+    public void getAvailabilityStatus_managedProfile_shouldReturnDisabled() {
+        when(mUserManager.isManagedProfile()).thenReturn(true);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.DISABLED_FOR_USER);
+    }
+
+    @Test
+    public void getAvailabilityStatus_hasAppCapability_shouldReturnAvailable() {
+        mController.capable = true;
+        when(mUserManager.isManagedProfile()).thenReturn(false);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.AVAILABLE);
+    }
+
+    @Test
+    public void getAvailabilityStatus_noAppCapability_shouldReturnDisabled() {
+        mController.capable = false;
+        when(mUserManager.isManagedProfile()).thenReturn(false);
+
+        assertThat(mController.getAvailabilityStatus()).isEqualTo(mController.DISABLED_UNSUPPORTED);
+    }
+
+    @Test
+    public void updateState_isDefaultApp_shouldSetSummaryToYes() {
+        mController.isDefault = true;
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setSummary(R.string.yes);
+    }
+
+    @Test
+    public void updateState_notDefaultApp_shouldSetSummaryToNo() {
+        mController.isDefault = false;
+
+        mController.updateState(mPreference);
+
+        verify(mPreference).setSummary(R.string.no);
+    }
+
+    @Test
+    public void handlePreferenceTreeClick_shouldStartDefaultAppSettings() {
+        mController.handlePreferenceTreeClick(mPreference);
+
+        verify(mContext).startActivity(argThat(intent-> intent != null
+                && intent.getStringExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT).equals(
+                        DefaultAppSettings.class.getName())
+                && intent.getBundleExtra(SettingsActivity.EXTRA_SHOW_FRAGMENT_ARGUMENTS)
+                .getString(SettingsActivity.EXTRA_FRAGMENT_ARG_KEY).equals("TestKey")));
+    }
+
+    private class TestPreferenceController extends DefaultAppShortcutPreferenceControllerBase {
+
+        private boolean isDefault;
+        private boolean capable;
+
+        public TestPreferenceController(Context context, AppInfoDashboardFragment parent) {
+            super(context, "TestKey", "TestPackage");
+        }
+
+        @Override
+        protected boolean hasAppCapability() {
+            return capable;
+        }
+
+        @Override
+        protected boolean isDefaultApp() {
+            return isDefault;
+        }
+
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultBrowserShortcutPreferenceControllerTest.java

@@ -0,0 +1,96 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultBrowserShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultBrowserShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultBrowserShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultBrowser() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_browser");
+    }
+
+    @Test
+    public void hasAppCapability_hasBrowserCapability_shouldReturnTrue() {
+        List<ResolveInfo> resolveInfos = new ArrayList<>();
+        resolveInfos.add(new ResolveInfo());
+        when(mPackageManager.queryIntentActivities(argThat(intent-> intent != null
+                && intent.getCategories().contains(Intent.CATEGORY_BROWSABLE)), anyInt()))
+                .thenReturn(resolveInfos);
+
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noBrowserCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultBrowser_shouldReturnTrue() {
+        when(mPackageManager.getDefaultBrowserPackageNameAsUser(anyInt())).thenReturn("Package1");
+
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultBrowser_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultEmergencyShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.provider.Settings;
+import android.telephony.TelephonyManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+
+import java.util.ArrayList;
+import java.util.List;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultEmergencyShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultEmergencyShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultEmergencyShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultEmergency() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_emergency_app");
+    }
+
+    @Test
+    public void hasAppCapability_hasEmergencyCapability_shouldReturnTrue() {
+        List<ResolveInfo> resolveInfos = new ArrayList<>();
+        resolveInfos.add(new ResolveInfo());
+        when(mPackageManager.queryIntentActivities(argThat(intent-> intent != null
+                && intent.getAction().equals(TelephonyManager.ACTION_EMERGENCY_ASSISTANCE)),
+                anyInt())).thenReturn(resolveInfos);
+
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noEmergencyCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultEmergency_shouldReturnTrue() {
+        Settings.Secure.putString(mContext.getContentResolver(),
+                Settings.Secure.EMERGENCY_ASSISTANCE_APPLICATION, "Package1");
+
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultEmergency_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultHomeShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.ArgumentMatchers.anyList;
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.ComponentName;
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultHomePreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultHomeShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultHomeShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultHomeShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultHome() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_home");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultHomePreferenceController.class)
+    public void hasAppCapability_hasHomeCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noHomeCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    public void isDefaultApp_isDefaultHome_shouldReturnTrue() {
+        when(mPackageManager.getHomeActivities(anyList()))
+                .thenReturn(new ComponentName("Package1", "cls1"));
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultHome_shouldReturnFalse() {
+        when(mPackageManager.getHomeActivities(anyList()))
+                .thenReturn(new ComponentName("pkg2", "cls1"));
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultHomePreferenceController.class)
+    public static class ShadowDefaultHomePreferenceController {
+        @Implementation
+        public static boolean hasHomePreference(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultPhoneShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultPhonePreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultPhoneShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultPhoneShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultPhoneShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultPhone() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_phone_app");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultPhonePreferenceController.class)
+    public void hasAppCapability_hasPhoneCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noPhoneCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultPhonePreferenceController.class)
+    public void isDefaultApp_isDefaultPhone_shouldReturnTrue() {
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultPhone_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultPhonePreferenceController.class)
+    public static class ShadowDefaultPhonePreferenceController {
+        @Implementation
+        public static boolean hasPhonePreference(String pkg, Context context) {
+            return true;
+        }
+
+        @Implementation
+        public static boolean isPhoneDefault(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}

tests/robotests/src/com/android/settings/applications/appinfo/DefaultSmsShortcutPreferenceControllerTest.java

@@ -0,0 +1,99 @@
+/*
+ * Copyright (C) 2017 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.settings.applications.appinfo;
+
+import static com.google.common.truth.Truth.assertThat;
+
+import static org.mockito.Mockito.spy;
+import static org.mockito.Mockito.when;
+
+import android.content.Context;
+import android.content.pm.PackageManager;
+
+import com.android.settings.TestConfig;
+import com.android.settings.applications.defaultapps.DefaultSmsPreferenceController;
+import com.android.settings.testutils.SettingsRobolectricTestRunner;
+
+import org.junit.Before;
+import org.junit.Test;
+import org.junit.runner.RunWith;
+import org.mockito.Mock;
+import org.mockito.MockitoAnnotations;
+import org.robolectric.RuntimeEnvironment;
+import org.robolectric.annotation.Config;
+import org.robolectric.annotation.Implementation;
+import org.robolectric.annotation.Implements;
+
+@RunWith(SettingsRobolectricTestRunner.class)
+@Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION_O)
+public class DefaultSmsShortcutPreferenceControllerTest {
+
+    @Mock
+    private PackageManager mPackageManager;
+
+    private Context mContext;
+    private DefaultSmsShortcutPreferenceController mController;
+
+    @Before
+    public void setUp() {
+        MockitoAnnotations.initMocks(this);
+        mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
+        mController = new DefaultSmsShortcutPreferenceController(mContext, "Package1");
+    }
+
+    @Test
+    public void getPreferenceKey_shouldReturnDefaultSms() {
+        assertThat(mController.getPreferenceKey()).isEqualTo("default_sms_app");
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultSmsPreferenceController.class)
+    public void hasAppCapability_hasSmsCapability_shouldReturnTrue() {
+        assertThat(mController.hasAppCapability()).isTrue();
+    }
+
+    @Test
+    public void hasAppCapability_noSmsCapability_shouldReturnFalse() {
+        assertThat(mController.hasAppCapability()).isFalse();
+    }
+
+    @Test
+    @Config(shadows = ShadowDefaultSmsPreferenceController.class)
+    public void isDefaultApp_isDefaultSms_shouldReturnTrue() {
+        assertThat(mController.isDefaultApp()).isTrue();
+    }
+
+    @Test
+    public void isDefaultApp_notDefaultSms_shouldReturnFalse() {
+        assertThat(mController.isDefaultApp()).isFalse();
+    }
+
+    @Implements(DefaultSmsPreferenceController.class)
+    public static class ShadowDefaultSmsPreferenceController {
+        @Implementation
+        public static boolean hasSmsPreference(String pkg, Context context) {
+            return true;
+        }
+
+        @Implementation
+        public static boolean isSmsDefault(String pkg, Context context) {
+            return true;
+        }
+    }
+
+}