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