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.app.admin.DevicePolicyManager;
     21 import android.content.BroadcastReceiver;
     22 import android.content.Context;
     23 import android.content.Intent;
     24 import android.content.IntentFilter;
     25 import android.content.RestrictionsManager;
     26 import android.os.Bundle;
     27 import android.os.PersistableBundle;
     28 import android.os.UserHandle;
     29 import android.os.UserManager;
     30 import android.view.Gravity;
     31 import android.view.View;
     32 import android.widget.TextView;
     33 
     34 import com.android.settingslib.RestrictedLockUtils;
     35 
     36 import static com.android.settingslib.RestrictedLockUtils.EnforcedAdmin;
     37 
     38 /**
     39  * Base class for settings screens that should be pin protected when in restricted mode or
     40  * that will display an admin support message in case an admin has disabled the options.
     41  * The constructor for this class will take the restriction key that this screen should be
     42  * locked by.  If {@link RestrictionsManager.hasRestrictionsProvider()} and
     43  * {@link UserManager.hasUserRestriction()}, then the user will have to enter the restrictions
     44  * pin before seeing the Settings screen.
     45  *
     46  * If this settings screen should be pin protected whenever
     47  * {@link RestrictionsManager.hasRestrictionsProvider()} returns true, pass in
     48  * {@link RESTRICT_IF_OVERRIDABLE} to the constructor instead of a restrictions key.
     49  */
     50 public abstract class RestrictedSettingsFragment extends SettingsPreferenceFragment {
     51 
     52     protected static final String RESTRICT_IF_OVERRIDABLE = "restrict_if_overridable";
     53 
     54     // No RestrictedSettingsFragment screens should use this number in startActivityForResult.
     55     private static final int REQUEST_PIN_CHALLENGE = 12309;
     56 
     57     private static final String KEY_CHALLENGE_SUCCEEDED = "chsc";
     58     private static final String KEY_CHALLENGE_REQUESTED = "chrq";
     59 
     60     // If the restriction PIN is entered correctly.
     61     private boolean mChallengeSucceeded;
     62     private boolean mChallengeRequested;
     63 
     64     private UserManager mUserManager;
     65     private RestrictionsManager mRestrictionsManager;
     66 
     67     private final String mRestrictionKey;
     68     private View mAdminSupportDetails;
     69     private EnforcedAdmin mEnforcedAdmin;
     70     private TextView mEmptyTextView;
     71 
     72     private boolean mOnlyAvailableForAdmins = false;
     73     private boolean mIsAdminUser;
     74 
     75     // Receiver to clear pin status when the screen is turned off.
     76     private BroadcastReceiver mScreenOffReceiver = new BroadcastReceiver() {
     77         @Override
     78         public void onReceive(Context context, Intent intent) {
     79             if (!mChallengeRequested) {
     80                 mChallengeSucceeded = false;
     81                 mChallengeRequested = false;
     82             }
     83         }
     84     };
     85 
     86     /**
     87      * @param restrictionKey The restriction key to check before pin protecting
     88      *            this settings page. Pass in {@link RESTRICT_IF_OVERRIDABLE} if it should
     89      *            be protected whenever a restrictions provider is set. Pass in
     90      *            null if it should never be protected.
     91      */
     92     public RestrictedSettingsFragment(String restrictionKey) {
     93         mRestrictionKey = restrictionKey;
     94     }
     95 
     96     @Override
     97     public void onCreate(Bundle icicle) {
     98         super.onCreate(icicle);
     99 
    100         mRestrictionsManager = (RestrictionsManager) getSystemService(Context.RESTRICTIONS_SERVICE);
    101         mUserManager = (UserManager) getSystemService(Context.USER_SERVICE);
    102         mIsAdminUser = mUserManager.isAdminUser();
    103 
    104         if (icicle != null) {
    105             mChallengeSucceeded = icicle.getBoolean(KEY_CHALLENGE_SUCCEEDED, false);
    106             mChallengeRequested = icicle.getBoolean(KEY_CHALLENGE_REQUESTED, false);
    107         }
    108 
    109         IntentFilter offFilter = new IntentFilter(Intent.ACTION_SCREEN_OFF);
    110         offFilter.addAction(Intent.ACTION_USER_PRESENT);
    111         getActivity().registerReceiver(mScreenOffReceiver, offFilter);
    112     }
    113 
    114     @Override
    115     public void onActivityCreated(Bundle savedInstanceState) {
    116         super.onActivityCreated(savedInstanceState);
    117         mAdminSupportDetails = initAdminSupportDetailsView();
    118         mEmptyTextView = initEmptyTextView();
    119     }
    120 
    121     @Override
    122     public void onSaveInstanceState(Bundle outState) {
    123         super.onSaveInstanceState(outState);
    124 
    125         if (getActivity().isChangingConfigurations()) {
    126             outState.putBoolean(KEY_CHALLENGE_REQUESTED, mChallengeRequested);
    127             outState.putBoolean(KEY_CHALLENGE_SUCCEEDED, mChallengeSucceeded);
    128         }
    129     }
    130 
    131     @Override
    132     public void onResume() {
    133         super.onResume();
    134 
    135         if (shouldBeProviderProtected(mRestrictionKey)) {
    136             ensurePin();
    137         }
    138     }
    139 
    140     @Override
    141     public void onDestroy() {
    142         getActivity().unregisterReceiver(mScreenOffReceiver);
    143         super.onDestroy();
    144     }
    145 
    146     @Override
    147     public void onActivityResult(int requestCode, int resultCode, Intent data) {
    148         if (requestCode == REQUEST_PIN_CHALLENGE) {
    149             if (resultCode == Activity.RESULT_OK) {
    150                 mChallengeSucceeded = true;
    151                 mChallengeRequested = false;
    152             } else {
    153                 mChallengeSucceeded = false;
    154             }
    155             return;
    156         }
    157 
    158         super.onActivityResult(requestCode, resultCode, data);
    159     }
    160 
    161     private void ensurePin() {
    162         if (!mChallengeSucceeded && !mChallengeRequested
    163                 && mRestrictionsManager.hasRestrictionsProvider()) {
    164             Intent intent = mRestrictionsManager.createLocalApprovalIntent();
    165             if (intent != null) {
    166                 mChallengeRequested = true;
    167                 mChallengeSucceeded = false;
    168                 PersistableBundle request = new PersistableBundle();
    169                 request.putString(RestrictionsManager.REQUEST_KEY_MESSAGE,
    170                         getResources().getString(R.string.restr_pin_enter_admin_pin));
    171                 intent.putExtra(RestrictionsManager.EXTRA_REQUEST_BUNDLE, request);
    172                 startActivityForResult(intent, REQUEST_PIN_CHALLENGE);
    173             }
    174         }
    175     }
    176 
    177     /**
    178      * Returns true if this activity is restricted, but no restrictions provider has been set.
    179      * Used to determine if the settings UI should disable UI.
    180      */
    181     protected boolean isRestrictedAndNotProviderProtected() {
    182         if (mRestrictionKey == null || RESTRICT_IF_OVERRIDABLE.equals(mRestrictionKey)) {
    183             return false;
    184         }
    185         return mUserManager.hasUserRestriction(mRestrictionKey)
    186                 && !mRestrictionsManager.hasRestrictionsProvider();
    187     }
    188 
    189     protected boolean hasChallengeSucceeded() {
    190         return (mChallengeRequested && mChallengeSucceeded) || !mChallengeRequested;
    191     }
    192 
    193     /**
    194      * Returns true if this restrictions key is locked down.
    195      */
    196     protected boolean shouldBeProviderProtected(String restrictionKey) {
    197         if (restrictionKey == null) {
    198             return false;
    199         }
    200         boolean restricted = RESTRICT_IF_OVERRIDABLE.equals(restrictionKey)
    201                 || mUserManager.hasUserRestriction(mRestrictionKey);
    202         return restricted && mRestrictionsManager.hasRestrictionsProvider();
    203     }
    204 
    205     private View initAdminSupportDetailsView() {
    206         return getActivity().findViewById(R.id.admin_support_details);
    207     }
    208 
    209     protected TextView initEmptyTextView() {
    210         TextView emptyView = (TextView) getActivity().findViewById(android.R.id.empty);
    211         return emptyView;
    212     }
    213 
    214     public EnforcedAdmin getRestrictionEnforcedAdmin() {
    215         mEnforcedAdmin = RestrictedLockUtils.checkIfRestrictionEnforced(getActivity(),
    216                 mRestrictionKey, UserHandle.myUserId());
    217         if (mEnforcedAdmin != null && mEnforcedAdmin.userId == UserHandle.USER_NULL) {
    218             mEnforcedAdmin.userId = UserHandle.myUserId();
    219         }
    220         return mEnforcedAdmin;
    221     }
    222 
    223     public TextView getEmptyTextView() {
    224         return mEmptyTextView;
    225     }
    226 
    227     @Override
    228     protected void onDataSetChanged() {
    229         highlightPreferenceIfNeeded();
    230         if (mAdminSupportDetails != null && isUiRestrictedByOnlyAdmin()) {
    231             final EnforcedAdmin admin = getRestrictionEnforcedAdmin();
    232             ShowAdminSupportDetailsDialog.setAdminSupportDetails(getActivity(),
    233                     mAdminSupportDetails, admin, false);
    234             setEmptyView(mAdminSupportDetails);
    235         } else if (mEmptyTextView != null) {
    236             setEmptyView(mEmptyTextView);
    237         }
    238         super.onDataSetChanged();
    239     }
    240 
    241     public void setIfOnlyAvailableForAdmins(boolean onlyForAdmins) {
    242         mOnlyAvailableForAdmins = onlyForAdmins;
    243     }
    244 
    245     /**
    246      * Returns whether restricted or actionable UI elements should be removed or disabled.
    247      */
    248     protected boolean isUiRestricted() {
    249         return isRestrictedAndNotProviderProtected() || !hasChallengeSucceeded()
    250                 || (!mIsAdminUser && mOnlyAvailableForAdmins);
    251     }
    252 
    253     protected boolean isUiRestrictedByOnlyAdmin() {
    254         return isUiRestricted() && !mUserManager.hasBaseUserRestriction(mRestrictionKey,
    255                 UserHandle.of(UserHandle.myUserId())) && (mIsAdminUser || !mOnlyAvailableForAdmins);
    256     }
    257 }
    258