src/com/android/settings/notification/ZenModePrioritySettings.java

   1 /*
   2  * Copyright (C) 2015 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.notification;
  18
  19 import android.os.Bundle;
  20 import android.preference.Preference;
  21 import android.preference.Preference.OnPreferenceChangeListener;
  22 import android.preference.PreferenceScreen;
  23 import android.preference.SwitchPreference;
  24 import android.service.notification.ZenModeConfig;
  25 import android.util.Log;
  26
  27 import com.android.internal.logging.MetricsLogger;
  28 import com.android.settings.DropDownPreference;
  29 import com.android.settings.R;
  30 import com.android.settings.search.Indexable;
  31
  32 public class ZenModePrioritySettings extends ZenModeSettingsBase implements Indexable {
  33     private static final String KEY_REMINDERS = "reminders";
  34     private static final String KEY_EVENTS = "events";
  35     private static final String KEY_MESSAGES = "messages";
  36     private static final String KEY_CALLS = "calls";
  37     private static final String KEY_REPEAT_CALLERS = "repeat_callers";
  38     private static final String KEY_ALLOW_LIGHTS = "zen_priority_allow_lights";
  39
  40     private static final int SOURCE_NONE = -1;
  41
  42     private boolean mDisableListeners;
  43     private SwitchPreference mReminders;
  44     private SwitchPreference mEvents;
  45     private DropDownPreference mMessages;
  46     private DropDownPreference mCalls;
  47     private SwitchPreference mRepeatCallers;
  48
  49     @Override
  50     public void onCreate(Bundle savedInstanceState) {
  51         super.onCreate(savedInstanceState);
  52         addPreferencesFromResource(R.xml.zen_mode_priority_settings);
  53         final PreferenceScreen root = getPreferenceScreen();
  54
  55         mReminders = (SwitchPreference) root.findPreference(KEY_REMINDERS);
  56         mReminders.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
  57             @Override
  58             public boolean onPreferenceChange(Preference preference, Object newValue) {
  59                 if (mDisableListeners) return true;
  60                 final boolean val = (Boolean) newValue;
  61                 MetricsLogger.action(mContext, MetricsLogger.ACTION_ZEN_ALLOW_REMINDERS, val);
  62                 if (val == mConfig.allowReminders) return true;
  63                 if (DEBUG) Log.d(TAG, "onPrefChange allowReminders=" + val);
  64                 final ZenModeConfig newConfig = mConfig.copy();
  65                 newConfig.allowReminders = val;
  66                 return setZenModeConfig(newConfig);
  67             }
  68         });
  69
  70         mEvents = (SwitchPreference) root.findPreference(KEY_EVENTS);
  71         mEvents.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
  72             @Override
  73             public boolean onPreferenceChange(Preference preference, Object newValue) {
  74                 if (mDisableListeners) return true;
  75                 final boolean val = (Boolean) newValue;
  76                 MetricsLogger.action(mContext, MetricsLogger.ACTION_ZEN_ALLOW_EVENTS, val);
  77                 if (val == mConfig.allowEvents) return true;
  78                 if (DEBUG) Log.d(TAG, "onPrefChange allowEvents=" + val);
  79                 final ZenModeConfig newConfig = mConfig.copy();
  80                 newConfig.allowEvents = val;
  81                 return setZenModeConfig(newConfig);
  82             }
  83         });
  84
  85         mMessages = (DropDownPreference) root.findPreference(KEY_MESSAGES);
  86         addSources(mMessages);
  87         mMessages.setCallback(new DropDownPreference.Callback() {
  88             @Override
  89             public boolean onItemSelected(int pos, Object newValue) {
  90                 if (mDisableListeners) return true;
  91                 final int val = (Integer) newValue;
  92                 MetricsLogger.action(mContext, MetricsLogger.ACTION_ZEN_ALLOW_MESSAGES, val);
  93                 final boolean allowMessages = val != SOURCE_NONE;
  94                 final int allowMessagesFrom = val == SOURCE_NONE ? mConfig.allowMessagesFrom : val;
  95                 if (allowMessages == mConfig.allowMessages
  96                         && allowMessagesFrom == mConfig.allowMessagesFrom) {
  97                     return true;
  98                 }
  99                 if (DEBUG) Log.d(TAG, "onPrefChange allowMessages=" + allowMessages
 100                         + " allowMessagesFrom=" + ZenModeConfig.sourceToString(allowMessagesFrom));
 101                 final ZenModeConfig newConfig = mConfig.copy();
 102                 newConfig.allowMessages = allowMessages;
 103                 newConfig.allowMessagesFrom = allowMessagesFrom;
 104                 return setZenModeConfig(newConfig);
 105             }
 106         });
 107
 108         mCalls = (DropDownPreference) root.findPreference(KEY_CALLS);
 109         addSources(mCalls);
 110         mCalls.setCallback(new DropDownPreference.Callback() {
 111             @Override
 112             public boolean onItemSelected(int pos, Object newValue) {
 113                 if (mDisableListeners) return true;
 114                 final int val = (Integer) newValue;
 115                 MetricsLogger.action(mContext, MetricsLogger.ACTION_ZEN_ALLOW_CALLS, val);
 116                 final boolean allowCalls = val != SOURCE_NONE;
 117                 final int allowCallsFrom = val == SOURCE_NONE ? mConfig.allowCallsFrom : val;
 118                 if (allowCalls == mConfig.allowCalls
 119                         && allowCallsFrom == mConfig.allowCallsFrom) {
 120                     return true;
 121                 }
 122                 if (DEBUG) Log.d(TAG, "onPrefChange allowCalls=" + allowCalls
 123                         + " allowCallsFrom=" + ZenModeConfig.sourceToString(allowCallsFrom));
 124                 final ZenModeConfig newConfig = mConfig.copy();
 125                 newConfig.allowCalls = allowCalls;
 126                 newConfig.allowCallsFrom = allowCallsFrom;
 127                 return setZenModeConfig(newConfig);
 128             }
 129         });
 130
 131         mRepeatCallers = (SwitchPreference) root.findPreference(KEY_REPEAT_CALLERS);
 132         mRepeatCallers.setSummary(mContext.getString(R.string.zen_mode_repeat_callers_summary,
 133                 mContext.getResources().getInteger(com.android.internal.R.integer
 134                         .config_zen_repeat_callers_threshold)));
 135         mRepeatCallers.setOnPreferenceChangeListener(new OnPreferenceChangeListener() {
 136             @Override
 137             public boolean onPreferenceChange(Preference preference, Object newValue) {
 138                 if (mDisableListeners) return true;
 139                 final boolean val = (Boolean) newValue;
 140                 MetricsLogger.action(mContext, MetricsLogger.ACTION_ZEN_ALLOW_REPEAT_CALLS, val);
 141                 if (val == mConfig.allowRepeatCallers) return true;
 142                 if (DEBUG) Log.d(TAG, "onPrefChange allowRepeatCallers=" + val);
 143                 final ZenModeConfig newConfig = mConfig.copy();
 144                 newConfig.allowRepeatCallers = val;
 145                 return setZenModeConfig(newConfig);
 146             }
 147         });
 148
 149         // Remove of the "Allow notification light" setting if LED is not supported
 150         if (!getResources().getBoolean(
 151                 com.android.internal.R.bool.config_intrusiveNotificationLed)) {
 152             root.removePreference(findPreference(KEY_ALLOW_LIGHTS));
 153         }
 154
 155         updateControls();
 156     }
 157
 158     @Override
 159     protected void onZenModeChanged() {
 160         // don't care
 161     }
 162
 163     @Override
 164     protected void onZenModeConfigChanged() {
 165         updateControls();
 166     }
 167
 168     private void updateControls() {
 169         mDisableListeners = true;
 170         if (mCalls != null) {
 171             mCalls.setSelectedValue(mConfig.allowCalls ? mConfig.allowCallsFrom : SOURCE_NONE);
 172         }
 173         mMessages.setSelectedValue(mConfig.allowMessages ? mConfig.allowMessagesFrom : SOURCE_NONE);
 174         mReminders.setChecked(mConfig.allowReminders);
 175         mEvents.setChecked(mConfig.allowEvents);
 176         mRepeatCallers.setChecked(mConfig.allowRepeatCallers);
 177         mRepeatCallers.setEnabled(!mConfig.allowCalls
 178                 || mConfig.allowCallsFrom != ZenModeConfig.SOURCE_ANYONE);
 179         mDisableListeners = false;
 180     }
 181
 182     @Override
 183     protected int getMetricsCategory() {
 184         return MetricsLogger.NOTIFICATION_ZEN_MODE_PRIORITY;
 185     }
 186
 187     private static void addSources(DropDownPreference pref) {
 188         pref.addItem(R.string.zen_mode_from_anyone, ZenModeConfig.SOURCE_ANYONE);
 189         pref.addItem(R.string.zen_mode_from_contacts, ZenModeConfig.SOURCE_CONTACT);
 190         pref.addItem(R.string.zen_mode_from_starred, ZenModeConfig.SOURCE_STAR);
 191         pref.addItem(R.string.zen_mode_from_none, SOURCE_NONE);
 192     }
 193
 194 }