settings/users/AppRestrictionsFragment.java

/*
 * 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.tv.settings.users;

import android.app.Activity;
import android.app.AppGlobals;
import android.app.tvsettings.TvSettingsEnums;
import android.content.ActivityNotFoundException;
import android.content.BroadcastReceiver;
import android.content.Context;
import android.content.Intent;
import android.content.IntentFilter;
import android.content.RestrictionEntry;
import android.content.RestrictionsManager;
import android.content.pm.ActivityInfo;
import android.content.pm.ApplicationInfo;
import android.content.pm.IPackageManager;
import android.content.pm.PackageInfo;
import android.content.pm.PackageManager;
import android.content.pm.ResolveInfo;
import android.content.pm.UserInfo;
import android.graphics.Color;
import android.graphics.drawable.ColorDrawable;
import android.graphics.drawable.Drawable;
import android.os.AsyncTask;
import android.os.Bundle;
import android.os.RemoteException;
import android.os.UserHandle;
import android.os.UserManager;
import android.text.TextUtils;
import android.util.EventLog;
import android.util.Log;
import android.view.View;
import android.widget.Checkable;
import android.widget.CompoundButton;
import android.widget.Switch;

import androidx.annotation.NonNull;
import androidx.collection.ArrayMap;
import androidx.preference.ListPreference;
import androidx.preference.MultiSelectListPreference;
import androidx.preference.Preference;
import androidx.preference.PreferenceGroup;
import androidx.preference.PreferenceScreen;
import androidx.preference.PreferenceViewHolder;
import androidx.preference.SwitchPreference;

import com.android.settingslib.users.AppRestrictionsHelper;
import com.android.tv.settings.R;
import com.android.tv.settings.SettingsPreferenceFragment;
import com.android.tv.settings.util.SafeIntents;

import java.util.ArrayList;
import java.util.Arrays;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Map;
import java.util.Set;
import java.util.StringTokenizer;
import java.util.stream.Collectors;
import java.util.stream.IntStream;

/**
 * The screen in TV settings to configure restricted profile app & content access.
 */
public class AppRestrictionsFragment extends SettingsPreferenceFragment implements
        Preference.OnPreferenceChangeListener,
        AppRestrictionsHelper.OnDisableUiForPackageListener {

    private static final String TAG = AppRestrictionsFragment.class.getSimpleName();

    private static final boolean DEBUG = false;

    private static final String PKG_PREFIX = "pkg_";
    private static final String ACTIVITY_PREFIX = "activity_";

    private static final Drawable BLANK_DRAWABLE = new ColorDrawable(Color.TRANSPARENT);

    private PackageManager mPackageManager;
    private UserManager mUserManager;
    private IPackageManager mIPm;
    private UserHandle mUser;
    private PackageInfo mSysPackageInfo;

    private AppRestrictionsHelper mHelper;

    private PreferenceGroup mAppList;

    private static final int MAX_APP_RESTRICTIONS = 100;

    private static final String DELIMITER = ";";

    /** Key for extra passed in from calling fragment for the userId of the user being edited */
    private static final String EXTRA_USER_ID = "user_id";

    /** Key for extra passed in from calling fragment to indicate if this is a newly created user */
    private static final String EXTRA_NEW_USER = "new_user";

    /**
     * Key for extra passed in from calling fragment to indicate we should exit after updating
     * apps.
     */
    private static final String EXTRA_EXIT_AFTER_UPDATE = "exit_after_update";

    private boolean mFirstTime = true;
    private boolean mNewUser;
    private boolean mExitAfterUpdate;
    private boolean mAppListChanged;
    private boolean mRestrictedProfile;

    private static final int CUSTOM_REQUEST_CODE_START = 1000;
    private int mCustomRequestCode = CUSTOM_REQUEST_CODE_START;

    private static final String STATE_CUSTOM_REQUEST_MAP_KEYS = "customRequestMapKeys";
    private static final String STATE_CUSTOM_REQUEST_MAP_VALUES = "customRequestMapValues";
    private Map<Integer, String> mCustomRequestMap = new ArrayMap<>();

    private AsyncTask mAppLoadingTask;

    private BroadcastReceiver mUserBackgrounding = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            // Update the user's app selection right away without waiting for a pause
            // onPause() might come in too late, causing apps to disappear after broadcasts
            // have been scheduled during user startup.
            if (mAppListChanged) {
                if (DEBUG) Log.d(TAG, "User backgrounding, update app list");
                mHelper.applyUserAppsStates(AppRestrictionsFragment.this);
                if (DEBUG) Log.d(TAG, "User backgrounding, done updating app list");
            }
        }
    };

    private BroadcastReceiver mPackageObserver = new BroadcastReceiver() {
        @Override
        public void onReceive(Context context, Intent intent) {
            onPackageChanged(intent);
        }
    };

    private static class AppRestrictionsPreference extends PreferenceGroup {
        private final Listener mListener = new Listener();
        private ArrayList<RestrictionEntry> mRestrictions;
        private boolean mImmutable;
        private boolean mChecked;
        private boolean mCheckedSet;

        AppRestrictionsPreference(Context context) {
            super(context, null, 0, R.style.LeanbackPreference_SwitchPreference);
        }

        void setRestrictions(ArrayList<RestrictionEntry> restrictions) {
            this.mRestrictions = restrictions;
        }

        void setImmutable(boolean immutable) {
            this.mImmutable = immutable;
        }

        boolean isImmutable() {
            return mImmutable;
        }

        ArrayList<RestrictionEntry> getRestrictions() {
            return mRestrictions;
        }

        public void setChecked(boolean checked) {
            // Always persist/notify the first time; don't assume the field's default of false.
            final boolean changed = mChecked != checked;
            if (changed || !mCheckedSet) {
                mChecked = checked;
                mCheckedSet = true;
                persistBoolean(checked);
                if (changed) {
                    notifyDependencyChange(shouldDisableDependents());
                    notifyChanged();
                    notifyHierarchyChanged();
                }
            }
        }

        @Override
        public int getPreferenceCount() {
            if (isChecked()) {
                return super.getPreferenceCount();
            } else {
                return 0;
            }
        }

        public boolean isChecked() {
            return mChecked;
        }

        @Override
        public void onBindViewHolder(PreferenceViewHolder holder) {
            super.onBindViewHolder(holder);
            View switchView = holder.findViewById(android.R.id.switch_widget);
            syncSwitchView(switchView);
        }

        private void syncSwitchView(View view) {
            if (view instanceof Switch) {
                final Switch switchView = (Switch) view;
                switchView.setOnCheckedChangeListener(null);
            }
            if (view instanceof Checkable) {
                ((Checkable) view).setChecked(mChecked);
            }
            if (view instanceof Switch) {
                final Switch switchView = (Switch) view;
                switchView.setOnCheckedChangeListener(mListener);
            }
        }

        private class Listener implements CompoundButton.OnCheckedChangeListener {
            @Override
            public void onCheckedChanged(CompoundButton buttonView, boolean isChecked) {
                if (!callChangeListener(isChecked)) {
                    // Listener didn't like it, change it back.
                    // CompoundButton will make sure we don't recurse.
                    buttonView.setChecked(!isChecked);
                    return;
                }

                AppRestrictionsPreference.this.setChecked(isChecked);
            }
        }
    }

    public static void prepareArgs(@NonNull Bundle bundle, int userId, boolean newUser,
                                   boolean exitAfterUpdate) {
        bundle.putInt(EXTRA_USER_ID, userId);
        bundle.putBoolean(EXTRA_NEW_USER, newUser);
        bundle.putBoolean(EXTRA_EXIT_AFTER_UPDATE, exitAfterUpdate);
    }

    public static AppRestrictionsFragment newInstance(int userId, boolean newUser,
                                   boolean exitAfterUpdate) {
        final Bundle args = new Bundle(3);
        prepareArgs(args, userId, newUser, exitAfterUpdate);
        AppRestrictionsFragment fragment = new AppRestrictionsFragment();
        fragment.setArguments(args);
        return fragment;
    }

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState != null) {
            mUser = new UserHandle(savedInstanceState.getInt(EXTRA_USER_ID));
            final ArrayList<Integer> keys =
                    savedInstanceState.getIntegerArrayList(STATE_CUSTOM_REQUEST_MAP_KEYS);
            final List<String> values = Arrays.asList(
                    savedInstanceState.getStringArray(STATE_CUSTOM_REQUEST_MAP_VALUES));
            mCustomRequestMap.putAll(IntStream.range(0, keys.size()).boxed().collect(
                    Collectors.toMap(keys::get, values::get)));
        } else {
            Bundle args = getArguments();
            if (args != null) {
                if (args.containsKey(EXTRA_USER_ID)) {
                    mUser = new UserHandle(args.getInt(EXTRA_USER_ID));
                }
                mNewUser = args.getBoolean(EXTRA_NEW_USER, false);
                mExitAfterUpdate = args.getBoolean(EXTRA_EXIT_AFTER_UPDATE, false);
            }
        }

        if (mUser == null) {
            mUser = android.os.Process.myUserHandle();
        }

        mHelper = new AppRestrictionsHelper(getContext(), mUser);
        mHelper.setLeanback(true);
        mPackageManager = getActivity().getPackageManager();
        mIPm = AppGlobals.getPackageManager();
        mUserManager = (UserManager) getActivity().getSystemService(Context.USER_SERVICE);
        mRestrictedProfile = mUserManager.getUserInfo(mUser.getIdentifier()).isRestricted();
        try {
            mSysPackageInfo = mPackageManager.getPackageInfo("android",
                    PackageManager.GET_SIGNATURES);
        } catch (PackageManager.NameNotFoundException nnfe) {
            Log.e(TAG, "Could not find system package signatures", nnfe);
        }
        mAppList = getAppPreferenceGroup();
        mAppList.setOrderingAsAdded(false);
    }

    @Override
    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
        final PreferenceScreen screen = getPreferenceManager()
                .createPreferenceScreen(getPreferenceManager().getContext());
        screen.setTitle(R.string.restricted_profile_configure_apps_title);
        setPreferenceScreen(screen);
    }

    @Override
    public void onSaveInstanceState(Bundle outState) {
        super.onSaveInstanceState(outState);
        outState.putInt(EXTRA_USER_ID, mUser.getIdentifier());
        final ArrayList<Integer> keys = new ArrayList<>(mCustomRequestMap.keySet());
        final List<String> values =
                keys.stream().map(mCustomRequestMap::get).collect(Collectors.toList());
        outState.putIntegerArrayList(STATE_CUSTOM_REQUEST_MAP_KEYS, keys);
        outState.putStringArray(STATE_CUSTOM_REQUEST_MAP_VALUES,
                values.toArray(new String[values.size()]));
    }

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

        getActivity().registerReceiver(mUserBackgrounding,
                new IntentFilter(Intent.ACTION_USER_BACKGROUND));
        IntentFilter packageFilter = new IntentFilter();
        packageFilter.addAction(Intent.ACTION_PACKAGE_ADDED);
        packageFilter.addAction(Intent.ACTION_PACKAGE_REMOVED);
        packageFilter.addDataScheme("package");
        getActivity().registerReceiver(mPackageObserver, packageFilter);

        mAppListChanged = false;
        if (mAppLoadingTask == null || mAppLoadingTask.getStatus() == AsyncTask.Status.FINISHED) {
            mAppLoadingTask = new AppLoadingTask().execute();
        }
    }

    @Override
    public void onPause() {
        super.onPause();
        mNewUser = false;
        getActivity().unregisterReceiver(mUserBackgrounding);
        getActivity().unregisterReceiver(mPackageObserver);
        if (mAppListChanged) {
            new AsyncTask<Void, Void, Void>() {
                @Override
                protected Void doInBackground(Void... params) {
                    mHelper.applyUserAppsStates(AppRestrictionsFragment.this);
                    return null;
                }
            }.execute();
        }
    }

    @Override
    public void onDestroyView() {
        if (mExitAfterUpdate) {
            requireActivity().setResult(Activity.RESULT_OK);
            requireActivity().finish();
        }
        super.onDestroyView();
    }

    private void onPackageChanged(Intent intent) {
        String action = intent.getAction();
        String packageName = intent.getData().getSchemeSpecificPart();
        // Package added, check if the preference needs to be enabled
        AppRestrictionsPreference pref = (AppRestrictionsPreference)
                findPreference(getKeyForPackage(packageName));
        if (pref == null) return;

        if ((Intent.ACTION_PACKAGE_ADDED.equals(action) && pref.isChecked())
                || (Intent.ACTION_PACKAGE_REMOVED.equals(action) && !pref.isChecked())) {
            pref.setEnabled(true);
        }
    }

    private PreferenceGroup getAppPreferenceGroup() {
        return getPreferenceScreen();
    }

    @Override
    public void onDisableUiForPackage(String packageName) {
        AppRestrictionsPreference pref = (AppRestrictionsPreference) findPreference(
                getKeyForPackage(packageName));
        if (pref != null) {
            pref.setEnabled(false);
        }
    }

    private class AppLoadingTask extends AsyncTask<Void, Void, Void> {

        @Override
        protected Void doInBackground(Void... params) {
            mHelper.fetchAndMergeApps();
            return null;
        }

        @Override
        protected void onPostExecute(Void result) {
            populateApps();
        }
    }

    private boolean isPlatformSigned(PackageInfo pi) {
        return (pi != null && pi.signatures != null &&
                mSysPackageInfo.signatures[0].equals(pi.signatures[0]));
    }

    private boolean isAppEnabledForUser(PackageInfo pi) {
        if (pi == null) return false;
        final int flags = pi.applicationInfo.flags;
        final int privateFlags = pi.applicationInfo.privateFlags;
        // Return true if it is installed and not hidden
        return ((flags& ApplicationInfo.FLAG_INSTALLED) != 0
                && (privateFlags&ApplicationInfo.PRIVATE_FLAG_HIDDEN) == 0);
    }

    private void populateApps() {
        final Context context = getActivity();
        if (context == null) return;
        final PackageManager pm = mPackageManager;
        final int userId = mUser.getIdentifier();

        // Check if the user was removed in the meantime.
        if (getExistingUser(mUserManager, mUser) == null) {
            return;
        }
        mAppList.removeAll();
        addLocationAppRestrictionsPreference();
        Intent restrictionsIntent = new Intent(Intent.ACTION_GET_RESTRICTION_ENTRIES);
        final List<ResolveInfo> receivers = pm.queryBroadcastReceivers(restrictionsIntent, 0);
        for (AppRestrictionsHelper.SelectableAppInfo app : mHelper.getVisibleApps()) {
            String packageName = app.packageName;
            if (packageName == null) continue;
            try {
                int enabledState = pm.getApplicationEnabledSetting(packageName);
                if (enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED ||
                        enabledState == PackageManager.COMPONENT_ENABLED_STATE_DISABLED_USER) {
                    mHelper.setPackageSelected(packageName, false);
                    continue;
                }
            } catch(IllegalArgumentException e) {
                Log.e(TAG, "Package " + packageName + " is not found");
                continue;
            }

            final boolean isSettingsApp = packageName.equals(context.getPackageName());
            AppRestrictionsPreference p =
                    new AppRestrictionsPreference(getPreferenceManager().getContext());
            final boolean hasSettings = resolveInfoListHasPackage(receivers, packageName);
            if (isSettingsApp) {
                // Settings app should be available to restricted user
                mHelper.setPackageSelected(packageName, true);
                continue;
            }
            PackageInfo pi = null;
            try {
                pi = mIPm.getPackageInfo(packageName,
                        PackageManager.MATCH_ANY_USER
                                | PackageManager.GET_SIGNATURES, userId);
            } catch (RemoteException e) {
                // Ignore
            }
            if (pi == null) {
                continue;
            }
            if (mRestrictedProfile && isAppUnsupportedInRestrictedProfile(pi)) {
                continue;
            }
            p.setIcon(app.icon != null ? app.icon.mutate() : null);
            p.setChecked(false);
            p.setTitle(app.activityName);
            p.setKey(getKeyForPackage(packageName));
            p.setPersistent(false);
            p.setOnPreferenceChangeListener(this);
            p.setSummary(getPackageSummary(pi, app));
            if (pi.requiredForAllUsers || isPlatformSigned(pi)) {
                p.setChecked(true);
                p.setImmutable(true);
                // If the app is required and has no restrictions, skip showing it
                if (!hasSettings) continue;
            } else if (!mNewUser && isAppEnabledForUser(pi)) {
                p.setChecked(true);
            }
            if (app.primaryEntry == null && hasSettings) {
                requestRestrictionsForApp(packageName, p);
            }
            if (app.primaryEntry != null) {
                p.setImmutable(true);
                p.setChecked(mHelper.isPackageSelected(packageName));
            }
            p.setOrder(MAX_APP_RESTRICTIONS * (mAppList.getPreferenceCount() + 2));
            mHelper.setPackageSelected(packageName, p.isChecked());
            mAppList.addPreference(p);
        }
        mAppListChanged = true;
        // If this is the first time for a new profile, install/uninstall default apps for profile
        // to avoid taking the hit in onPause(), which can cause race conditions on user switch.
        if (mNewUser && mFirstTime) {
            mFirstTime = false;
            mHelper.applyUserAppsStates(this);
        }
    }

    private String getPackageSummary(PackageInfo pi, AppRestrictionsHelper.SelectableAppInfo app) {
        // Check for 3 cases:
        // - Primary entry that can see primary user accounts
        // - Primary entry that cannot see primary user accounts
        // - Primary entry that can see primary user accounts
        // Otherwise no summary is returned
        if (app.primaryEntry != null) {
            if (mRestrictedProfile && pi.restrictedAccountType != null) {
                return getString(R.string.app_sees_restricted_accounts_and_controlled_by,
                        app.primaryEntry.activityName);
            }
            return getString(R.string.user_restrictions_controlled_by,
                    app.primaryEntry.activityName);
        } else if (pi.restrictedAccountType != null) {
            return getString(R.string.app_sees_restricted_accounts);
        }
        return null;
    }

    private static boolean isAppUnsupportedInRestrictedProfile(PackageInfo pi) {
        return pi.requiredAccountType != null && pi.restrictedAccountType == null;
    }

    private void addLocationAppRestrictionsPreference() {
        AppRestrictionsPreference p =
                new AppRestrictionsPreference(getPreferenceManager().getContext());
        String packageName = getContext().getPackageName();
        p.setIcon(R.drawable.ic_location_on);
        p.setKey(getKeyForPackage(packageName));
        ArrayList<RestrictionEntry> restrictions = RestrictionUtils.getRestrictions(
                getActivity(), mUser);
        RestrictionEntry locationRestriction = restrictions.get(0);
        p.setTitle(locationRestriction.getTitle());
        p.setRestrictions(restrictions);
        p.setSummary(locationRestriction.getDescription());
        p.setChecked(locationRestriction.getSelectedState());
        p.setPersistent(false);
        p.setOrder(MAX_APP_RESTRICTIONS);
        mAppList.addPreference(p);
    }

    private String getKeyForPackage(String packageName) {
        return PKG_PREFIX + packageName;
    }

    private String getKeyForPackageActivity(String packageName) {
        return ACTIVITY_PREFIX + packageName;
    }

    private String getPackageFromKey(String key) {
        if (key.startsWith(PKG_PREFIX)) {
            return key.substring(PKG_PREFIX.length());
        } else if (key.startsWith(ACTIVITY_PREFIX)) {
            return key.substring(ACTIVITY_PREFIX.length());
        } else {
            throw new IllegalArgumentException("Tried to extract package from wrong key: " + key);
        }
    }

    private boolean resolveInfoListHasPackage(List<ResolveInfo> receivers, String packageName) {
        for (ResolveInfo info : receivers) {
            if (info.activityInfo.packageName.equals(packageName)) {
                return true;
            }
        }
        return false;
    }

    private void updateAllEntries(String prefKey, boolean checked) {
        for (int i = 0; i < mAppList.getPreferenceCount(); i++) {
            Preference pref = mAppList.getPreference(i);
            if (pref instanceof AppRestrictionsPreference) {
                if (prefKey.equals(pref.getKey())) {
                    ((AppRestrictionsPreference) pref).setChecked(checked);
                }
            }
        }
    }

    private void assertSafeToStartCustomActivity(Intent intent, String packageName) {
        EventLog.writeEvent(0x534e4554, "223578534", -1 /* UID */, "");
        ResolveInfo resolveInfo = mPackageManager.resolveActivity(
                intent, PackageManager.MATCH_DEFAULT_ONLY);

        if (resolveInfo == null) {
            throw new ActivityNotFoundException("No result for resolving " + intent);
        }
        // Prevent potential privilege escalation
        ActivityInfo activityInfo = resolveInfo.activityInfo;
        if (!packageName.equals(activityInfo.packageName)) {
            throw new SecurityException("Application " + packageName
                    + " is not allowed to start activity " + intent);
        }
    }

    @Override
    public boolean onPreferenceTreeClick(Preference preference) {
        if (preference instanceof AppRestrictionsPreference) {
            AppRestrictionsPreference pref = (AppRestrictionsPreference) preference;
            if (!pref.isImmutable()) {
                pref.setChecked(!pref.isChecked());
                final String packageName = getPackageFromKey(pref.getKey());
                // Settings/Location is handled as a top-level entry
                if (packageName.equals(getActivity().getPackageName())) {
                    pref.getRestrictions().get(0).setSelectedState(pref.isChecked());
                    RestrictionUtils.setRestrictions(getActivity(), pref.getRestrictions(), mUser);
                    return true;
                }
                mHelper.setPackageSelected(packageName, pref.isChecked());
                mAppListChanged = true;
                // If it's not a restricted profile, apply the changes immediately
                if (!mRestrictedProfile) {
                    mHelper.applyUserAppState(packageName, pref.isChecked(), this);
                }
                updateAllEntries(pref.getKey(), pref.isChecked());
            }
            return true;
        } else if (preference.getIntent() != null) {

            try {
                assertSafeToStartCustomActivity(preference.getIntent(),
                    getPackageFromKey(preference.getKey()));
            } catch (ActivityNotFoundException | SecurityException e) {
                // return without startActivity
                Log.e(TAG, "Cannot start restrictionsIntent " + e);
                EventLog.writeEvent(0x534e4554, "200688991", -1 /* UID */, "");
                return true;
            }
            try {
                startActivityForResult(preference.getIntent(),
                        generateCustomActivityRequestCode(preference));
            } catch (ActivityNotFoundException e) {
                Log.e(TAG, "Activity not found", e);
            }
            return true;
        } else {
            return super.onPreferenceTreeClick(preference);
        }
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        String key = preference.getKey();
        if (key != null && key.contains(DELIMITER)) {
            StringTokenizer st = new StringTokenizer(key, DELIMITER);
            final String packageName = st.nextToken();
            final String restrictionKey = st.nextToken();
            AppRestrictionsPreference appPref = (AppRestrictionsPreference)
                    mAppList.findPreference(getKeyForPackage(packageName));
            ArrayList<RestrictionEntry> restrictions = appPref.getRestrictions();
            if (restrictions != null) {
                for (RestrictionEntry entry : restrictions) {
                    if (entry.getKey().equals(restrictionKey)) {
                        switch (entry.getType()) {
                            case RestrictionEntry.TYPE_BOOLEAN:
                                entry.setSelectedState((Boolean) newValue);
                                break;
                            case RestrictionEntry.TYPE_CHOICE:
                            case RestrictionEntry.TYPE_CHOICE_LEVEL:
                                ListPreference listPref = (ListPreference) preference;
                                entry.setSelectedString((String) newValue);
                                String readable = findInArray(entry.getChoiceEntries(),
                                        entry.getChoiceValues(), (String) newValue);
                                listPref.setSummary(readable);
                                break;
                            case RestrictionEntry.TYPE_MULTI_SELECT:
                                // noinspection unchecked
                                Set<String> set = (Set<String>) newValue;
                                String [] selectedValues = new String[set.size()];
                                set.toArray(selectedValues);
                                entry.setAllSelectedStrings(selectedValues);
                                break;
                            default:
                                continue;
                        }
                        mUserManager.setApplicationRestrictions(packageName,
                                RestrictionsManager.convertRestrictionsToBundle(restrictions),
                                mUser);
                        break;
                    }
                }
            }
        }
        return true;
    }

    /**
     * Send a broadcast to the app to query its restrictions
     * @param packageName package name of the app with restrictions
     * @param preference the preference item for the app toggle
     */
    private void requestRestrictionsForApp(String packageName,
            AppRestrictionsPreference preference) {
        Bundle oldEntries =
                mUserManager.getApplicationRestrictions(packageName, mUser);
        Intent intent = new Intent(Intent.ACTION_GET_RESTRICTION_ENTRIES);
        intent.setPackage(packageName);
        intent.putExtra(Intent.EXTRA_RESTRICTIONS_BUNDLE, oldEntries);
        intent.addFlags(Intent.FLAG_INCLUDE_STOPPED_PACKAGES);
        getActivity().sendOrderedBroadcast(intent, null,
                new RestrictionsResultReceiver(packageName, preference),
                null, Activity.RESULT_OK, null, null);
    }

    private class RestrictionsResultReceiver extends BroadcastReceiver {

        private static final String CUSTOM_RESTRICTIONS_INTENT = Intent.EXTRA_RESTRICTIONS_INTENT;
        private final String mPackageName;
        private final AppRestrictionsPreference mPreference;

        RestrictionsResultReceiver(String packageName, AppRestrictionsPreference preference) {
            super();
            mPackageName = packageName;
            mPreference = preference;
        }

        @Override
        public void onReceive(Context context, Intent intent) {
            Bundle results = getResultExtras(true);
            final ArrayList<RestrictionEntry> restrictions = results != null
                    ? results.getParcelableArrayList(Intent.EXTRA_RESTRICTIONS_LIST) : null;
            Intent restrictionsIntent = results != null
                    ? results.getParcelable(CUSTOM_RESTRICTIONS_INTENT) : null;
            if (restrictions != null && restrictionsIntent == null) {
                onRestrictionsReceived(mPreference, restrictions);
                if (mRestrictedProfile) {
                    mUserManager.setApplicationRestrictions(mPackageName,
                            RestrictionsManager.convertRestrictionsToBundle(restrictions), mUser);
                }
            } else if (restrictionsIntent != null) {
                mPreference.setRestrictions(null);
                mPreference.removeAll();
                final Preference p = new Preference(mPreference.getContext());
                p.setKey(getKeyForPackageActivity(mPackageName));
                p.setIcon(BLANK_DRAWABLE);
                p.setTitle(R.string.restricted_profile_customize_restrictions);
                p.setIntent(SafeIntents.forCallback(restrictionsIntent));
                mPreference.addPreference(p);
            } else {
                Log.e(TAG, "No restrictions returned from " + mPackageName);
            }
        }
    }

    private void onRestrictionsReceived(AppRestrictionsPreference preference,
            ArrayList<RestrictionEntry> restrictions) {
        // Remove any earlier restrictions
        preference.removeAll();
        // Non-custom-activity case - expand the restrictions in-place
        int count = 1;
        final Context themedContext = getPreferenceManager().getContext();
        for (RestrictionEntry entry : restrictions) {
            Preference p = null;
            switch (entry.getType()) {
                case RestrictionEntry.TYPE_BOOLEAN:
                    p = new SwitchPreference(themedContext);
                    p.setTitle(entry.getTitle());
                    p.setSummary(entry.getDescription());
                    ((SwitchPreference)p).setChecked(entry.getSelectedState());
                    break;
                case RestrictionEntry.TYPE_CHOICE:
                case RestrictionEntry.TYPE_CHOICE_LEVEL:
                    p = new ListPreference(themedContext);
                    p.setTitle(entry.getTitle());
                    String value = entry.getSelectedString();
                    if (value == null) {
                        value = entry.getDescription();
                    }
                    p.setSummary(findInArray(entry.getChoiceEntries(), entry.getChoiceValues(),
                            value));
                    ((ListPreference)p).setEntryValues(entry.getChoiceValues());
                    ((ListPreference)p).setEntries(entry.getChoiceEntries());
                    ((ListPreference)p).setValue(value);
                    ((ListPreference)p).setDialogTitle(entry.getTitle());
                    break;
                case RestrictionEntry.TYPE_MULTI_SELECT:
                    p = new MultiSelectListPreference(themedContext);
                    p.setTitle(entry.getTitle());
                    ((MultiSelectListPreference)p).setEntryValues(entry.getChoiceValues());
                    ((MultiSelectListPreference)p).setEntries(entry.getChoiceEntries());
                    HashSet<String> set = new HashSet<>();
                    Collections.addAll(set, entry.getAllSelectedStrings());
                    ((MultiSelectListPreference)p).setValues(set);
                    ((MultiSelectListPreference)p).setDialogTitle(entry.getTitle());
                    break;
                case RestrictionEntry.TYPE_NULL:
                default:
            }
            if (p != null) {
                p.setPersistent(false);
                p.setOrder(preference.getOrder() + count);
                // Store the restrictions key string as a key for the preference
                p.setKey(getPackageFromKey(preference.getKey()) + DELIMITER + entry.getKey());
                preference.addPreference(p);
                p.setOnPreferenceChangeListener(AppRestrictionsFragment.this);
                p.setIcon(BLANK_DRAWABLE);
                count++;
            }
        }
        preference.setRestrictions(restrictions);
        if (count == 1 // No visible restrictions
                && preference.isImmutable()
                && preference.isChecked()) {
            // Special case of required app with no visible restrictions. Remove it
            mAppList.removePreference(preference);
        }
    }

    /**
     * Generates a request code that is stored in a map to retrieve the associated
     * AppRestrictionsPreference.
     */
    private int generateCustomActivityRequestCode(Preference preference) {
        mCustomRequestCode++;
        final String key = getKeyForPackage(getPackageFromKey(preference.getKey()));
        mCustomRequestMap.put(mCustomRequestCode, key);
        return mCustomRequestCode;
    }

    @Override
    public void onActivityResult(int requestCode, int resultCode, Intent data) {
        super.onActivityResult(requestCode, resultCode, data);

        final String key = mCustomRequestMap.get(requestCode);
        AppRestrictionsPreference pref = null;
        if (!TextUtils.isEmpty(key)) {
            pref = (AppRestrictionsPreference) findPreference(key);
        }
        if (pref == null) {
            Log.w(TAG, "Unknown requestCode " + requestCode);
            return;
        }

        if (resultCode == Activity.RESULT_OK) {
            String packageName = getPackageFromKey(pref.getKey());
            ArrayList<RestrictionEntry> list =
                    data.getParcelableArrayListExtra(Intent.EXTRA_RESTRICTIONS_LIST);
            Bundle bundle = data.getBundleExtra(Intent.EXTRA_RESTRICTIONS_BUNDLE);
            if (list != null) {
                // If there's a valid result, persist it to the user manager.
                pref.setRestrictions(list);
                mUserManager.setApplicationRestrictions(packageName,
                        RestrictionsManager.convertRestrictionsToBundle(list), mUser);
            } else if (bundle != null) {
                // If there's a valid result, persist it to the user manager.
                mUserManager.setApplicationRestrictions(packageName, bundle, mUser);
            }
        }
        // Remove request from the map
        mCustomRequestMap.remove(requestCode);
    }

    private String findInArray(String[] choiceEntries, String[] choiceValues,
            String selectedString) {
        for (int i = 0; i < choiceValues.length; i++) {
            if (choiceValues[i].equals(selectedString)) {
                return choiceEntries[i];
            }
        }
        return selectedString;
    }

    /**
     * Queries for the UserInfo of a user. Returns null if the user doesn't exist (was removed).
     * @param userManager Instance of UserManager
     * @param checkUser The user to check the existence of.
     * @return UserInfo of the user or null for non-existent user.
     */
    private static UserInfo getExistingUser(UserManager userManager, UserHandle checkUser) {
        final List<UserInfo> users = userManager.getAliveUsers();
        final int checkUserId = checkUser.getIdentifier();
        for (UserInfo user : users) {
            if (user.id == checkUserId) {
                return user;
            }
        }
        return null;
    }

    @Override
    protected int getPageId() {
        return TvSettingsEnums.APPS_SECURITY_RESTRICTIONS_PROFILE_ALLOWED_APPS;
    }
}