Misc fixes for User page and my device info page

- Rename UserAndAccountDashboard* to AccountDashboard* - Move emergency info from account to device info page - Move auto sync data toggles (4 of them) from Account page to user page - Move the controllers too. UserSettings is a not a DashboardFragment so I had to manually call each controller method. TODO: refactor UserSettings to a DashboardFragment - Move legal information/regulatory info above advance button within device info page. Fixes: 72523158 Bug: 71871075 Test: robotests Change-Id: I1b8af8af61e49d17926f984978a09a974b6c62e1
2018-01-26 10:15:56 -08:00
parent c24930aaf2
commit 881d579620
26 changed files with 243 additions and 178 deletions
--- a/src/com/android/settings/users/AddUserWhenLockedPreferenceController.java
+++ b/src/com/android/settings/users/AddUserWhenLockedPreferenceController.java
@@ -0,0 +1,87 @@
+/*
+ * Copyright (C) 2016 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.users;
+
+import android.content.Context;
+import android.provider.Settings.Global;
+import android.support.v7.preference.Preference;
+
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settingslib.RestrictedSwitchPreference;
+import com.android.settingslib.core.AbstractPreferenceController;
+import com.android.settingslib.core.lifecycle.Lifecycle;
+import com.android.settingslib.core.lifecycle.LifecycleObserver;
+import com.android.settingslib.core.lifecycle.events.OnPause;
+import com.android.settingslib.core.lifecycle.events.OnResume;
+
+public class AddUserWhenLockedPreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin, Preference.OnPreferenceChangeListener,
+        LifecycleObserver, OnPause, OnResume {
+
+    private final String mPrefKey;
+    private final UserCapabilities mUserCaps;
+    private boolean mShouldUpdateUserList;
+
+    public AddUserWhenLockedPreferenceController(Context context, String key, Lifecycle lifecycle) {
+        super(context);
+        mPrefKey = key;
+        mUserCaps = UserCapabilities.create(context);
+        if (lifecycle != null) {
+            lifecycle.addObserver(this);
+        }
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        RestrictedSwitchPreference restrictedSwitchPreference =
+                (RestrictedSwitchPreference) preference;
+        int value = Global.getInt(mContext.getContentResolver(), Global.ADD_USERS_WHEN_LOCKED, 0);
+        restrictedSwitchPreference.setChecked(value == 1);
+        restrictedSwitchPreference.setDisabledByAdmin(
+                mUserCaps.disallowAddUser() ? mUserCaps.getEnforcedAdmin() : null);
+    }
+
+    @Override
+    public boolean onPreferenceChange(Preference preference, Object newValue) {
+        Boolean value = (Boolean) newValue;
+        Global.putInt(mContext.getContentResolver(),
+                Global.ADD_USERS_WHEN_LOCKED, value != null && value ? 1 : 0);
+        return true;
+    }
+
+    @Override
+    public void onPause() {
+        mShouldUpdateUserList = true;
+    }
+
+    @Override
+    public void onResume() {
+        if (mShouldUpdateUserList) {
+            mUserCaps.updateAddUserCapabilities(mContext);
+        }
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return mUserCaps.isAdmin() &&
+                (!mUserCaps.disallowAddUser() || mUserCaps.disallowAddUserSetByAdmin());
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return mPrefKey;
+    }
+}
--- a/src/com/android/settings/users/AutoSyncDataPreferenceController.java
+++ b/src/com/android/settings/users/AutoSyncDataPreferenceController.java
@@ -0,0 +1,164 @@
+/*
+ * Copyright (C) 2016 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.users;
+
+import android.app.ActivityManager;
+import android.app.AlertDialog;
+import android.app.Dialog;
+import android.app.Fragment;
+import android.content.ContentResolver;
+import android.content.Context;
+import android.content.DialogInterface;
+import android.os.Bundle;
+import android.os.Process;
+import android.os.UserHandle;
+import android.os.UserManager;
+import android.support.v14.preference.SwitchPreference;
+import android.support.v7.preference.Preference;
+import android.util.Log;
+
+import com.android.internal.logging.nano.MetricsProto;
+import com.android.settings.R;
+import com.android.settings.core.PreferenceControllerMixin;
+import com.android.settings.core.instrumentation.InstrumentedDialogFragment;
+import com.android.settingslib.core.AbstractPreferenceController;
+
+public class AutoSyncDataPreferenceController extends AbstractPreferenceController
+        implements PreferenceControllerMixin {
+
+    private static final String TAG = "AutoSyncDataController";
+    private static final String TAG_CONFIRM_AUTO_SYNC_CHANGE = "confirmAutoSyncChange";
+    private static final String KEY_AUTO_SYNC_ACCOUNT = "auto_sync_account_data";
+
+    protected final UserManager mUserManager;
+    private final Fragment mParentFragment;
+
+    protected UserHandle mUserHandle;
+
+    public AutoSyncDataPreferenceController(Context context, Fragment parent) {
+        super(context);
+        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
+        mParentFragment = parent;
+        mUserHandle = Process.myUserHandle();
+    }
+
+    @Override
+    public void updateState(Preference preference) {
+        SwitchPreference switchPreference = (SwitchPreference) preference;
+        switchPreference.setChecked(ContentResolver.getMasterSyncAutomaticallyAsUser(
+                mUserHandle.getIdentifier()));
+    }
+
+    @Override
+    public boolean handlePreferenceTreeClick(Preference preference) {
+        if (getPreferenceKey().equals(preference.getKey())) {
+            SwitchPreference switchPreference = (SwitchPreference) preference;
+            boolean checked = switchPreference.isChecked();
+            switchPreference.setChecked(!checked);
+            if (ActivityManager.isUserAMonkey()) {
+                Log.d(TAG, "ignoring monkey's attempt to flip sync state");
+            } else {
+                ConfirmAutoSyncChangeFragment.show(mParentFragment, checked, mUserHandle,
+                        switchPreference);
+            }
+            return true;
+        }
+        return false;
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return !mUserManager.isManagedProfile()
+                && (mUserManager.isLinkedUser()
+                || mUserManager.getProfiles(UserHandle.myUserId()).size() == 1);
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_AUTO_SYNC_ACCOUNT;
+    }
+
+    /**
+     * Dialog to inform user about changing auto-sync setting
+     */
+    public static class ConfirmAutoSyncChangeFragment extends InstrumentedDialogFragment implements
+            DialogInterface.OnClickListener {
+        private static final String SAVE_ENABLING = "enabling";
+        private static final String SAVE_USER_HANDLE = "userHandle";
+        boolean mEnabling;
+        UserHandle mUserHandle;
+        SwitchPreference mPreference;
+
+        public static void show(Fragment parent, boolean enabling, UserHandle userHandle,
+                SwitchPreference preference) {
+            if (!parent.isAdded()) return;
+
+            final ConfirmAutoSyncChangeFragment dialog = new ConfirmAutoSyncChangeFragment();
+            dialog.mEnabling = enabling;
+            dialog.mUserHandle = userHandle;
+            dialog.setTargetFragment(parent, 0);
+            dialog.mPreference = preference;
+            dialog.show(parent.getFragmentManager(), TAG_CONFIRM_AUTO_SYNC_CHANGE);
+        }
+
+        @Override
+        public Dialog onCreateDialog(Bundle savedInstanceState) {
+            final Context context = getActivity();
+            if (savedInstanceState != null) {
+                mEnabling = savedInstanceState.getBoolean(SAVE_ENABLING);
+                mUserHandle = (UserHandle) savedInstanceState.getParcelable(SAVE_USER_HANDLE);
+            }
+
+            final AlertDialog.Builder builder = new AlertDialog.Builder(context);
+            if (!mEnabling) {
+                builder.setTitle(R.string.data_usage_auto_sync_off_dialog_title);
+                builder.setMessage(R.string.data_usage_auto_sync_off_dialog);
+            } else {
+                builder.setTitle(R.string.data_usage_auto_sync_on_dialog_title);
+                builder.setMessage(R.string.data_usage_auto_sync_on_dialog);
+            }
+
+            builder.setPositiveButton(android.R.string.ok, this);
+            builder.setNegativeButton(android.R.string.cancel, null);
+
+            return builder.create();
+        }
+
+        @Override
+        public void onSaveInstanceState(Bundle outState) {
+            super.onSaveInstanceState(outState);
+            outState.putBoolean(SAVE_ENABLING, mEnabling);
+            outState.putParcelable(SAVE_USER_HANDLE, mUserHandle);
+        }
+
+        @Override
+        public int getMetricsCategory() {
+            return MetricsProto.MetricsEvent.DIALOG_CONFIRM_AUTO_SYNC_CHANGE;
+        }
+
+        @Override
+        public void onClick(DialogInterface dialog, int which) {
+            if (which == DialogInterface.BUTTON_POSITIVE) {
+                ContentResolver.setMasterSyncAutomaticallyAsUser(mEnabling,
+                        mUserHandle.getIdentifier());
+                if (mPreference != null) {
+                    mPreference.setChecked(mEnabling);
+                }
+            }
+        }
+    }
+
+}
--- a/src/com/android/settings/users/AutoSyncPersonalDataPreferenceController.java
+++ b/src/com/android/settings/users/AutoSyncPersonalDataPreferenceController.java
@@ -0,0 +1,42 @@
+/*
+ * Copyright (C) 2016 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.users;
+
+import android.app.Fragment;
+import android.content.Context;
+import android.os.UserHandle;
+
+public class AutoSyncPersonalDataPreferenceController extends AutoSyncDataPreferenceController {
+
+    private static final String TAG = "AutoSyncPersonalData";
+    private static final String KEY_AUTO_SYNC_PERSONAL_ACCOUNT = "auto_sync_personal_account_data";
+
+    public AutoSyncPersonalDataPreferenceController(Context context, Fragment parent) {
+        super(context, parent);
+    }
+
+    @Override
+    public boolean isAvailable() {
+        return !mUserManager.isManagedProfile() && !mUserManager.isLinkedUser()
+                && mUserManager.getProfiles(UserHandle.myUserId()).size() > 1;
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_AUTO_SYNC_PERSONAL_ACCOUNT;
+    }
+
+}
--- a/src/com/android/settings/users/AutoSyncWorkDataPreferenceController.java
+++ b/src/com/android/settings/users/AutoSyncWorkDataPreferenceController.java
@@ -0,0 +1,37 @@
+/*
+ * Copyright (C) 2016 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.users;
+
+import android.app.Fragment;
+import android.content.Context;
+
+import com.android.settings.Utils;
+
+public class AutoSyncWorkDataPreferenceController extends AutoSyncPersonalDataPreferenceController {
+
+    private static final String TAG = "AutoSyncWorkData";
+    private static final String KEY_AUTO_SYNC_WORK_ACCOUNT = "auto_sync_work_account_data";
+
+    public AutoSyncWorkDataPreferenceController(Context context, Fragment parent) {
+        super(context, parent);
+        mUserHandle = Utils.getManagedProfileWithDisabled(mUserManager);
+    }
+
+    @Override
+    public String getPreferenceKey() {
+        return KEY_AUTO_SYNC_WORK_ACCOUNT;
+    }
+}
--- a/src/com/android/settings/users/UserCapabilities.java
+++ b/src/com/android/settings/users/UserCapabilities.java
@@ -41,6 +41,7 @@ public class UserCapabilities {
    public static UserCapabilities create(Context context) {
        UserManager userManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
        UserCapabilities caps = new UserCapabilities();
+
        if (!UserManager.supportsMultipleUsers() || Utils.isMonkeyRunning()) {
            caps.mEnabled = false;
            return caps;
--- a/src/com/android/settings/users/UserSettings.java
+++ b/src/com/android/settings/users/UserSettings.java
@@ -103,6 +103,7 @@ public class UserSettings extends SettingsPreferenceFragment
    private static final String KEY_USER_LIST = "user_list";
    private static final String KEY_USER_ME = "user_me";
    private static final String KEY_ADD_USER = "user_add";
+    private static final String KEY_ADD_USER_WHEN_LOCKED = "user_settings_add_users_when_locked";

    private static final int MENU_REMOVE_USER = Menu.FIRST;

@@ -145,8 +146,11 @@ public class UserSettings extends SettingsPreferenceFragment
    private SparseArray<Bitmap> mUserIcons = new SparseArray<>();
    private static SparseArray<Bitmap> sDarkDefaultUserBitmapCache = new SparseArray<>();

-    private EditUserInfoController mEditUserInfoController =
-            new EditUserInfoController();
+    private EditUserInfoController mEditUserInfoController = new EditUserInfoController();
+    private AddUserWhenLockedPreferenceController mAddUserWhenLockedPreferenceController;
+    private AutoSyncDataPreferenceController mAutoSyncDataPreferenceController;
+    private AutoSyncPersonalDataPreferenceController mAutoSyncPersonalDataPreferenceController;
+    private AutoSyncWorkDataPreferenceController mAutoSyncWorkDataPreferenceController;

    // A place to cache the generated default avatar
    private Drawable mDefaultIconDrawable;
@@ -191,6 +195,28 @@ public class UserSettings extends SettingsPreferenceFragment
    @Override
    public void onCreate(Bundle icicle) {
        super.onCreate(icicle);
+        addPreferencesFromResource(R.xml.user_settings);
+        if (Global.getInt(getContext().getContentResolver(), Global.DEVICE_PROVISIONED, 0) == 0) {
+            getActivity().finish();
+            return;
+        }
+        final Context context = getActivity();
+        mAddUserWhenLockedPreferenceController = new AddUserWhenLockedPreferenceController(
+                context, KEY_ADD_USER_WHEN_LOCKED, getLifecycle());
+
+        mAutoSyncDataPreferenceController = new AutoSyncDataPreferenceController(context, this);
+        mAutoSyncPersonalDataPreferenceController =
+                new AutoSyncPersonalDataPreferenceController(context, this);
+        mAutoSyncWorkDataPreferenceController =
+                new AutoSyncWorkDataPreferenceController(context, this);
+
+        final PreferenceScreen screen = getPreferenceScreen();
+        mAddUserWhenLockedPreferenceController.displayPreference(screen);
+        mAutoSyncDataPreferenceController.displayPreference(screen);
+        mAutoSyncPersonalDataPreferenceController.displayPreference(screen);
+        mAutoSyncWorkDataPreferenceController.displayPreference(screen);
+        screen.findPreference(mAddUserWhenLockedPreferenceController.getPreferenceKey())
+                .setOnPreferenceChangeListener(mAddUserWhenLockedPreferenceController);

        if (icicle != null) {
            if (icicle.containsKey(SAVE_ADDING_USER)) {
@@ -201,7 +227,7 @@ public class UserSettings extends SettingsPreferenceFragment
            }
            mEditUserInfoController.onRestoreInstanceState(icicle);
        }
-        final Context context = getActivity();
+
        mUserCaps = UserCapabilities.create(context);
        mUserManager = (UserManager) context.getSystemService(Context.USER_SERVICE);
        if (!mUserCaps.mEnabled) {
@@ -210,7 +236,6 @@ public class UserSettings extends SettingsPreferenceFragment

        final int myUserId = UserHandle.myUserId();

-        addPreferencesFromResource(R.xml.user_settings);
        mUserListCategory = (PreferenceGroup) findPreference(KEY_USER_LIST);
        mMePreference = new UserPreference(getPrefContext(), null /* attrs */, myUserId,
                null /* settings icon handler */,
@@ -230,25 +255,40 @@ public class UserSettings extends SettingsPreferenceFragment
                mAddUser.setTitle(R.string.user_add_user_menu);
            }
        }
-        setHasOptionsMenu(true);
-        IntentFilter filter = new IntentFilter(Intent.ACTION_USER_REMOVED);
+        final IntentFilter filter = new IntentFilter(Intent.ACTION_USER_REMOVED);
        filter.addAction(Intent.ACTION_USER_INFO_CHANGED);
        context.registerReceiverAsUser(mUserChangeReceiver, UserHandle.ALL, filter, null, mHandler);
        loadProfile();
        updateUserList();
        mShouldUpdateUserList = false;
-
-        if (Global.getInt(getContext().getContentResolver(), Global.DEVICE_PROVISIONED, 0) == 0) {
-            getActivity().finish();
-            return;
-        }
    }

    @Override
    public void onResume() {
        super.onResume();

-        if (!mUserCaps.mEnabled) return;
+        if (!mUserCaps.mEnabled) {
+            return;
+        }
+        final PreferenceScreen screen = getPreferenceScreen();
+
+        if (mAutoSyncDataPreferenceController.isAvailable()) {
+            mAutoSyncDataPreferenceController.updateState(screen.findPreference(
+                    mAutoSyncDataPreferenceController.getPreferenceKey()));
+        }
+        if (mAddUserWhenLockedPreferenceController.isAvailable()) {
+            mAddUserWhenLockedPreferenceController.updateState(screen.findPreference(
+                    mAddUserWhenLockedPreferenceController.getPreferenceKey()));
+        }
+        if (mAutoSyncPersonalDataPreferenceController.isAvailable()) {
+            mAutoSyncPersonalDataPreferenceController.updateState(screen.findPreference(
+                    mAutoSyncPersonalDataPreferenceController.getPreferenceKey()));
+        }
+        if (mAutoSyncWorkDataPreferenceController.isAvailable()) {
+            mAutoSyncWorkDataPreferenceController.updateState(screen.findPreference(
+                    mAutoSyncWorkDataPreferenceController.getPreferenceKey()));
+        }
+
        if (mShouldUpdateUserList) {
            mUserCaps.updateAddUserCapabilities(getActivity());
            loadProfile();
@@ -266,7 +306,9 @@ public class UserSettings extends SettingsPreferenceFragment
    public void onDestroy() {
        super.onDestroy();

-        if (!mUserCaps.mEnabled) return;
+        if (!mUserCaps.mEnabled) {
+            return;
+        }

        getActivity().unregisterReceiver(mUserChangeReceiver);
    }
@@ -285,6 +327,20 @@ public class UserSettings extends SettingsPreferenceFragment
        super.startActivityForResult(intent, requestCode);
    }

+    @Override
+    public boolean onPreferenceTreeClick(Preference preference) {
+        if (mAutoSyncDataPreferenceController.handlePreferenceTreeClick(preference)) {
+            return true;
+        }
+        if (mAutoSyncPersonalDataPreferenceController.handlePreferenceTreeClick(preference)) {
+            return true;
+        }
+        if (mAutoSyncWorkDataPreferenceController.handlePreferenceTreeClick(preference)) {
+            return true;
+        }
+        return super.onPreferenceTreeClick(preference);
+    }
+
    @Override
    public void onCreateOptionsMenu(Menu menu, MenuInflater inflater) {
        int pos = 0;
@@ -857,32 +913,24 @@ public class UserSettings extends SettingsPreferenceFragment
            loadIconsAsync(missingIcons);
        }

-        PreferenceScreen preferenceScreen = getPreferenceScreen();
-        preferenceScreen.removeAll();
-
-        // If profiles are supported, userPreferences will be added to the category labeled
-        // "User & Profiles", otherwise the category is skipped and elements are added directly
-        // to preferenceScreen
-        PreferenceGroup groupToAddUsers;
+        // Remove everything from mUserListCategory and add new users.
+        mUserListCategory.removeAll();
+        // If profiles are supported, mUserListCategory will have a special title
        if (mUserCaps.mCanAddRestrictedProfile) {
-            mUserListCategory.removeAll();
-            mUserListCategory.setOrder(Preference.DEFAULT_ORDER);
-            preferenceScreen.addPreference(mUserListCategory);
-            groupToAddUsers = mUserListCategory;
+            mUserListCategory.setTitle(R.string.user_list_title);
        } else {
-            groupToAddUsers = preferenceScreen;
+            mUserListCategory.setTitle(null);
        }
+
        for (UserPreference userPreference : userPreferences) {
            userPreference.setOrder(Preference.DEFAULT_ORDER);
-            groupToAddUsers.addPreference(userPreference);
+            mUserListCategory.addPreference(userPreference);
        }

        // Append Add user to the end of the list
        if ((mUserCaps.mCanAddUser || mUserCaps.mDisallowAddUserSetByAdmin) &&
                Utils.isDeviceProvisioned(getActivity())) {
            boolean moreUsers = mUserManager.canAddMoreUsers();
-            mAddUser.setOrder(Preference.DEFAULT_ORDER);
-            preferenceScreen.addPreference(mAddUser);
            mAddUser.setEnabled(moreUsers && !mAddingUser);
            if (!moreUsers) {
                mAddUser.setSummary(getString(R.string.user_add_max_count, getMaxRealUsers()));