Update picture-in-picture settings to match mocks.

- Removing switches in top-level picture-in-picture settings, adding
  details screen for each app which contains the switch and some
  additional information.

Bug: 35957404
Test: make -j40 RunSettingsRoboTests
Change-Id: Ib22df8a52ab857e071ec43dd3e5d1f5282db35cb

AndroidManifest.xml

@@ -2490,6 +2490,18 @@
                 android:value="com.android.settings.applications.PictureInPictureSettings" />
         </activity>
 
+        <activity android:name="Settings$AppPictureInPictureSettingsActivity"
+            android:label="@string/picture_in_picture_title"
+            android:taskAffinity="">
+            <intent-filter>
+                <action android:name="android.settings.PICTURE_IN_PICTURE_SETTINGS" />
+                <category android:name="android.intent.category.DEFAULT" />
+                <data android:scheme="package" />
+            </intent-filter>
+            <meta-data android:name="com.android.settings.FRAGMENT_CLASS"
+                android:value="com.android.settings.applications.PictureInPictureDetails" />
+        </activity>
+
         <activity android:name="Settings$ZenAccessSettingsActivity"
                   android:label="@string/manage_zen_access_title"
                   android:taskAffinity="">

res/values/strings.xml

@@ -6459,8 +6459,17 @@
     <!-- Apps > App Details > Advanced section string title. [CHAR LIMIT=NONE] -->
     <string name="picture_in_picture_app_detail_title">Picture-in-picture</string>
 
-    <!-- Apps > App Details > Advanced section string description. [CHAR LIMIT=NONE] -->
+    <!-- Apps > App Details > Picture-in-picture > Switch title. [CHAR LIMIT=NONE] -->
-    <string name="picture_in_picture_app_detail_summary">Permit entering picture-in-picture when leaving app</string>
+    <string name="picture_in_picture_app_detail_switch">Allow picture-in-picture</string>
+
+    <!-- Apps > App Details > Picture-in-picture > Description. [CHAR LIMIT=NONE] -->
+    <string name="picture_in_picture_app_detail_summary">Allow this app to create a picture-in-picture window while the app is open or after you leave it (for example, to continue watching a video).  This window displays on top of other apps you're using.</string>
+
+    <!-- Summary of app allowed to enter picture-in-picture. [CHAR LIMIT=60] -->
+    <string name="picture_in_picture_on">Yes</string>
+
+    <!-- Summary of app not allowed to enter picture-in-picture. [CHAR LIMIT=60] -->
+    <string name="picture_in_picture_off">No</string>
 
     <!-- Sound & notification > Advanced section: Title for managing Do Not Disturb access option. [CHAR LIMIT=40] -->
     <string name="manage_zen_access_title">Do Not Disturb access</string>

res/xml/special_access.xml

@@ -79,6 +79,7 @@
         android:title="@string/picture_in_picture_title"
         android:fragment="com.android.settings.applications.PictureInPictureSettings"
         settings:keywords="@string/picture_in_picture_keywords" />
+
     <Preference
         android:key="premium_sms"
         android:title="@string/premium_sms_access"

src/com/android/settings/Settings.java

@@ -95,6 +95,7 @@ public class Settings extends SettingsActivity {
     public static class NotificationAccessSettingsActivity extends SettingsActivity { /* empty */ }
     public static class VrListenersSettingsActivity extends SettingsActivity { /* empty */ }
     public static class PictureInPictureSettingsActivity extends SettingsActivity { /* empty */ }
+    public static class AppPictureInPictureSettingsActivity extends SettingsActivity { /* empty */ }
     public static class ZenAccessSettingsActivity extends SettingsActivity { /* empty */ }
     public static class ConditionProviderSettingsActivity extends SettingsActivity { /* empty */ }
     public static class UsbSettingsActivity extends SettingsActivity { /* empty */ }

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

@@ -52,7 +52,6 @@ import android.os.ServiceManager;
 import android.os.UserHandle;
 import android.os.UserManager;
 import android.support.annotation.VisibleForTesting;
-import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
 import android.support.v7.preference.Preference.OnPreferenceClickListener;
 import android.support.v7.preference.PreferenceCategory;
@@ -1041,17 +1040,16 @@ public class InstalledAppDetails extends AppInfoBase
                 category.addPreference(pref);
             }
             if (hasPictureInPictureActivities) {
-                final SwitchPreference pref = new SwitchPreference(getPrefContext());
+                Preference pref = new Preference(getPrefContext());
-                pref.setPersistent(false);
                 pref.setTitle(R.string.picture_in_picture_app_detail_title);
-                pref.setSummary(R.string.picture_in_picture_app_detail_summary);
+                pref.setKey("picture_in_picture");
-                pref.setChecked(PictureInPictureSettings.getEnterPipOnHideStateForPackage(
+                pref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
-                        getContext(), mPackageInfo.applicationInfo.uid, mPackageName));
-                pref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
                     @Override
-                    public boolean onPreferenceChange(Preference preference, Object newValue) {
+                    public boolean onPreferenceClick(Preference preference) {
-                        PictureInPictureSettings.setEnterPipOnHideStateForPackage(getContext(),
+                        AppInfoBase.startAppInfoFragment(PictureInPictureDetails.class,
-                                mPackageInfo.applicationInfo.uid, mPackageName, (Boolean) newValue);
+                                R.string.picture_in_picture_app_detail_title, mPackageName,
+                                mPackageInfo.applicationInfo.uid, InstalledAppDetails.this,
+                                -1, getMetricsCategory());
                         return true;
                     }
                 });
@@ -1164,6 +1162,11 @@ public class InstalledAppDetails extends AppInfoBase
         if (pref != null) {
             pref.setSummary(DrawOverlayDetails.getSummary(getContext(), mAppEntry));
         }
+        pref = findPreference("picture_in_picture");
+        if (pref != null) {
+            pref.setSummary(PictureInPictureDetails.getPreferenceSummary(getContext(),
+                    mPackageInfo.applicationInfo.uid, mPackageName));
+        }
         pref = findPreference("write_settings_apps");
         if (pref != null) {
             pref.setSummary(WriteSettingsDetails.getSummary(getContext(), mAppEntry));

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

@@ -0,0 +1,138 @@
+/*
+ * 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;
+
+import static android.app.AppOpsManager.MODE_ALLOWED;
+import static android.app.AppOpsManager.MODE_ERRORED;
+import static android.app.AppOpsManager.OP_PICTURE_IN_PICTURE;
+
+import android.app.AlertDialog;
+import android.app.AppOpsManager;
+import android.content.Context;
+import android.content.Intent;
+import android.os.Bundle;
+import android.provider.Settings;
+import android.support.v14.preference.SwitchPreference;
+import android.support.v7.preference.Preference;
+import android.support.v7.preference.Preference.OnPreferenceChangeListener;
+
+import com.android.internal.annotations.VisibleForTesting;
+import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
+import com.android.settings.R;
+import com.android.settings.overlay.FeatureFactory;
+
+public class PictureInPictureDetails extends AppInfoWithHeader
+        implements OnPreferenceChangeListener {
+
+    private static final String KEY_APP_OPS_SETTINGS_SWITCH = "app_ops_settings_switch";
+    private static final String KEY_APP_OPS_SETTINGS_PREFS = "app_ops_settings_preference";
+    private static final String KEY_APP_OPS_SETTINGS_DESC = "app_ops_settings_description";
+    private static final String LOG_TAG = "PictureInPictureDetails";
+
+    private SwitchPreference mSwitchPref;
+    private Preference mOverlayDesc;
+    private Intent mSettingsIntent;
+
+    @Override
+    public void onCreate(Bundle savedInstanceState) {
+        super.onCreate(savedInstanceState);
+
+        // find preferences
+        addPreferencesFromResource(R.xml.app_ops_permissions_details);
+        mSwitchPref = (SwitchPreference) findPreference(KEY_APP_OPS_SETTINGS_SWITCH);
+        mOverlayDesc = findPreference(KEY_APP_OPS_SETTINGS_DESC);
+        getPreferenceScreen().removePreference(findPreference(KEY_APP_OPS_SETTINGS_PREFS));
+
+        // set title/summary for all of them
+        getPreferenceScreen().setTitle(R.string.picture_in_picture_app_detail_title);
+        mSwitchPref.setTitle(R.string.picture_in_picture_app_detail_switch);
+        mOverlayDesc.setSummary(R.string.picture_in_picture_app_detail_summary);
+
+        // install event listeners
+        mSwitchPref.setOnPreferenceChangeListener(this);
+
+        mSettingsIntent = new Intent(Intent.ACTION_MAIN)
+                .setAction(Settings.ACTION_PICTURE_IN_PICTURE_SETTINGS);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        if (preference == mSwitchPref) {
+            logSpecialPermissionChange((Boolean) newValue, mPackageName);
+            setEnterPipStateForPackage(getActivity(), mPackageInfo.applicationInfo.uid, mPackageName,
+                    (Boolean) newValue);
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    protected boolean refreshUi() {
+        boolean isAllowed = getEnterPipStateForPackage(getActivity(),
+                mPackageInfo.applicationInfo.uid, mPackageName);
+        mSwitchPref.setChecked(isAllowed);
+        return true;
+    }
+
+    @Override
+    protected AlertDialog createDialog(int id, int errorCode) {
+        return null;
+    }
+
+    @Override
+    public int getMetricsCategory() {
+        return MetricsEvent.SETTINGS_MANAGE_PICTURE_IN_PICTURE;
+    }
+
+    /**
+     * Sets whether the app associated with the given {@param packageName} is allowed to enter
+     * picture-in-picture.
+     */
+    static void setEnterPipStateForPackage(Context context, int uid, String packageName,
+            boolean value) {
+        final AppOpsManager appOps = context.getSystemService(AppOpsManager.class);
+        final int newMode = value ? MODE_ALLOWED : MODE_ERRORED;
+        appOps.setMode(OP_PICTURE_IN_PICTURE, uid, packageName, newMode);
+    }
+
+    /**
+     * @return whether the app associated with the given {@param packageName} is allowed to enter
+     *         picture-in-picture.
+     */
+    static boolean getEnterPipStateForPackage(Context context, int uid, String packageName) {
+        final AppOpsManager appOps = context.getSystemService(AppOpsManager.class);
+        return appOps.checkOpNoThrow(OP_PICTURE_IN_PICTURE, uid, packageName) == MODE_ALLOWED;
+    }
+
+    /**
+     * @return the summary for the current state of whether the app associated with the given
+     *         {@param packageName} is allowed to enter picture-in-picture.
+     */
+    static int getPreferenceSummary(Context context, int uid, String packageName) {
+        final boolean enabled = PictureInPictureDetails.getEnterPipStateForPackage(context, uid,
+                packageName);
+        return enabled ? R.string.picture_in_picture_on : R.string.picture_in_picture_off;
+    }
+
+    @VisibleForTesting
+    void logSpecialPermissionChange(boolean newState, String packageName) {
+        int logCategory = newState
+                ? MetricsEvent.APP_PICTURE_IN_PICTURE_ALLOW
+                : MetricsEvent.APP_PICTURE_IN_PICTURE_DENY;
+        FeatureFactory.getFactory(getContext())
+                .getMetricsFeatureProvider().action(getContext(), logCategory, packageName);
+    }
+}

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

@@ -15,13 +15,9 @@
  */
 package com.android.settings.applications;
 
-import static android.app.AppOpsManager.MODE_ALLOWED;
-import static android.app.AppOpsManager.MODE_ERRORED;
-import static android.app.AppOpsManager.OP_ENTER_PICTURE_IN_PICTURE_ON_HIDE;
 import static android.content.pm.PackageManager.GET_ACTIVITIES;
 
 import android.annotation.Nullable;
-import android.app.AppOpsManager;
 import android.content.Context;
 import android.content.pm.ActivityInfo;
 import android.content.pm.ApplicationInfo;
@@ -30,8 +26,8 @@ import android.content.pm.PackageItemInfo;
 import android.content.pm.PackageManager;
 import android.os.Bundle;
 import android.os.UserHandle;
-import android.support.v14.preference.SwitchPreference;
 import android.support.v7.preference.Preference;
+import android.support.v7.preference.Preference.OnPreferenceClickListener;
 import android.support.v7.preference.PreferenceScreen;
 import android.util.ArrayMap;
 import android.view.View;
@@ -40,7 +36,6 @@ import com.android.internal.annotations.VisibleForTesting;
 import com.android.internal.logging.nano.MetricsProto.MetricsEvent;
 import com.android.settings.R;
 import com.android.settings.notification.EmptyTextSettings;
-import com.android.settings.overlay.FeatureFactory;
 
 import java.util.ArrayList;
 import java.util.Collections;
@@ -98,28 +93,6 @@ public class PictureInPictureSettings extends EmptyTextSettings {
         return false;
     }
 
-    /**
-     * Sets whether the app associated with the given {@param packageName} is allowed to enter
-     * picture-in-picture when it is hidden.
-     */
-    static void setEnterPipOnHideStateForPackage(Context context, int uid, String packageName,
-            boolean value) {
-        final AppOpsManager appOps = context.getSystemService(AppOpsManager.class);
-        final int newMode = value ? MODE_ALLOWED : MODE_ERRORED;
-        appOps.setMode(OP_ENTER_PICTURE_IN_PICTURE_ON_HIDE,
-                uid, packageName, newMode);
-    }
-
-    /**
-     * @return whether the app associated with the given {@param packageName} is allowed to enter
-     *         picture-in-picture when it is hidden.
-     */
-    static boolean getEnterPipOnHideStateForPackage(Context context, int uid, String packageName) {
-        final AppOpsManager appOps = context.getSystemService(AppOpsManager.class);
-        return appOps.checkOpNoThrow(OP_ENTER_PICTURE_IN_PICTURE_ON_HIDE,
-                uid, packageName) == MODE_ALLOWED;
-    }
-
     @Override
     public void onCreate(Bundle icicle) {
         super.onCreate(icicle);
@@ -147,8 +120,8 @@ public class PictureInPictureSettings extends EmptyTextSettings {
             if (checkPackageHasPictureInPictureActivities(packageInfo.packageName,
                     packageInfo.activities)) {
                 final String packageName = packageInfo.applicationInfo.packageName;
-                final boolean state = getEnterPipOnHideStateForPackage(mContext,
+                final boolean state = PictureInPictureDetails.getEnterPipStateForPackage(
-                        packageInfo.applicationInfo.uid, packageName);
+                        mContext, packageInfo.applicationInfo.uid, packageName);
                 pipApps.add(packageInfo.applicationInfo);
                 packageToState.put(packageName, state);
             }
@@ -160,17 +133,18 @@ public class PictureInPictureSettings extends EmptyTextSettings {
         for (final ApplicationInfo appInfo : pipApps) {
             final String packageName = appInfo.packageName;
             final CharSequence label = appInfo.loadLabel(mPackageManager);
-            final SwitchPreference pref = new SwitchPreference(prefContext);
+
-            pref.setPersistent(false);
+            final Preference pref = new Preference(prefContext);
             pref.setIcon(appInfo.loadIcon(mPackageManager));
             pref.setTitle(label);
-            pref.setChecked(packageToState.get(packageName));
+            pref.setSummary(PictureInPictureDetails.getPreferenceSummary(prefContext,
-            pref.setOnPreferenceChangeListener(new Preference.OnPreferenceChangeListener() {
+                    appInfo.uid, packageName));
+            pref.setOnPreferenceClickListener(new OnPreferenceClickListener() {
                 @Override
-                public boolean onPreferenceChange(Preference preference, Object newValue) {
+                public boolean onPreferenceClick(Preference preference) {
-                    logSpecialPermissionChange((Boolean) newValue, packageName);
+                    AppInfoBase.startAppInfoFragment(PictureInPictureDetails.class,
-                    setEnterPipOnHideStateForPackage(mContext, appInfo.uid, packageName,
+                            R.string.picture_in_picture_app_detail_title, packageName, appInfo.uid,
-                            (Boolean) newValue);
+                            PictureInPictureSettings.this, -1, getMetricsCategory());
                     return true;
                 }
             });
@@ -188,13 +162,4 @@ public class PictureInPictureSettings extends EmptyTextSettings {
     public int getMetricsCategory() {
         return MetricsEvent.SETTINGS_MANAGE_PICTURE_IN_PICTURE;
     }
-
-    @VisibleForTesting
-    void logSpecialPermissionChange(boolean newState, String packageName) {
-        int logCategory = newState
-                ? MetricsEvent.APP_PICTURE_IN_PICTURE_ON_HIDE_ALLOW
-                : MetricsEvent.APP_PICTURE_IN_PICTURE_ON_HIDE_DENY;
-        FeatureFactory.getFactory(getContext())
-                .getMetricsFeatureProvider().action(getContext(), logCategory, packageName);
-    }
 }

src/com/android/settings/core/gateway/SettingsGateway.java

@@ -52,6 +52,7 @@ import com.android.settings.applications.InstalledAppDetails;
 import com.android.settings.applications.ManageApplications;
 import com.android.settings.applications.ManageDomainUrls;
 import com.android.settings.applications.NotificationApps;
+import com.android.settings.applications.PictureInPictureDetails;
 import com.android.settings.applications.PictureInPictureSettings;
 import com.android.settings.applications.ProcessStatsSummary;
 import com.android.settings.applications.ProcessStatsUi;
@@ -218,6 +219,7 @@ public class SettingsGateway {
             WallpaperTypeSettings.class.getName(),
             VrListenerSettings.class.getName(),
             PictureInPictureSettings.class.getName(),
+            PictureInPictureDetails.class.getName(),
             ManagedProfileSettings.class.getName(),
             ChooseAccountActivity.class.getName(),
             IccLockSettings.class.getName(),

tests/robotests/assets/grandfather_not_implementing_indexable

@@ -91,3 +91,4 @@ com.android.settings.localepicker.LocaleListEditor
 com.android.settings.qstile.DevelopmentTileConfigActivity$DevelopmentTileConfigFragment
 com.android.settings.applications.ExternalSourcesDetails
 com.android.settings.applications.PictureInPictureSettings
+com.android.settings.applications.PictureInPictureDetails

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

@@ -17,8 +17,6 @@
 package com.android.settings.applications;
 
 import android.content.Context;
-import android.content.pm.ActivityInfo;
-import android.content.pm.PackageInfo;
 
 import com.android.internal.logging.nano.MetricsProto;
 import com.android.settings.SettingsRobolectricTestRunner;
@@ -34,40 +32,32 @@ import org.mockito.MockitoAnnotations;
 import org.robolectric.annotation.Config;
 import org.robolectric.util.ReflectionHelpers;
 
-import java.lang.reflect.Field;
-
 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.argThat;
-import static org.mockito.Matchers.anyObject;
 import static org.mockito.Matchers.eq;
-import static org.mockito.Mockito.atLeast;
 import static org.mockito.Mockito.verify;
-import static org.mockito.Mockito.verifyNoMoreInteractions;
-import static org.mockito.Mockito.when;
 
 @RunWith(SettingsRobolectricTestRunner.class)
 @Config(manifest = TestConfig.MANIFEST_PATH, sdk = TestConfig.SDK_VERSION)
-public class PictureInPictureSettingsTest {
+public class PictureInPictureDetailsTest {
 
     @Mock(answer = Answers.RETURNS_DEEP_STUBS)
     private Context mContext;
 
     private FakeFeatureFactory mFeatureFactory;
-    private PictureInPictureSettings mFragment;
+    private PictureInPictureDetails mFragment;
 
     @Before
     public void setUp() {
         MockitoAnnotations.initMocks(this);
         FakeFeatureFactory.setupForTest(mContext);
         mFeatureFactory = (FakeFeatureFactory) FakeFeatureFactory.getFactory(mContext);
-        mFragment = new PictureInPictureSettings();
+        mFragment = new PictureInPictureDetails();
     }
 
     @Test
     public void testIgnoredApp() {
-        for (String ignoredPackage : mFragment.IGNORE_PACKAGE_LIST) {
+        for (String ignoredPackage : PictureInPictureSettings.IGNORE_PACKAGE_LIST) {
             assertThat(checkPackageHasPictureInPictureActivities(ignoredPackage, true))
                             .isFalse();
         }
@@ -94,11 +84,11 @@ public class PictureInPictureSettingsTest {
     public void logSpecialPermissionChange() {
         mFragment.logSpecialPermissionChange(true, "app");
         verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
-                eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_ON_HIDE_ALLOW), eq("app"));
+                eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_ALLOW), eq("app"));
 
         mFragment.logSpecialPermissionChange(false, "app");
         verify(mFeatureFactory.metricsFeatureProvider).action(any(Context.class),
-                eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_ON_HIDE_DENY), eq("app"));
+                eq(MetricsProto.MetricsEvent.APP_PICTURE_IN_PICTURE_DENY), eq("app"));
     }
 
     private boolean checkPackageHasPictureInPictureActivities(String packageName,