src/com/android/settings/RestrictedSettingsFragment.java

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