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