Add Open button to launch instant app.

- move logic from InstantAppButtonsController into
InstantAppButtonsPreferenceController, as it is not really necessary to
have separate control to be in different class.
- add logic to check if the instant app provides a default launch uri.
If so, show a Open button to launch the uri, and move the Install
button into option menu. If not, Install button remains as is.
- also update the instant app button layout to match the regular 2
buttons layout.

Change-Id: Ibcae780ad697ca93a48604b03c8f4600dd3c0472
Fixes: 69562807
Test: make RunSettingsRoboTests

res/layout/instant_app_buttons.xml

@@ -20,24 +20,39 @@
     android:id="@+id/instant_app_button_container"
     android:layout_width="match_parent"
     android:layout_height="wrap_content"
-    android:paddingTop="4dp"
+    android:gravity="center"
-    android:paddingStart="8dp"
+    android:paddingTop="24dp"
-    android:paddingEnd="8dp"
+    android:paddingStart="68dp"
-    android:visibility="gone">
+    android:paddingEnd="24dp"
-    <Button
+    android:orientation="horizontal">
-        android:id="@+id/install"
+
-        style="@style/ActionPrimaryButton"
+    <FrameLayout
-        android:enabled="false"
         android:layout_width="0dp"
         android:layout_weight="1"
-        android:layout_height="wrap_content"
+        android:layout_height="wrap_content">
-        android:layout_gravity="center"
+        <Button
-        android:text="@string/install_text"/>
+            android:id="@+id/install"
+            style="@style/ActionPrimaryButton"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="4dp"
+            android:text="@string/install_text"/>
+        <Button
+            android:id="@+id/launch"
+            style="@style/ActionPrimaryButton"
+            android:layout_width="match_parent"
+            android:layout_height="wrap_content"
+            android:layout_marginBottom="4dp"
+            android:text="@string/launch_instant_app"/>
+    </FrameLayout>
+    <Space
+        android:layout_width="16dp"
+        android:layout_height="wrap_content" />
     <Button
         android:id="@+id/clear_data"
         android:layout_width="0dp"
         android:layout_weight="1"
         android:layout_height="wrap_content"
-        android:layout_gravity="center"
+        android:layout_marginBottom="4dp"
         android:text="@string/clear_instant_app_data"/>
 </LinearLayout>

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

@@ -17,24 +17,13 @@
 package com.android.settings.applications;
 
 import android.annotation.UserIdInt;
-import android.app.Fragment;
 import android.content.Intent;
-import android.view.View;
-
-import com.android.settings.applications.instantapps.InstantAppButtonsController;
 
 import java.util.List;
 import java.util.Set;
 
 public interface ApplicationFeatureProvider {
 
-    /**
-     * Returns a new {@link InstantAppButtonsController} instance for showing buttons
-     * only relevant to instant apps.
-     */
-    InstantAppButtonsController newInstantAppButtonsController(Fragment fragment,
-            View view, InstantAppButtonsController.ShowDialogDelegate showDialogDelegate);
-
     /**
      * Calculates the total number of apps installed on the device via policy in the current user
      * and all its managed profiles.

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

@@ -16,7 +16,6 @@
 
 package com.android.settings.applications;
 
-import android.app.Fragment;
 import android.content.Context;
 import android.content.Intent;
 import android.content.pm.ComponentInfo;
@@ -26,9 +25,7 @@ import android.content.pm.UserInfo;
 import android.os.RemoteException;
 import android.os.UserManager;
 import android.util.ArraySet;
-import android.view.View;
 
-import com.android.settings.applications.instantapps.InstantAppButtonsController;
 import com.android.settings.wrapper.DevicePolicyManagerWrapper;
 import com.android.settings.wrapper.IPackageManagerWrapper;
 import com.android.settingslib.wrapper.PackageManagerWrapper;
@@ -54,12 +51,6 @@ public class ApplicationFeatureProviderImpl implements ApplicationFeatureProvide
         mUm = UserManager.get(mContext);
     }
 
-    @Override
-    public InstantAppButtonsController newInstantAppButtonsController(Fragment fragment,
-            View view, InstantAppButtonsController.ShowDialogDelegate showDialogDelegate) {
-        return new InstantAppButtonsController(mContext, fragment, view, showDialogDelegate);
-    }
-
     @Override
     public void calculateNumberOfPolicyInstalledApps(boolean async, NumberOfAppsCallback callback) {
         final CurrentUserAndManagedProfilePolicyInstalledAppCounter counter =

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

@@ -85,6 +85,7 @@ public class AppInfoDashboardFragment extends DashboardFragment
     @VisibleForTesting static final int UNINSTALL_ALL_USERS_MENU = 1;
     @VisibleForTesting static final int UNINSTALL_UPDATES = 2;
     static final int FORCE_STOP_MENU = 3;
+    static final int INSTALL_INSTANT_APP_MENU = 4;
 
     // Result code identifiers
     @VisibleForTesting
@@ -102,6 +103,7 @@ public class AppInfoDashboardFragment extends DashboardFragment
     static final int DLG_FORCE_STOP = DLG_BASE + 1;
     private static final int DLG_DISABLE = DLG_BASE + 2;
     private static final int DLG_SPECIAL_DISABLE = DLG_BASE + 3;
+    static final int DLG_CLEAR_INSTANT_APP = DLG_BASE + 4;
 
     private static final String KEY_ADVANCED_APP_INFO_CATEGORY = "advanced_app_info";
 
@@ -243,7 +245,7 @@ public class AppInfoDashboardFragment extends DashboardFragment
         // The following are controllers for preferences that don't need to refresh the preference
         // state when app state changes.
         mInstantAppButtonPreferenceController =
-                new InstantAppButtonsPreferenceController(context, this, packageName);
+                new InstantAppButtonsPreferenceController(context, this, packageName, lifecycle);
         controllers.add(mInstantAppButtonPreferenceController);
         controllers.add(new AppBatteryPreferenceController(context, this, packageName, lifecycle));
         controllers.add(new AppMemoryPreferenceController(context, this, lifecycle));

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

@@ -18,30 +18,62 @@ package com.android.settings.applications.appinfo;
 
 import android.app.AlertDialog;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.net.Uri;
+import android.os.Bundle;
+import android.os.UserHandle;
 import android.support.annotation.VisibleForTesting;
 import android.support.v7.preference.PreferenceScreen;
+import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuInflater;
+import android.view.MenuItem;
+import android.view.View;
+import android.widget.Button;
 
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
-import com.android.settings.applications.ApplicationFeatureProvider;
+import com.android.settings.applications.AppStoreUtil;
 import com.android.settings.applications.LayoutPreference;
-import com.android.settings.applications.instantapps.InstantAppButtonsController;
 import com.android.settings.core.BasePreferenceController;
 import com.android.settings.overlay.FeatureFactory;
 import com.android.settingslib.applications.AppUtils;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+import com.android.settingslib.core.lifecycle.LifecycleObserver;
+import com.android.settingslib.core.lifecycle.events.OnCreateOptionsMenu;
+import com.android.settingslib.core.lifecycle.events.OnOptionsItemSelected;
+import com.android.settingslib.core.lifecycle.events.OnPrepareOptionsMenu;
+import com.android.settingslib.wrapper.PackageManagerWrapper;
 
-public class InstantAppButtonsPreferenceController extends BasePreferenceController {
+import java.util.List;
+
+public class InstantAppButtonsPreferenceController extends BasePreferenceController implements
+        LifecycleObserver, OnCreateOptionsMenu, OnPrepareOptionsMenu, OnOptionsItemSelected,
+        DialogInterface.OnClickListener {
 
     private static final String KEY_INSTANT_APP_BUTTONS = "instant_app_buttons";
+    private static final String META_DATA_DEFAULT_URI = "default-url";
 
     private final AppInfoDashboardFragment mParent;
     private final String mPackageName;
-    private InstantAppButtonsController mInstantAppButtonsController;
+    private final PackageManagerWrapper mPackageManagerWrapper;
+    private String mLaunchUri;
+    private LayoutPreference mPreference;
+    private MenuItem mInstallMenu;
 
     public InstantAppButtonsPreferenceController(Context context, AppInfoDashboardFragment parent,
-            String packageName) {
+            String packageName, Lifecycle lifecycle) {
         super(context, KEY_INSTANT_APP_BUTTONS);
         mParent = parent;
         mPackageName = packageName;
+        mPackageManagerWrapper = new PackageManagerWrapper(context.getPackageManager());
+        mLaunchUri = getDefaultLaunchUri();
+        if (lifecycle != null) {
+            lifecycle.addObserver(this);
+        }
     }
 
     @Override
@@ -53,22 +85,98 @@ public class InstantAppButtonsPreferenceController extends BasePreferenceControl
     @Override
     public void displayPreference(PreferenceScreen screen) {
         super.displayPreference(screen);
-        LayoutPreference buttons =
+        mPreference = (LayoutPreference) screen.findPreference(KEY_INSTANT_APP_BUTTONS);
-                (LayoutPreference) screen.findPreference(KEY_INSTANT_APP_BUTTONS);
+        initButtons(mPreference.findViewById(R.id.instant_app_button_container));
-        mInstantAppButtonsController = getApplicationFeatureProvider()
-                .newInstantAppButtonsController(mParent,
-                        buttons.findViewById(R.id.instant_app_button_container),
-                        id -> mParent.showDialogInner(id, 0))
-                .setPackageName(mPackageName)
-                .show();
     }
 
-    public AlertDialog createDialog(int id) {
+    @Override
-        return mInstantAppButtonsController.createDialog(id);
+    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
+        if (!TextUtils.isEmpty(mLaunchUri)) {
+            menu.add(0, AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU, 2, R.string.install_text)
+                .setShowAsAction(MenuItem.SHOW_AS_ACTION_NEVER);
+        }
     }
 
-    @VisibleForTesting
+    @Override
-    ApplicationFeatureProvider getApplicationFeatureProvider() {
+    public boolean onOptionsItemSelected(MenuItem menuItem) {
-        return FeatureFactory.getFactory(mContext).getApplicationFeatureProvider(mContext);
+        if (menuItem.getItemId() == AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU) {
+            final Intent appStoreIntent = AppStoreUtil.getAppStoreLink(mContext, mPackageName);
+            if (appStoreIntent != null) {
+                mParent.startActivity(appStoreIntent);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public void onPrepareOptionsMenu(Menu menu) {
+        mInstallMenu = menu.findItem(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU);
+        final Intent appStoreIntent = AppStoreUtil.getAppStoreLink(mContext, mPackageName);
+        if (appStoreIntent == null) {
+            mInstallMenu.setEnabled(false);
+        }
+    }
+
+    @Override
+    public void onClick(DialogInterface dialog, int which) {
+        FeatureFactory.getFactory(mContext).getMetricsFeatureProvider()
+            .action(mContext, MetricsEvent.ACTION_SETTINGS_CLEAR_INSTANT_APP, mPackageName);
+        mPackageManagerWrapper.deletePackageAsUser(
+            mPackageName, null, 0, UserHandle.myUserId());
+    }
+
+    AlertDialog createDialog(int id) {
+        if (id == AppInfoDashboardFragment.DLG_CLEAR_INSTANT_APP) {
+            AlertDialog confirmDialog = new AlertDialog.Builder(mContext)
+                .setPositiveButton(R.string.clear_instant_app_data, this)
+                .setNegativeButton(R.string.cancel, null)
+                .setTitle(R.string.clear_instant_app_data)
+                .setMessage(mContext.getString(R.string.clear_instant_app_confirmation))
+                .create();
+            return confirmDialog;
+        }
+        return null;
+    }
+
+    private void initButtons(View view) {
+        final Button installButton = view.findViewById(R.id.install);
+        final Button clearDataButton = view.findViewById(R.id.clear_data);
+        final Button launchButton = view.findViewById(R.id.launch);
+        if (!TextUtils.isEmpty(mLaunchUri)) {
+            installButton.setVisibility(View.GONE);
+            final Intent intent = new Intent(Intent.ACTION_VIEW);
+            intent.setData(Uri.parse(mLaunchUri));
+            launchButton.setOnClickListener(v -> mParent.startActivity(intent));
+        } else {
+            launchButton.setVisibility(View.GONE);
+            final Intent appStoreIntent = AppStoreUtil.getAppStoreLink(mContext, mPackageName);
+            if (appStoreIntent != null) {
+                installButton.setOnClickListener(v -> mParent.startActivity(appStoreIntent));
+            } else {
+                installButton.setEnabled(false);
+            }
+        }
+        clearDataButton.setOnClickListener(
+            v -> mParent.showDialogInner(mParent.DLG_CLEAR_INSTANT_APP, 0));
+    }
+
+    private String getDefaultLaunchUri() {
+        final PackageManager manager = mContext.getPackageManager();
+        final Intent intent = new Intent(Intent.ACTION_MAIN);
+        intent.addCategory(Intent.CATEGORY_LAUNCHER);
+        intent.setPackage(mPackageName);
+        final List<ResolveInfo> infos = manager.queryIntentActivities(
+            intent, PackageManager.GET_META_DATA | PackageManager.MATCH_INSTANT);
+        for (ResolveInfo info : infos) {
+            final Bundle metaData = info.activityInfo.metaData;
+            if (metaData != null) {
+                final String launchUri = metaData.getString(META_DATA_DEFAULT_URI);
+                if (!TextUtils.isEmpty(launchUri)) {
+                    return launchUri;
+                }
+            }
+        }
+        return null;
     }
 }

src/com/android/settings/applications/instantapps/InstantAppButtonsController.java

@@ -1,113 +0,0 @@
-/*
- * 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.instantapps;
-
-import android.app.AlertDialog;
-import android.app.Fragment;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.os.UserHandle;
-import android.view.View;
-import android.widget.Button;
-
-import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
-import com.android.settings.R;
-import com.android.settings.applications.AppStoreUtil;
-import com.android.settings.overlay.FeatureFactory;
-import com.android.settingslib.wrapper.PackageManagerWrapper;
-
-/** Encapsulates a container for buttons relevant to instant apps */
-public class InstantAppButtonsController implements DialogInterface.OnClickListener {
-
-    public interface ShowDialogDelegate {
-        /**
-         * Delegate that should be called when this controller wants to show a dialog.
-         */
-        void showDialog(int id);
-    }
-
-    private final Context mContext;
-    private final Fragment mFragment;
-    private final View mView;
-    private final PackageManagerWrapper mPackageManagerWrapper;
-    private final ShowDialogDelegate mShowDialogDelegate;
-    private String mPackageName;
-
-    public static final int DLG_BASE = 0x5032;
-    public static final int DLG_CLEAR_APP = DLG_BASE + 1;
-
-    public InstantAppButtonsController(
-            Context context,
-            Fragment fragment,
-            View view,
-            ShowDialogDelegate showDialogDelegate) {
-      mContext = context;
-      mFragment = fragment;
-      mView = view;
-      mShowDialogDelegate = showDialogDelegate;
-      mPackageManagerWrapper = new PackageManagerWrapper(context.getPackageManager());
-    }
-
-    public InstantAppButtonsController setPackageName(String packageName) {
-        mPackageName = packageName;
-        return this;
-    }
-
-    public void bindButtons() {
-        Button installButton = (Button)mView.findViewById(R.id.install);
-        Button clearDataButton = (Button)mView.findViewById(R.id.clear_data);
-        Intent appStoreIntent = AppStoreUtil.getAppStoreLink(mContext, mPackageName);
-        if (appStoreIntent != null) {
-            installButton.setEnabled(true);
-            installButton.setOnClickListener(v -> mFragment.startActivity(appStoreIntent));
-        }
-
-        clearDataButton.setOnClickListener(v -> mShowDialogDelegate.showDialog(DLG_CLEAR_APP));
-    }
-
-    public AlertDialog createDialog(int id) {
-        if (id == DLG_CLEAR_APP) {
-            AlertDialog dialog = new AlertDialog.Builder(mFragment.getActivity())
-                    .setPositiveButton(R.string.clear_instant_app_data, this)
-                    .setNegativeButton(R.string.cancel, null)
-                    .setTitle(R.string.clear_instant_app_data)
-                    .setMessage(mContext.getString(R.string.clear_instant_app_confirmation))
-                    .create();
-            return dialog;
-        }
-        return null;
-    }
-
-    public void onClick(DialogInterface dialog, int which) {
-        if (which == DialogInterface.BUTTON_POSITIVE) {
-            FeatureFactory.getFactory(mContext)
-                    .getMetricsFeatureProvider()
-                    .action(mContext,
-                            MetricsEvent.ACTION_SETTINGS_CLEAR_INSTANT_APP,
-                            mPackageName);
-            mPackageManagerWrapper.deletePackageAsUser(
-                    mPackageName, null, 0, UserHandle.myUserId());
-        }
-    }
-
-    public InstantAppButtonsController show() {
-        bindButtons();
-        mView.setVisibility(View.VISIBLE);
-        return this;
-    }
-}

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

@@ -18,28 +18,40 @@ package com.android.settings.applications.appinfo;
 
 import static com.google.common.truth.Truth.assertThat;
 
-import static org.mockito.ArgumentMatchers.nullable;
+import static org.mockito.ArgumentMatchers.any;
+import static org.mockito.ArgumentMatchers.anyInt;
+import static org.mockito.ArgumentMatchers.argThat;
+import static org.mockito.ArgumentMatchers.eq;
 import static org.mockito.Mockito.mock;
+import static org.mockito.Mockito.never;
 import static org.mockito.Mockito.spy;
 import static org.mockito.Mockito.verify;
 import static org.mockito.Mockito.when;
 
-import android.app.AlertDialog;
+import android.content.ComponentName;
-import android.app.Fragment;
 import android.content.Context;
+import android.content.DialogInterface;
+import android.content.Intent;
+import android.content.pm.ActivityInfo;
 import android.content.pm.ApplicationInfo;
 import android.content.pm.PackageInfo;
 import android.content.pm.PackageManager;
+import android.content.pm.ResolveInfo;
+import android.support.v7.preference.PreferenceManager;
 import android.support.v7.preference.PreferenceScreen;
+import android.text.TextUtils;
+import android.view.Menu;
+import android.view.MenuItem;
 import android.view.View;
+import android.widget.Button;
 
+import com.android.settings.R;
 import com.android.settings.TestConfig;
 import com.android.settings.applications.LayoutPreference;
-import com.android.settings.applications.instantapps.InstantAppButtonsController;
-import com.android.settings.testutils.FakeFeatureFactory;
 import com.android.settings.testutils.SettingsRobolectricTestRunner;
 import com.android.settingslib.applications.AppUtils;
 import com.android.settingslib.applications.instantapps.InstantAppDataProvider;
+import com.android.settingslib.wrapper.PackageManagerWrapper;
 
 import org.junit.Before;
 import org.junit.Test;
@@ -54,27 +66,48 @@ import org.robolectric.util.ReflectionHelpers;
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
 public class InstantAppButtonsPreferenceControllerTest {
 
+    private static final String TEST_INSTALLER_PACKAGE_NAME = "com.installer";
+    private static final String TEST_INSTALLER_ACTIVITY_NAME = "com.installer.InstallerActivity";
+    private static final String TEST_AIA_PACKAGE_NAME = "test.aia.package";
+
     @Mock
     private PackageManager mPackageManager;
     @Mock
     private ApplicationInfo mAppInfo;
     @Mock
     private AppInfoDashboardFragment mFragment;
+    @Mock
+    private LayoutPreference mPreference;
 
     private Context mContext;
+    private PreferenceScreen mScreen;
+    private PreferenceManager mPreferenceManager;
+    private Button mLaunchButton;
+    private Button mInstallButton;
+    private Button mClearAppButton;
     private InstantAppButtonsPreferenceController mController;
-    private FakeFeatureFactory mFeatureFactory;
 
     @Before
     public void setUp() throws PackageManager.NameNotFoundException {
         MockitoAnnotations.initMocks(this);
-        mFeatureFactory = FakeFeatureFactory.setupForTest();
         mContext = spy(RuntimeEnvironment.application);
+        when(mContext.getPackageManager()).thenReturn(mPackageManager);
         final PackageInfo packageInfo = mock(PackageInfo.class);
         packageInfo.applicationInfo = mAppInfo;
         when(mFragment.getPackageInfo()).thenReturn(packageInfo);
-        mController =
+        mPreferenceManager = new PreferenceManager(mContext);
-                spy(new InstantAppButtonsPreferenceController(mContext, mFragment, "Package1"));
+        mScreen = mPreferenceManager.createPreferenceScreen(mContext);
+        when(mFragment.getPreferenceManager()).thenReturn(mPreferenceManager);
+        final View buttons = View.inflate(
+            RuntimeEnvironment.application, R.layout.instant_app_buttons, null /* parent */);
+        mLaunchButton = buttons.findViewById(R.id.launch);
+        mInstallButton = buttons.findViewById(R.id.install);
+        mClearAppButton = buttons.findViewById(R.id.clear_data);
+        mController = spy(new InstantAppButtonsPreferenceController(
+            mContext, mFragment, TEST_AIA_PACKAGE_NAME, null /* lifecycle */));
+        when(mPreference.getKey()).thenReturn("instant_app_buttons");
+        mScreen.addPreference(mPreference);
+        when(mPreference.findViewById(R.id.instant_app_button_container)).thenReturn(buttons);
     }
 
     @Test
@@ -94,39 +127,164 @@ public class InstantAppButtonsPreferenceControllerTest {
     }
 
     @Test
-    public void displayPreference_shouldSetPreferenceTitle() {
+    public void onCreateOptionsMenu_noLaunchUri_shouldNotAddInstallInstantAppMenu() {
-        final PreferenceScreen screen = mock(PreferenceScreen.class);
+        final Menu menu = mock(Menu.class);
-        final LayoutPreference preference = mock(LayoutPreference.class);
+        when(menu.add(anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(mock(MenuItem.class));
-        when(screen.findPreference(mController.getPreferenceKey())).thenReturn(preference);
-        when(mController.getApplicationFeatureProvider())
-                .thenReturn(mFeatureFactory.applicationFeatureProvider);
-        final InstantAppButtonsController buttonsController =
-                mock(InstantAppButtonsController.class);
-        when(buttonsController.setPackageName(nullable(String.class)))
-                .thenReturn(buttonsController);
-        when(mFeatureFactory.applicationFeatureProvider.newInstantAppButtonsController(
-                nullable(Fragment.class), nullable(View.class),
-                nullable(InstantAppButtonsController.ShowDialogDelegate.class)))
-                .thenReturn(buttonsController);
 
-        mController.displayPreference(screen);
+        mController.onCreateOptionsMenu(menu, null /* inflater */);
 
-        verify(buttonsController).setPackageName(nullable(String.class));
+        verify(menu, never()).add(anyInt(), eq(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU),
-        verify(buttonsController).show();
+            anyInt(), eq(R.string.install_text));
     }
 
     @Test
-    public void createDialog_shouldReturnDialogFromButtonController() {
+    public void onCreateOptionsMenu_hasLaunchUri_shouldAddForceStop() {
-        final InstantAppButtonsController buttonsController =
+        ReflectionHelpers.setField(mController, "mLaunchUri", "www.test.launch");
-                mock(InstantAppButtonsController.class);
+        final Menu menu = mock(Menu.class);
-        ReflectionHelpers.setField(
+        when(menu.add(anyInt(), anyInt(), anyInt(), anyInt())).thenReturn(mock(MenuItem.class));
-                mController, "mInstantAppButtonsController", buttonsController);
-        final AlertDialog mockDialog = mock(AlertDialog.class);
-        when(buttonsController.createDialog(InstantAppButtonsController.DLG_CLEAR_APP))
-                .thenReturn(mockDialog);
 
-        assertThat(mController.createDialog(InstantAppButtonsController.DLG_CLEAR_APP))
+        mController.onCreateOptionsMenu(menu, null /* inflater */);
-                .isEqualTo(mockDialog);
+
+        verify(menu).add(anyInt(), eq(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU),
+            anyInt(), eq(R.string.install_text));
+    }
+
+    @Test
+    public void onPrepareOptionsMenu_noAppStoreLink_shoulDisableInstallInstantAppMenu() {
+        ReflectionHelpers.setField(mController, "mLaunchUri", "www.test.launch");
+        final Menu menu = mock(Menu.class);
+        final MenuItem menuItem = mock(MenuItem.class);
+        when(menu.findItem(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU)).thenReturn(menuItem);
+
+        mController.onPrepareOptionsMenu(menu);
+
+        verify(menuItem).setEnabled(false);
+    }
+
+    @Test
+    public void onPrepareOptionsMenu_hasAppStoreLink_shoulNotDisableInstallInstantAppMenu() {
+        ReflectionHelpers.setField(mController, "mLaunchUri", "www.test.launch");
+        final ResolveInfo resolveInfo = mock(ResolveInfo.class);
+        final ActivityInfo activityInfo = mock(ActivityInfo.class);
+        resolveInfo.activityInfo = activityInfo;
+        activityInfo.packageName = TEST_INSTALLER_PACKAGE_NAME;
+        activityInfo.name = TEST_INSTALLER_ACTIVITY_NAME;
+        when(mPackageManager.resolveActivity(any(), anyInt())).thenReturn(resolveInfo);
+        final Menu menu = mock(Menu.class);
+        final MenuItem menuItem = mock(MenuItem.class);
+        when(menu.findItem(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU)).thenReturn(menuItem);
+
+        mController.onPrepareOptionsMenu(menu);
+
+        verify(menuItem, never()).setEnabled(false);
+    }
+
+    @Test
+    public void onOptionsItemSelected_shouldOpenAppStore() {
+        final ResolveInfo resolveInfo = mock(ResolveInfo.class);
+        final ActivityInfo activityInfo = mock(ActivityInfo.class);
+        resolveInfo.activityInfo = activityInfo;
+        activityInfo.packageName = TEST_INSTALLER_PACKAGE_NAME;
+        activityInfo.name = TEST_INSTALLER_ACTIVITY_NAME;
+        when(mPackageManager.resolveActivity(any(), anyInt())).thenReturn(resolveInfo);
+        mController.displayPreference(mScreen);
+        final ComponentName componentName =
+            new ComponentName(TEST_INSTALLER_PACKAGE_NAME, TEST_INSTALLER_ACTIVITY_NAME);
+        final MenuItem menu = mock(MenuItem.class);
+        when(menu.getItemId()).thenReturn(AppInfoDashboardFragment.INSTALL_INSTANT_APP_MENU);
+
+        mController.onOptionsItemSelected(menu);
+
+        verify(mFragment).startActivity(argThat(intent-> intent != null
+            && intent.getAction().equals(Intent.ACTION_SHOW_APP_INFO)
+            && intent.getComponent().equals(componentName)));
+    }
+
+    @Test
+    public void displayPreference_noLaunchUri_shouldShowHideLaunchButton() {
+        mController.displayPreference(mScreen);
+
+        assertThat(mLaunchButton.getVisibility()).isEqualTo(View.GONE);
+    }
+
+    @Test
+    public void displayPreference_hasLaunchUri_shouldShowHideInstallButton() {
+        ReflectionHelpers.setField(mController, "mLaunchUri", "www.test.launch");
+
+        mController.displayPreference(mScreen);
+
+        assertThat(mInstallButton.getVisibility()).isEqualTo(View.GONE);
+    }
+
+    @Test
+    public void displayPreference_noAppStoreLink_shoulDisableInstallButton() {
+        mController.displayPreference(mScreen);
+
+        assertThat(mInstallButton.isEnabled()).isFalse();
+    }
+
+    @Test
+    public void displayPreference_hasAppStoreLink_shoulSetClickListenerForInstallButton() {
+        final ResolveInfo resolveInfo = mock(ResolveInfo.class);
+        final ActivityInfo activityInfo = mock(ActivityInfo.class);
+        resolveInfo.activityInfo = activityInfo;
+        activityInfo.packageName = TEST_INSTALLER_PACKAGE_NAME;
+        activityInfo.name = TEST_INSTALLER_ACTIVITY_NAME;
+        when(mPackageManager.resolveActivity(any(), anyInt())).thenReturn(resolveInfo);
+
+        mController.displayPreference(mScreen);
+
+        assertThat(mInstallButton.hasOnClickListeners()).isTrue();
+    }
+
+    @Test
+    public void displayPreference_shoulSetClickListenerForClearButton() {
+        mController.displayPreference(mScreen);
+
+        assertThat(mClearAppButton.hasOnClickListeners()).isTrue();
+    }
+
+    @Test
+    public void clickLaunchButton_shouldLaunchViewIntent() {
+        final String launchUri = "www.test.launch";
+        ReflectionHelpers.setField(mController, "mLaunchUri", launchUri);
+        mController.displayPreference(mScreen);
+
+        mLaunchButton.callOnClick();
+
+        verify(mFragment).startActivity(argThat(intent-> intent != null
+            && intent.getAction().equals(Intent.ACTION_VIEW)
+            && TextUtils.equals(intent.getDataString(), launchUri)));
+    }
+
+    @Test
+    public void clickInstallButton_shouldOpenAppStore() {
+        final ResolveInfo resolveInfo = mock(ResolveInfo.class);
+        final ActivityInfo activityInfo = mock(ActivityInfo.class);
+        resolveInfo.activityInfo = activityInfo;
+        activityInfo.packageName = TEST_INSTALLER_PACKAGE_NAME;
+        activityInfo.name = TEST_INSTALLER_ACTIVITY_NAME;
+        when(mPackageManager.resolveActivity(any(), anyInt())).thenReturn(resolveInfo);
+        mController.displayPreference(mScreen);
+        final ComponentName componentName =
+            new ComponentName(TEST_INSTALLER_PACKAGE_NAME, TEST_INSTALLER_ACTIVITY_NAME);
+
+        mInstallButton.callOnClick();
+
+        verify(mFragment).startActivity(argThat(intent-> intent != null
+            && intent.getAction().equals(Intent.ACTION_SHOW_APP_INFO)
+            && intent.getComponent().equals(componentName)));
+    }
+
+    @Test
+    public void onClick_shouldDeleteApp() {
+        PackageManagerWrapper packageManagerWrapper = mock(PackageManagerWrapper.class);
+        ReflectionHelpers.setField(mController, "mPackageManagerWrapper", packageManagerWrapper);
+
+        mController.onClick(mock(DialogInterface.class), DialogInterface.BUTTON_POSITIVE);
+
+        verify(packageManagerWrapper)
+            .deletePackageAsUser(eq(TEST_AIA_PACKAGE_NAME), any(), anyInt(),anyInt());
     }
 
 }

tests/robotests/src/com/android/settings/applications/instantapps/InstantAppButtonsControllerTest.java

@@ -1,181 +0,0 @@
-/*
- * 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.instantapps;
-
-import static com.android.settings.applications.instantapps.InstantAppButtonsController
-        .ShowDialogDelegate;
-import static com.google.common.truth.Truth.assertThat;
-import static org.mockito.Matchers.any;
-import static org.mockito.Matchers.anyInt;
-import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.doAnswer;
-import static org.mockito.Mockito.mock;
-import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyZeroInteractions;
-import static org.mockito.Mockito.when;
-
-import android.annotation.SuppressLint;
-import android.app.Fragment;
-import android.content.ComponentName;
-import android.content.Context;
-import android.content.DialogInterface;
-import android.content.Intent;
-import android.content.pm.ActivityInfo;
-import android.content.pm.PackageManager;
-import android.content.pm.ResolveInfo;
-import android.view.View;
-import android.widget.Button;
-
-import com.android.settings.R;
-import com.android.settings.TestConfig;
-import com.android.settings.testutils.FakeFeatureFactory;
-import com.android.settings.testutils.SettingsRobolectricTestRunner;
-import com.android.settingslib.core.instrumentation.MetricsFeatureProvider;
-import com.android.settingslib.wrapper.PackageManagerWrapper;
-
-import org.junit.Before;
-import org.junit.BeforeClass;
-import org.junit.Test;
-import org.junit.runner.RunWith;
-import org.mockito.Answers;
-import org.mockito.Mock;
-import org.mockito.MockitoAnnotations;
-import org.robolectric.annotation.Config;
-import org.robolectric.util.ReflectionHelpers;
-
-/** Tests for the InstantAppButtonsController. */
-@RunWith(SettingsRobolectricTestRunner.class)
-@Config(manifest = TestConfig.MANIFEST_PATH, sdk = 23)
-public class InstantAppButtonsControllerTest {
-
-    private static final String TEST_INSTALLER_PACKAGE_NAME = "com.installer";
-    private static final String TEST_INSTALLER_ACTIVITY_NAME = "com.installer.InstallerActivity";
-    private static final String TEST_AIA_PACKAGE_NAME = "test.aia.package";
-    private static ComponentName sTestInstallerComponent;
-
-    @BeforeClass
-    public static void beforeClass() {
-        sTestInstallerComponent =
-                new ComponentName(
-                        TEST_INSTALLER_PACKAGE_NAME,
-                        TEST_INSTALLER_ACTIVITY_NAME);
-    }
-
-    @Mock(answer = Answers.RETURNS_DEEP_STUBS)
-    Context mockContext;
-    @Mock
-    PackageManager mockPackageManager;
-    @Mock
-    PackageManagerWrapper mockPackageManagerWrapper;
-    @Mock
-    View mockView;
-    @Mock
-    ShowDialogDelegate mockShowDialogDelegate;
-    @Mock
-    Button mockInstallButton;
-    @Mock
-    Button mockClearButton;
-    @Mock
-    MetricsFeatureProvider mockMetricsFeatureProvider;
-    @Mock
-    ResolveInfo mockResolveInfo;
-    @Mock
-    ActivityInfo mockActivityInfo;
-
-    private PackageManager stubPackageManager;
-
-    private FakeFeatureFactory fakeFeatureFactory;
-    private TestFragment testFragment;
-    private InstantAppButtonsController controller;
-
-
-    private View.OnClickListener receivedListener;
-
-    @Before
-    public void init() {
-        MockitoAnnotations.initMocks(this);
-        testFragment = new TestFragment();
-        when(mockView.findViewById(R.id.install)).thenReturn(mockInstallButton);
-        when(mockView.findViewById(R.id.clear_data)).thenReturn(mockClearButton);
-        mockResolveInfo.activityInfo = mockActivityInfo;
-        mockActivityInfo.packageName = TEST_INSTALLER_PACKAGE_NAME;
-        mockActivityInfo.name = TEST_INSTALLER_ACTIVITY_NAME;
-        when(mockContext.getPackageManager()).thenReturn(mockPackageManager);
-        when(mockPackageManager.resolveActivity(any(), anyInt())).thenReturn(mockResolveInfo);
-        controller = new InstantAppButtonsController(
-                mockContext, testFragment, mockView, mockShowDialogDelegate);
-        controller.setPackageName(TEST_AIA_PACKAGE_NAME);
-        ReflectionHelpers.setField(
-                controller, "mPackageManagerWrapper", mockPackageManagerWrapper);
-        FakeFeatureFactory.setupForTest();
-    }
-
-    @Test
-    public void testInstallListenerTriggersInstall() {
-        doAnswer(invocation -> {
-            receivedListener = (View.OnClickListener) invocation.getArguments()[0];
-            return null;
-        }).when(mockInstallButton).setOnClickListener(any());
-        controller.bindButtons();
-
-        assertThat(receivedListener).isNotNull();
-        receivedListener.onClick(mockInstallButton);
-        assertThat(testFragment.getStartActivityIntent()).isNotNull();
-        assertThat(testFragment.getStartActivityIntent().getComponent())
-                .isEqualTo(sTestInstallerComponent);
-    }
-
-    @Test
-    public void testClearListenerShowsDialog() {
-        doAnswer(invocation -> {
-            receivedListener = (View.OnClickListener) invocation.getArguments()[0];
-            return null;
-        }).when(mockClearButton).setOnClickListener(any());
-        controller.bindButtons();
-        assertThat(receivedListener).isNotNull();
-        receivedListener.onClick(mockClearButton);
-        verify(mockShowDialogDelegate).showDialog(InstantAppButtonsController.DLG_CLEAR_APP);
-    }
-
-    @Test
-    public void testDialogInterfaceOnClick_positiveClearsApp() {
-        controller.onClick(mock(DialogInterface.class), DialogInterface.BUTTON_POSITIVE);
-        verify(mockPackageManagerWrapper)
-                .deletePackageAsUser(eq(TEST_AIA_PACKAGE_NAME), any(), anyInt(),anyInt());
-    }
-
-    @Test
-    public void testDialogInterfaceOnClick_nonPositiveDoesNothing() {
-        controller.onClick(mock(DialogInterface.class), DialogInterface.BUTTON_NEGATIVE);
-        controller.onClick(mock(DialogInterface.class), DialogInterface.BUTTON_NEUTRAL);
-        verifyZeroInteractions(mockPackageManagerWrapper);
-    }
-    @SuppressLint("ValidFragment")
-    private class TestFragment extends Fragment {
-
-        private Intent startActivityIntent;
-
-        public Intent getStartActivityIntent() {
-            return startActivityIntent;
-        }
-
-        @Override
-        public void startActivity(Intent intent) {
-            startActivityIntent = intent;
-        }
-    }
-}