Home | History | Annotate | Download | only in accounts 
      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
     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
     80     public void onResume() {
     81         super.onResume();
     82         loadDataAndPopulateUi();
     83     }
     84 
     85     @Override
     86     public void onDestroy() {
     87         super.onDestroy();
     88         mManagedProfileBroadcastReceiver.unregister(getActivity());
     89     }
     90 
     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 
    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
    122     public int getMetricsCategory() {
    123         return MetricsProto.MetricsEvent.ACCOUNTS_WORK_PROFILE_SETTINGS;
    124     }
    125 
    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
    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
    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 
    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 
    185         public void unregister(Context context) {
    186             context.unregisterReceiver(this);
    187         }
    188     }
    189 
    190 }
    191