Home | History | Annotate | Download | only in settings 
      1 /*
      2  * Copyright (C) 2013 The Android Open Source Project
      3  *
      4  * Licensed under the Apache License, Version 2.0 (the "License");
      5  * you may not use this file except in compliance with the License.
      6  * You may obtain a copy of the License at
      7  *
      8  *      http://www.apache.org/licenses/LICENSE-2.0
      9  *
     10  * Unless required by applicable law or agreed to in writing, software
     11  * distributed under the License is distributed on an "AS IS" BASIS,
     12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
     13  * See the License for the specific language governing permissions and
     14  * limitations under the License.
     15  */
     16 
     17 package com.android.settings;
     18 
     19 import android.app.Activity;
     20 import android.content.BroadcastReceiver;
     21 import android.content.Context;
     22 import android.content.Intent;
     23 import android.content.IntentFilter;
     24 import android.content.RestrictionsManager;
     25 import android.os.Bundle;
     26 import android.os.PersistableBundle;
     27 import android.os.UserManager;
     28 
     29 /**
     30  * Base class for settings screens that should be pin protected when in restricted mode.
     31  * The constructor for this class will take the restriction key that this screen should be
     32  * locked by.  If {@link RestrictionsManager.hasRestrictionsProvider()} and
     33  * {@link UserManager.hasUserRestriction()}, then the user will have to enter the restrictions
     34  * pin before seeing the Settings screen.
     35  *
     36  * If this settings screen should be pin protected whenever
     37  * {@link RestrictionsManager.hasRestrictionsProvider()} returns true, pass in
     38  * {@link RESTRICT_IF_OVERRIDABLE} to the constructor instead of a restrictions key.
     39  */
     40 public class RestrictedSettingsFragment extends SettingsPreferenceFragment {
     41 
     42     protected static final String RESTRICT_IF_OVERRIDABLE = "restrict_if_overridable";
     43 
     44     // No RestrictedSettingsFragment screens should use this number in startActivityForResult.
     45     private static final int REQUEST_PIN_CHALLENGE = 12309;
     46 
     47     private static final String KEY_CHALLENGE_SUCCEEDED = "chsc";
     48     private static final String KEY_CHALLENGE_REQUESTED = "chrq";
     49 
     50     // If the restriction PIN is entered correctly.
     51     private boolean mChallengeSucceeded;
     52     private boolean mChallengeRequested;
     53 
     54     private UserManager mUserManager;
     55     private RestrictionsManager mRestrictionsManager;
     56 
     57     private final String mRestrictionKey;
     58 
     59     // Receiver to clear pin status when the screen is turned off.
     60     private BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
     61         @Override
     62         public void onReceive(Context context, Intent intent) {
     63             if (!mChallengeRequested) {
     64                 mChallengeSucceeded = false;
     65                 mChallengeRequested = false;
     66             }
     67         }
     68     };
     69 
     70     /**
     71      * @param restrictionKey The restriction key to check before pin protecting
     72      *            this settings page. Pass in {@link RESTRICT_IF_OVERRIDABLE} if it should
     73      *            be protected whenever a restrictions provider is set. Pass in
     74      *            null if it should never be protected.
     75      */
     76     public RestrictedSettingsFragment(String restrictionKey) {
     77         mRestrictionKey = restrictionKey;
     78     }
     79 
     80     @Override
     81     public void onCreate(Bundle icicle) {
     82         super.onCreate(icicle);
     83 
     84         mRestrictionsManager = (RestrictionsManager) getSystemService(Context.RESTRICTIONS_SERVICE);
     85         mUserManager = (UserManager) getSystemService(Context.USER_SERVICE);
     86 
     87         if (icicle != null) {
     88             mChallengeSucceeded = icicle.getBoolean(KEY_CHALLENGE_SUCCEEDED, false);
     89             mChallengeRequested = icicle.getBoolean(KEY_CHALLENGE_REQUESTED, false);
     90         }
     91 
     92         IntentFilter offFilter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
     93         offFilter.addAction(Intent.ACTION_USER_PRESENT);
     94         getActivity().registerReceiver(mScreenOffReceiver, offFilter);
     95     }
     96 
     97     @Override
     98     public void onSaveInstanceState(Bundle outState) {
     99         super.onSaveInstanceState(outState);
    100 
    101         if (getActivity().isChangingConfigurations()) {
    102             outState.putBoolean(KEY_CHALLENGE_REQUESTED, mChallengeRequested);
    103             outState.putBoolean(KEY_CHALLENGE_SUCCEEDED, mChallengeSucceeded);
    104         }
    105     }
    106 
    107     @Override
    108     public void onResume() {
    109         super.onResume();
    110 
    111         if (shouldBeProviderProtected(mRestrictionKey)) {
    112             ensurePin();
    113         }
    114     }
    115 
    116     @Override
    117     public void onDestroy() {
    118         getActivity().unregisterReceiver(mScreenOffReceiver);
    119         super.onDestroy();
    120     }
    121 
    122     @Override
    123     public void onActivityResult(int requestCode, int resultCode, Intent data) {
    124         if (requestCode == REQUEST_PIN_CHALLENGE) {
    125             if (resultCode == Activity.RESULT_OK) {
    126                 mChallengeSucceeded = true;
    127                 mChallengeRequested = false;
    128             } else {
    129                 mChallengeSucceeded = false;
    130             }
    131             return;
    132         }
    133 
    134         super.onActivityResult(requestCode, resultCode, data);
    135     }
    136 
    137     private void ensurePin() {
    138         if (!mChallengeSucceeded && !mChallengeRequested
    139                 && mRestrictionsManager.hasRestrictionsProvider()) {
    140             Intent intent = mRestrictionsManager.createLocalApprovalIntent();
    141             if (intent != null) {
    142                 mChallengeRequested = true;
    143                 mChallengeSucceeded = false;
    144                 PersistableBundle request = new PersistableBundle();
    145                 request.putString(RestrictionsManager.REQUEST_KEY_MESSAGE,
    146                         getResources().getString(R.string.restr_pin_enter_admin_pin));
    147                 intent.putExtra(RestrictionsManager.EXTRA_REQUEST_BUNDLE, request);
    148                 startActivityForResult(intent, REQUEST_PIN_CHALLENGE);
    149             }
    150         }
    151     }
    152 
    153     /**
    154      * Returns true if this activity is restricted, but no restrictions provider has been set.
    155      * Used to determine if the settings UI should disable UI.
    156      */
    157     protected boolean isRestrictedAndNotProviderProtected() {
    158         if (mRestrictionKey == null || RESTRICT_IF_OVERRIDABLE.equals(mRestrictionKey)) {
    159             return false;
    160         }
    161         return mUserManager.hasUserRestriction(mRestrictionKey)
    162                 && !mRestrictionsManager.hasRestrictionsProvider();
    163     }
    164 
    165     protected boolean hasChallengeSucceeded() {
    166         return (mChallengeRequested && mChallengeSucceeded) || !mChallengeRequested;
    167     }
    168 
    169     /**
    170      * Returns true if this restrictions key is locked down.
    171      */
    172     protected boolean shouldBeProviderProtected(String restrictionKey) {
    173         if (restrictionKey == null) {
    174             return false;
    175         }
    176         boolean restricted = RESTRICT_IF_OVERRIDABLE.equals(restrictionKey)
    177                 || mUserManager.hasUserRestriction(mRestrictionKey);
    178         return restricted && mRestrictionsManager.hasRestrictionsProvider();
    179     }
    180 
    181     /**
    182      * Returns whether restricted or actionable UI elements should be removed or disabled.
    183      */
    184     protected boolean isUiRestricted() {
    185         return isRestrictedAndNotProviderProtected() || !hasChallengeSucceeded();
    186     }
    187 }
    188