1 /* 2 * Copyright (C) 2014 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.systemui.statusbar.policy; 18 19 import android.app.AlarmManager; 20 import android.app.INotificationManager; 21 import android.app.NotificationManager; 22 import android.content.BroadcastReceiver; 23 import android.content.ComponentName; 24 import android.content.ContentResolver; 25 import android.content.Context; 26 import android.content.Intent; 27 import android.content.IntentFilter; 28 import android.database.ContentObserver; 29 import android.net.Uri; 30 import android.os.Handler; 31 import android.os.RemoteException; 32 import android.os.ServiceManager; 33 import android.os.UserHandle; 34 import android.provider.Settings.Global; 35 import android.provider.Settings.Secure; 36 import android.service.notification.Condition; 37 import android.service.notification.IConditionListener; 38 import android.service.notification.ZenModeConfig; 39 import android.util.Log; 40 import android.util.Slog; 41 42 import com.android.systemui.qs.GlobalSetting; 43 44 import java.util.ArrayList; 45 import java.util.LinkedHashMap; 46 47 /** Platform implementation of the zen mode controller. **/ 48 public class ZenModeControllerImpl implements ZenModeController { 49 private static final String TAG = "ZenModeController"; 50 private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG); 51 52 private final ArrayList<Callback> mCallbacks = new ArrayList<Callback>(); 53 private final Context mContext; 54 private final GlobalSetting mModeSetting; 55 private final GlobalSetting mConfigSetting; 56 private final INotificationManager mNoMan; 57 private final LinkedHashMap<Uri, Condition> mConditions = new LinkedHashMap<Uri, Condition>(); 58 private final AlarmManager mAlarmManager; 59 private final SetupObserver mSetupObserver; 60 61 private int mUserId; 62 private boolean mRequesting; 63 private boolean mRegistered; 64 65 public ZenModeControllerImpl(Context context, Handler handler) { 66 mContext = context; 67 mModeSetting = new GlobalSetting(mContext, handler, Global.ZEN_MODE) { 68 @Override 69 protected void handleValueChanged(int value) { 70 fireZenChanged(value); 71 } 72 }; 73 mConfigSetting = new GlobalSetting(mContext, handler, Global.ZEN_MODE_CONFIG_ETAG) { 74 @Override 75 protected void handleValueChanged(int value) { 76 fireExitConditionChanged(); 77 } 78 }; 79 mModeSetting.setListening(true); 80 mConfigSetting.setListening(true); 81 mNoMan = INotificationManager.Stub.asInterface( 82 ServiceManager.getService(Context.NOTIFICATION_SERVICE)); 83 mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE); 84 mSetupObserver = new SetupObserver(handler); 85 mSetupObserver.register(); 86 } 87 88 @Override 89 public void addCallback(Callback callback) { 90 mCallbacks.add(callback); 91 } 92 93 @Override 94 public void removeCallback(Callback callback) { 95 mCallbacks.remove(callback); 96 } 97 98 @Override 99 public int getZen() { 100 return mModeSetting.getValue(); 101 } 102 103 @Override 104 public void setZen(int zen) { 105 mModeSetting.setValue(zen); 106 } 107 108 @Override 109 public boolean isZenAvailable() { 110 return mSetupObserver.isDeviceProvisioned() && mSetupObserver.isUserSetup(); 111 } 112 113 @Override 114 public void requestConditions(boolean request) { 115 mRequesting = request; 116 try { 117 mNoMan.requestZenModeConditions(mListener, request ? Condition.FLAG_RELEVANT_NOW : 0); 118 } catch (RemoteException e) { 119 // noop 120 } 121 if (!mRequesting) { 122 mConditions.clear(); 123 } 124 } 125 126 @Override 127 public void setExitCondition(Condition exitCondition) { 128 try { 129 mNoMan.setZenModeCondition(exitCondition); 130 } catch (RemoteException e) { 131 // noop 132 } 133 } 134 135 @Override 136 public Condition getExitCondition() { 137 try { 138 final ZenModeConfig config = mNoMan.getZenModeConfig(); 139 if (config != null) { 140 return config.exitCondition; 141 } 142 } catch (RemoteException e) { 143 // noop 144 } 145 return null; 146 } 147 148 @Override 149 public long getNextAlarm() { 150 final AlarmManager.AlarmClockInfo info = mAlarmManager.getNextAlarmClock(mUserId); 151 return info != null ? info.getTriggerTime() : 0; 152 } 153 154 @Override 155 public void setUserId(int userId) { 156 mUserId = userId; 157 if (mRegistered) { 158 mContext.unregisterReceiver(mReceiver); 159 } 160 final IntentFilter filter = new IntentFilter(AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED); 161 filter.addAction(NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED); 162 mContext.registerReceiverAsUser(mReceiver, new UserHandle(mUserId), filter, null, null); 163 mRegistered = true; 164 mSetupObserver.register(); 165 } 166 167 @Override 168 public ComponentName getEffectsSuppressor() { 169 return NotificationManager.from(mContext).getEffectsSuppressor(); 170 } 171 172 private void fireNextAlarmChanged() { 173 for (Callback cb : mCallbacks) { 174 cb.onNextAlarmChanged(); 175 } 176 } 177 178 private void fireEffectsSuppressorChanged() { 179 for (Callback cb : mCallbacks) { 180 cb.onEffectsSupressorChanged(); 181 } 182 } 183 184 private void fireZenChanged(int zen) { 185 for (Callback cb : mCallbacks) { 186 cb.onZenChanged(zen); 187 } 188 } 189 190 private void fireZenAvailableChanged(boolean available) { 191 for (Callback cb : mCallbacks) { 192 cb.onZenAvailableChanged(available); 193 } 194 } 195 196 private void fireConditionsChanged(Condition[] conditions) { 197 for (Callback cb : mCallbacks) { 198 cb.onConditionsChanged(conditions); 199 } 200 } 201 202 private void fireExitConditionChanged() { 203 final Condition exitCondition = getExitCondition(); 204 if (DEBUG) Slog.d(TAG, "exitCondition changed: " + exitCondition); 205 for (Callback cb : mCallbacks) { 206 cb.onExitConditionChanged(exitCondition); 207 } 208 } 209 210 private void updateConditions(Condition[] conditions) { 211 if (conditions == null || conditions.length == 0) return; 212 for (Condition c : conditions) { 213 if ((c.flags & Condition.FLAG_RELEVANT_NOW) == 0) continue; 214 mConditions.put(c.id, c); 215 } 216 fireConditionsChanged( 217 mConditions.values().toArray(new Condition[mConditions.values().size()])); 218 } 219 220 private final IConditionListener mListener = new IConditionListener.Stub() { 221 @Override 222 public void onConditionsReceived(Condition[] conditions) { 223 if (DEBUG) Slog.d(TAG, "onConditionsReceived " 224 + (conditions == null ? 0 : conditions.length) + " mRequesting=" + mRequesting); 225 if (!mRequesting) return; 226 updateConditions(conditions); 227 } 228 }; 229 230 private final BroadcastReceiver mReceiver = new BroadcastReceiver() { 231 @Override 232 public void onReceive(Context context, Intent intent) { 233 if (AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED.equals(intent.getAction())) { 234 fireNextAlarmChanged(); 235 } 236 if (NotificationManager.ACTION_EFFECTS_SUPPRESSOR_CHANGED.equals(intent.getAction())) { 237 fireEffectsSuppressorChanged(); 238 } 239 } 240 }; 241 242 private final class SetupObserver extends ContentObserver { 243 private final ContentResolver mResolver; 244 245 private boolean mRegistered; 246 247 public SetupObserver(Handler handler) { 248 super(handler); 249 mResolver = mContext.getContentResolver(); 250 } 251 252 public boolean isUserSetup() { 253 return Secure.getIntForUser(mResolver, Secure.USER_SETUP_COMPLETE, 0, mUserId) != 0; 254 } 255 256 public boolean isDeviceProvisioned() { 257 return Global.getInt(mResolver, Global.DEVICE_PROVISIONED, 0) != 0; 258 } 259 260 public void register() { 261 if (mRegistered) { 262 mResolver.unregisterContentObserver(this); 263 } 264 mResolver.registerContentObserver( 265 Global.getUriFor(Global.DEVICE_PROVISIONED), false, this); 266 mResolver.registerContentObserver( 267 Secure.getUriFor(Secure.USER_SETUP_COMPLETE), false, this, mUserId); 268 fireZenAvailableChanged(isZenAvailable()); 269 } 270 271 @Override 272 public void onChange(boolean selfChange, Uri uri) { 273 if (Global.getUriFor(Global.DEVICE_PROVISIONED).equals(uri) 274 || Secure.getUriFor(Secure.USER_SETUP_COMPLETE).equals(uri)) { 275 fireZenAvailableChanged(isZenAvailable()); 276 } 277 } 278 } 279 } 280