1 /* 2 * Copyright (C) 2016 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.accounts; 18 19 import android.content.BroadcastReceiver; 20 import android.content.Context; 21 import android.content.Intent; 22 import android.content.IntentFilter; 23 import android.os.Bundle; 24 import android.os.UserHandle; 25 import android.os.UserManager; 26 import android.provider.Settings; 27 import android.support.v14.preference.SwitchPreference; 28 import android.support.v7.preference.Preference; 29 import android.util.Log; 30 31 import com.android.internal.logging.nano.MetricsProto; 32 import com.android.settings.R; 33 import com.android.settings.SettingsPreferenceFragment; 34 import com.android.settings.Utils; 35 import com.android.settingslib.RestrictedLockUtils; 36 import com.android.settingslib.RestrictedSwitchPreference; 37 38 import static android.provider.Settings.Secure.MANAGED_PROFILE_CONTACT_REMOTE_SEARCH; 39 40 /** 41 * Setting page for managed profile. 42 * FIXME: It currently assumes there is only one managed profile. 43 */ 44 public class ManagedProfileSettings extends SettingsPreferenceFragment 45 implements Preference.OnPreferenceChangeListener { 46 47 private SwitchPreference mWorkModePreference; 48 private RestrictedSwitchPreference mContactPrefrence; 49 50 private UserManager mUserManager; 51 private UserHandle mManagedUser; 52 private Context mContext; 53 54 private ManagedProfileBroadcastReceiver mManagedProfileBroadcastReceiver; 55 56 private static final String KEY_WORK_MODE = "work_mode"; 57 private static final String KEY_CONTACT = "contacts_search"; 58 59 private static final String TAG = "ManagedProfileSettings"; 60 61 @Override onCreate(Bundle icicle)62 public void onCreate(Bundle icicle) { 63 super.onCreate(icicle); 64 addPreferencesFromResource(R.xml.managed_profile_settings); 65 mWorkModePreference = (SwitchPreference) findPreference(KEY_WORK_MODE); 66 mWorkModePreference.setOnPreferenceChangeListener(this); 67 mContactPrefrence = (RestrictedSwitchPreference) findPreference(KEY_CONTACT); 68 mContactPrefrence.setOnPreferenceChangeListener(this); 69 mContext = getActivity().getApplicationContext(); 70 mUserManager = (UserManager) getSystemService(Context.USER_SERVICE); 71 mManagedUser = getManagedUserFromArgument(); 72 if (mManagedUser == null) { 73 getActivity().finish(); 74 } 75 mManagedProfileBroadcastReceiver = new ManagedProfileBroadcastReceiver(); 76 mManagedProfileBroadcastReceiver.register(getActivity()); 77 } 78 79 @Override onResume()80 public void onResume() { 81 super.onResume(); 82 loadDataAndPopulateUi(); 83 } 84 85 @Override onDestroy()86 public void onDestroy() { 87 super.onDestroy(); 88 mManagedProfileBroadcastReceiver.unregister(getActivity()); 89 } 90 getManagedUserFromArgument()91 private UserHandle getManagedUserFromArgument() { 92 Bundle arguments = getArguments(); 93 if (arguments != null) { 94 UserHandle userHandle = arguments.getParcelable(Intent.EXTRA_USER); 95 if (userHandle != null) { 96 if (mUserManager.isManagedProfile(userHandle.getIdentifier())) { 97 return userHandle; 98 } 99 } 100 } 101 // Return default managed profile for the current user. 102 return Utils.getManagedProfile(mUserManager); 103 } 104 loadDataAndPopulateUi()105 private void loadDataAndPopulateUi() { 106 if (mWorkModePreference != null) { 107 updateWorkModePreference(); 108 } 109 110 if (mContactPrefrence != null) { 111 int value = Settings.Secure.getIntForUser(getContentResolver(), 112 MANAGED_PROFILE_CONTACT_REMOTE_SEARCH, 0, mManagedUser.getIdentifier()); 113 mContactPrefrence.setChecked(value != 0); 114 RestrictedLockUtils.EnforcedAdmin enforcedAdmin = 115 RestrictedLockUtils.checkIfRemoteContactSearchDisallowed( 116 mContext, mManagedUser.getIdentifier()); 117 mContactPrefrence.setDisabledByAdmin(enforcedAdmin); 118 } 119 } 120 121 @Override getMetricsCategory()122 public int getMetricsCategory() { 123 return MetricsProto.MetricsEvent.ACCOUNTS_WORK_PROFILE_SETTINGS; 124 } 125 updateWorkModePreference()126 private void updateWorkModePreference() { 127 boolean isWorkModeOn = !mUserManager.isQuietModeEnabled(mManagedUser); 128 mWorkModePreference.setChecked(isWorkModeOn); 129 mWorkModePreference.setSummary(isWorkModeOn 130 ? R.string.work_mode_on_summary 131 : R.string.work_mode_off_summary); 132 } 133 134 135 @Override onPreferenceChange(Preference preference, Object newValue)136 public boolean onPreferenceChange(Preference preference, Object newValue) { 137 if (preference == mWorkModePreference) { 138 boolean quietModeEnabled = !(boolean) newValue; 139 mUserManager.requestQuietModeEnabled(quietModeEnabled, mManagedUser); 140 return true; 141 } 142 if (preference == mContactPrefrence) { 143 int value = ((boolean) newValue == true) ? 1 : 0; 144 Settings.Secure.putIntForUser(getContentResolver(), 145 MANAGED_PROFILE_CONTACT_REMOTE_SEARCH, value, mManagedUser.getIdentifier()); 146 return true; 147 } 148 return false; 149 } 150 151 private class ManagedProfileBroadcastReceiver extends BroadcastReceiver { 152 153 @Override onReceive(Context context, Intent intent)154 public void onReceive(Context context, Intent intent) { 155 final String action = intent.getAction(); 156 Log.v(TAG, "Received broadcast: " + action); 157 if (action.equals(Intent.ACTION_MANAGED_PROFILE_REMOVED)) { 158 if (intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 159 UserHandle.USER_NULL) == mManagedUser.getIdentifier()) { 160 getActivity().finish(); 161 } 162 return; 163 } 164 165 if (action.equals(Intent.ACTION_MANAGED_PROFILE_AVAILABLE) 166 || action.equals(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE)) { 167 if (intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 168 UserHandle.USER_NULL) == mManagedUser.getIdentifier()) { 169 updateWorkModePreference(); 170 } 171 return; 172 } 173 Log.w(TAG, "Cannot handle received broadcast: " + intent.getAction()); 174 } 175 176 register(Context context)177 public void register(Context context) { 178 IntentFilter intentFilter = new IntentFilter(); 179 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED); 180 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE); 181 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE); 182 context.registerReceiver(this, intentFilter); 183 } 184 unregister(Context context)185 public void unregister(Context context) { 186 context.unregisterReceiver(this); 187 } 188 } 189 190 } 191