src/com.example.android.apprestrictions/CustomRestrictionsFragment.java

/*
 * Copyright (C) 2013 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.example.android.apprestrictions;

import android.app.Activity;
import android.content.Context;
import android.content.Intent;
import android.content.RestrictionEntry;
import android.os.Bundle;
import android.os.UserManager;
import android.preference.CheckBoxPreference;
import android.preference.ListPreference;
import android.preference.MultiSelectListPreference;
import android.preference.Preference;
import android.preference.PreferenceFragment;

import java.util.ArrayList;
import java.util.Collections;
import java.util.HashSet;
import java.util.List;
import java.util.Set;

/**
 * This fragment is included in {@code CustomRestrictionsActivity}.  It demonstrates how an app
 * can integrate its own custom app restriction settings with the restricted profile feature.
 *
 * This sample app maintains custom app restriction settings in shared preferences.  Your app
 * can use other methods to maintain the settings.  When this activity is invoked
 * (from Settings > Users > Restricted Profile), the shared preferences are used to initialize
 * the custom configuration on the user interface.
 *
 * Three sample input types are shown: checkbox, single-choice, and multi-choice.  When the
 * settings are modified by the user, the corresponding restriction entries are saved in the
 * platform.  The saved restriction entries are retrievable when the app is launched under a
 * restricted profile.
 */
public class CustomRestrictionsFragment extends PreferenceFragment
        implements Preference.OnPreferenceChangeListener {

    // Shared preference key for the boolean restriction.
    private static final String KEY_BOOLEAN_PREF = "pref_boolean";
    // Shared preference key for the single-select restriction.
    private static final String KEY_CHOICE_PREF = "pref_choice";
    // Shared preference key for the multi-select restriction.
    private static final String KEY_MULTI_PREF = "pref_multi";


    private List<RestrictionEntry> mRestrictions;
    private Bundle mRestrictionsBundle;

    // Shared preferences for each of the sample input types.
    private CheckBoxPreference mBooleanPref;
    private ListPreference mChoicePref;
    private MultiSelectListPreference mMultiPref;

    // Restriction entries for each of the sample input types.
    private RestrictionEntry mBooleanEntry;
    private RestrictionEntry mChoiceEntry;
    private RestrictionEntry mMultiEntry;

    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        addPreferencesFromResource(R.xml.custom_prefs);

        // This sample app uses shared preferences to maintain app restriction settings.  Your app
        // can use other methods to maintain the settings.
        mBooleanPref = (CheckBoxPreference) findPreference(KEY_BOOLEAN_PREF);
        mChoicePref = (ListPreference) findPreference(KEY_CHOICE_PREF);
        mMultiPref = (MultiSelectListPreference) findPreference(KEY_MULTI_PREF);

        mBooleanPref.setOnPreferenceChangeListener(this);
        mChoicePref.setOnPreferenceChangeListener(this);
        mMultiPref.setOnPreferenceChangeListener(this);

        setRetainInstance(true);
    }

    @Override
    public void onActivityCreated(Bundle savedInstanceState) {
        super.onActivityCreated(savedInstanceState);
        final Activity activity = getActivity();

        // BEGIN_INCLUDE (GET_CURRENT_RESTRICTIONS)
        // Existing app restriction settings, if exist, can be retrieved from the Bundle.
        mRestrictionsBundle =
                activity.getIntent().getBundleExtra(Intent.EXTRA_RESTRICTIONS_BUNDLE);

        if (mRestrictionsBundle == null) {
            mRestrictionsBundle =
                    ((UserManager) activity.getSystemService(Context.USER_SERVICE))
                            .getApplicationRestrictions(activity.getPackageName());
        }

        if (mRestrictionsBundle == null) {
            mRestrictionsBundle = new Bundle();
        }

        mRestrictions = activity.getIntent().getParcelableArrayListExtra(
                Intent.EXTRA_RESTRICTIONS_LIST);
        // END_INCLUDE (GET_CURRENT_RESTRICTIONS)

        // Transfers the saved values into the preference hierarchy.
        if (mRestrictions != null) {
            for (RestrictionEntry entry : mRestrictions) {
                if (entry.getKey().equals(GetRestrictionsReceiver.KEY_BOOLEAN)) {
                    mBooleanPref.setChecked(entry.getSelectedState());
                    mBooleanEntry = entry;
                } else if (entry.getKey().equals(GetRestrictionsReceiver.KEY_CHOICE)) {
                    mChoicePref.setValue(entry.getSelectedString());
                    mChoiceEntry = entry;
                } else if (entry.getKey().equals(GetRestrictionsReceiver.KEY_MULTI_SELECT)) {
                    HashSet<String> set = new HashSet<>();
                    Collections.addAll(set, entry.getAllSelectedStrings());
                    mMultiPref.setValues(set);
                    mMultiEntry = entry;
                }
            }
        } else {
            mRestrictions = new ArrayList<>();

            // Initializes the boolean restriction entry and updates its corresponding shared
            // preference value.
            mBooleanEntry = new RestrictionEntry(GetRestrictionsReceiver.KEY_BOOLEAN,
                    mRestrictionsBundle.getBoolean(GetRestrictionsReceiver.KEY_BOOLEAN, false));
            mBooleanEntry.setType(RestrictionEntry.TYPE_BOOLEAN);
            mBooleanPref.setChecked(mBooleanEntry.getSelectedState());

            // Initializes the single choice restriction entry and updates its corresponding
            // shared preference value.
            mChoiceEntry = new RestrictionEntry(GetRestrictionsReceiver.KEY_CHOICE,
                    mRestrictionsBundle.getString(GetRestrictionsReceiver.KEY_CHOICE));
            mChoiceEntry.setType(RestrictionEntry.TYPE_CHOICE);
            mChoicePref.setValue(mChoiceEntry.getSelectedString());

            // Initializes the multi-select restriction entry and updates its corresponding
            // shared preference value.
            mMultiEntry = new RestrictionEntry(GetRestrictionsReceiver.KEY_MULTI_SELECT,
                    mRestrictionsBundle.getStringArray(
                            GetRestrictionsReceiver.KEY_MULTI_SELECT));
            mMultiEntry.setType(RestrictionEntry.TYPE_MULTI_SELECT);
            if (mMultiEntry.getAllSelectedStrings() != null) {
                HashSet<String> set = new HashSet<>();
                final String[] values = mRestrictionsBundle.getStringArray(
                        GetRestrictionsReceiver.KEY_MULTI_SELECT);
                if (values != null) {
                    Collections.addAll(set, values);
                }
                mMultiPref.setValues(set);
            }
            mRestrictions.add(mBooleanEntry);
            mRestrictions.add(mChoiceEntry);
            mRestrictions.add(mMultiEntry);
        }
        // Prepares result to be passed back to the Settings app when the custom restrictions
        // activity finishes.
        Intent intent = new Intent(getActivity().getIntent());
        intent.putParcelableArrayListExtra(Intent.EXTRA_RESTRICTIONS_LIST,
                new ArrayList<>(mRestrictions));
        getActivity().setResult(Activity.RESULT_OK, intent);
    }

    @Override
    public boolean onPreferenceChange(Preference preference, Object newValue) {
        if (preference == mBooleanPref) {
            mBooleanEntry.setSelectedState((Boolean) newValue);
        } else if (preference == mChoicePref) {
            mChoiceEntry.setSelectedString((String) newValue);
        } else if (preference == mMultiPref && newValue instanceof Set) {
            // newValue is a Set<String>, skip the lint warning.
            //noinspection unchecked
            String[] selectedStrings = new String[((Set<String>) newValue).size()];
            int i = 0;
            //noinspection unchecked
            for (String value : (Set<String>) newValue) {
                selectedStrings[i++] = value;
            }
            mMultiEntry.setAllSelectedStrings(selectedStrings);
        }

        // Saves all the app restriction configuration changes from the custom activity.
        Intent intent = new Intent(getActivity().getIntent());
        intent.putParcelableArrayListExtra(Intent.EXTRA_RESTRICTIONS_LIST,
                new ArrayList<>(mRestrictions));
        getActivity().setResult(Activity.RESULT_OK, intent);
        return true;
    }
}