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 mWorkModePreference.setChecked( 108 !mUserManager.isQuietModeEnabled(mManagedUser)); 109 } 110 111 if (mContactPrefrence != null) { 112 int value = Settings.Secure.getIntForUser(getContentResolver(), 113 MANAGED_PROFILE_CONTACT_REMOTE_SEARCH, 0, mManagedUser.getIdentifier()); 114 mContactPrefrence.setChecked(value != 0); 115 RestrictedLockUtils.EnforcedAdmin enforcedAdmin = 116 RestrictedLockUtils.checkIfRemoteContactSearchDisallowed( 117 mContext, mManagedUser.getIdentifier()); 118 mContactPrefrence.setDisabledByAdmin(enforcedAdmin); 119 } 120 } 121 122 @Override getMetricsCategory()123 public int getMetricsCategory() { 124 return MetricsProto.MetricsEvent.ACCOUNTS_WORK_PROFILE_SETTINGS; 125 } 126 127 128 @Override onPreferenceChange(Preference preference, Object newValue)129 public boolean onPreferenceChange(Preference preference, Object newValue) { 130 if (preference == mWorkModePreference) { 131 if ((boolean) newValue) { 132 mUserManager.trySetQuietModeDisabled(mManagedUser.getIdentifier(), null); 133 } else { 134 mUserManager.setQuietModeEnabled(mManagedUser.getIdentifier(), true); 135 } 136 return true; 137 } 138 if (preference == mContactPrefrence) { 139 int value = ((boolean) newValue == true) ? 1 : 0; 140 Settings.Secure.putIntForUser(getContentResolver(), 141 MANAGED_PROFILE_CONTACT_REMOTE_SEARCH, value, mManagedUser.getIdentifier()); 142 return true; 143 } 144 return false; 145 } 146 147 private class ManagedProfileBroadcastReceiver extends BroadcastReceiver { 148 149 @Override onReceive(Context context, Intent intent)150 public void onReceive(Context context, Intent intent) { 151 final String action = intent.getAction(); 152 Log.v(TAG, "Received broadcast: " + action); 153 if (action.equals(Intent.ACTION_MANAGED_PROFILE_REMOVED)) { 154 if (intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 155 UserHandle.USER_NULL) == mManagedUser.getIdentifier()) { 156 getActivity().finish(); 157 } 158 return; 159 } 160 161 if (action.equals(Intent.ACTION_MANAGED_PROFILE_AVAILABLE) 162 || action.equals(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE)) { 163 if (intent.getIntExtra(Intent.EXTRA_USER_HANDLE, 164 UserHandle.USER_NULL) == mManagedUser.getIdentifier()) { 165 mWorkModePreference.setChecked( 166 !mUserManager.isQuietModeEnabled(mManagedUser)); 167 } 168 return; 169 } 170 Log.w(TAG, "Cannot handle received broadcast: " + intent.getAction()); 171 } 172 173 register(Context context)174 public void register(Context context) { 175 IntentFilter intentFilter = new IntentFilter(); 176 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED); 177 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE); 178 intentFilter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE); 179 context.registerReceiver(this, intentFilter); 180 } 181 unregister(Context context)182 public void unregister(Context context) { 183 context.unregisterReceiver(this); 184 } 185 } 186 187 } 188