• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2008 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.phone;
18 
19 import android.app.ActivityManager;
20 import android.app.ActivityManagerNative;
21 import android.app.AlarmManager;
22 import android.app.AlarmManager.AlarmClockInfo;
23 import android.app.SynchronousUserSwitchObserver;
24 import android.content.BroadcastReceiver;
25 import android.content.Context;
26 import android.content.Intent;
27 import android.content.IntentFilter;
28 import android.content.pm.UserInfo;
29 import android.media.AudioManager;
30 import android.os.Handler;
31 import android.os.RemoteException;
32 import android.os.UserHandle;
33 import android.os.UserManager;
34 import android.provider.Settings.Global;
35 import android.telecom.TelecomManager;
36 import android.util.Log;
37 
38 import com.android.internal.telephony.IccCardConstants;
39 import com.android.internal.telephony.TelephonyIntents;
40 import com.android.systemui.R;
41 import com.android.systemui.qs.tiles.DndTile;
42 import com.android.systemui.qs.tiles.RotationLockTile;
43 import com.android.systemui.statusbar.policy.BluetoothController;
44 import com.android.systemui.statusbar.policy.BluetoothController.Callback;
45 import com.android.systemui.statusbar.policy.CastController;
46 import com.android.systemui.statusbar.policy.CastController.CastDevice;
47 import com.android.systemui.statusbar.policy.DataSaverController;
48 import com.android.systemui.statusbar.policy.HotspotController;
49 import com.android.systemui.statusbar.policy.RotationLockController;
50 import com.android.systemui.statusbar.policy.UserInfoController;
51 
52 /**
53  * This class contains all of the policy about which icons are installed in the status
54  * bar at boot time.  It goes through the normal API for icons, even though it probably
55  * strictly doesn't need to.
56  */
57 public class PhoneStatusBarPolicy implements Callback, RotationLockController.RotationLockControllerCallback, DataSaverController.Listener {
58     private static final String TAG = "PhoneStatusBarPolicy";
59     private static final boolean DEBUG = Log.isLoggable(TAG, Log.DEBUG);
60 
61     private final String mSlotCast;
62     private final String mSlotHotspot;
63     private final String mSlotBluetooth;
64     private final String mSlotTty;
65     private final String mSlotZen;
66     private final String mSlotVolume;
67     private final String mSlotAlarmClock;
68     private final String mSlotManagedProfile;
69     private final String mSlotRotate;
70     private final String mSlotHeadset;
71     private final String mSlotDataSaver;
72 
73     private final Context mContext;
74     private final Handler mHandler = new Handler();
75     private final CastController mCast;
76     private final HotspotController mHotspot;
77     private final AlarmManager mAlarmManager;
78     private final UserInfoController mUserInfoController;
79     private final UserManager mUserManager;
80     private final StatusBarIconController mIconController;
81     private final RotationLockController mRotationLockController;
82     private final DataSaverController mDataSaver;
83     private StatusBarKeyguardViewManager mStatusBarKeyguardViewManager;
84 
85     // Assume it's all good unless we hear otherwise.  We don't always seem
86     // to get broadcasts that it *is* there.
87     IccCardConstants.State mSimState = IccCardConstants.State.READY;
88 
89     private boolean mZenVisible;
90     private boolean mVolumeVisible;
91     private boolean mCurrentUserSetup;
92 
93     private int mZen;
94 
95     private boolean mManagedProfileFocused = false;
96     private boolean mManagedProfileIconVisible = false;
97     private boolean mManagedProfileInQuietMode = false;
98 
99     private BluetoothController mBluetooth;
100 
PhoneStatusBarPolicy(Context context, StatusBarIconController iconController, CastController cast, HotspotController hotspot, UserInfoController userInfoController, BluetoothController bluetooth, RotationLockController rotationLockController, DataSaverController dataSaver)101     public PhoneStatusBarPolicy(Context context, StatusBarIconController iconController,
102             CastController cast, HotspotController hotspot, UserInfoController userInfoController,
103             BluetoothController bluetooth, RotationLockController rotationLockController,
104             DataSaverController dataSaver) {
105         mContext = context;
106         mIconController = iconController;
107         mCast = cast;
108         mHotspot = hotspot;
109         mBluetooth = bluetooth;
110         mBluetooth.addStateChangedCallback(this);
111         mAlarmManager = (AlarmManager) context.getSystemService(Context.ALARM_SERVICE);
112         mUserInfoController = userInfoController;
113         mUserManager = (UserManager) mContext.getSystemService(Context.USER_SERVICE);
114         mRotationLockController = rotationLockController;
115         mDataSaver = dataSaver;
116 
117         mSlotCast = context.getString(com.android.internal.R.string.status_bar_cast);
118         mSlotHotspot = context.getString(com.android.internal.R.string.status_bar_hotspot);
119         mSlotBluetooth = context.getString(com.android.internal.R.string.status_bar_bluetooth);
120         mSlotTty = context.getString(com.android.internal.R.string.status_bar_tty);
121         mSlotZen = context.getString(com.android.internal.R.string.status_bar_zen);
122         mSlotVolume = context.getString(com.android.internal.R.string.status_bar_volume);
123         mSlotAlarmClock = context.getString(com.android.internal.R.string.status_bar_alarm_clock);
124         mSlotManagedProfile = context.getString(
125                 com.android.internal.R.string.status_bar_managed_profile);
126         mSlotRotate = context.getString(com.android.internal.R.string.status_bar_rotate);
127         mSlotHeadset = context.getString(com.android.internal.R.string.status_bar_headset);
128         mSlotDataSaver = context.getString(com.android.internal.R.string.status_bar_data_saver);
129 
130         mRotationLockController.addRotationLockControllerCallback(this);
131 
132         // listen for broadcasts
133         IntentFilter filter = new IntentFilter();
134         filter.addAction(AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED);
135         filter.addAction(AudioManager.RINGER_MODE_CHANGED_ACTION);
136         filter.addAction(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION);
137         filter.addAction(AudioManager.ACTION_HEADSET_PLUG);
138         filter.addAction(TelephonyIntents.ACTION_SIM_STATE_CHANGED);
139         filter.addAction(TelecomManager.ACTION_CURRENT_TTY_MODE_CHANGED);
140         filter.addAction(Intent.ACTION_MANAGED_PROFILE_AVAILABLE);
141         filter.addAction(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE);
142         filter.addAction(Intent.ACTION_MANAGED_PROFILE_REMOVED);
143         mContext.registerReceiver(mIntentReceiver, filter, null, mHandler);
144 
145         // listen for user / profile change.
146         try {
147             ActivityManagerNative.getDefault().registerUserSwitchObserver(mUserSwitchListener, TAG);
148         } catch (RemoteException e) {
149             // Ignore
150         }
151 
152         // TTY status
153         mIconController.setIcon(mSlotTty,  R.drawable.stat_sys_tty_mode, null);
154         mIconController.setIconVisibility(mSlotTty, false);
155 
156         // bluetooth status
157         updateBluetooth();
158 
159         // Alarm clock
160         mIconController.setIcon(mSlotAlarmClock, R.drawable.stat_sys_alarm, null);
161         mIconController.setIconVisibility(mSlotAlarmClock, false);
162 
163         // zen
164         mIconController.setIcon(mSlotZen, R.drawable.stat_sys_zen_important, null);
165         mIconController.setIconVisibility(mSlotZen, false);
166 
167         // volume
168         mIconController.setIcon(mSlotVolume, R.drawable.stat_sys_ringer_vibrate, null);
169         mIconController.setIconVisibility(mSlotVolume, false);
170         updateVolumeZen();
171 
172         // cast
173         mIconController.setIcon(mSlotCast, R.drawable.stat_sys_cast, null);
174         mIconController.setIconVisibility(mSlotCast, false);
175         mCast.addCallback(mCastCallback);
176 
177         // hotspot
178         mIconController.setIcon(mSlotHotspot, R.drawable.stat_sys_hotspot,
179                 mContext.getString(R.string.accessibility_status_bar_hotspot));
180         mIconController.setIconVisibility(mSlotHotspot, mHotspot.isHotspotEnabled());
181         mHotspot.addCallback(mHotspotCallback);
182 
183         // managed profile
184         mIconController.setIcon(mSlotManagedProfile, R.drawable.stat_sys_managed_profile_status,
185                 mContext.getString(R.string.accessibility_managed_profile));
186         mIconController.setIconVisibility(mSlotManagedProfile, mManagedProfileIconVisible);
187 
188         // data saver
189         mIconController.setIcon(mSlotDataSaver, R.drawable.stat_sys_data_saver,
190                 context.getString(R.string.accessibility_data_saver_on));
191         mIconController.setIconVisibility(mSlotDataSaver, false);
192         mDataSaver.addListener(this);
193     }
194 
setStatusBarKeyguardViewManager( StatusBarKeyguardViewManager statusBarKeyguardViewManager)195     public void setStatusBarKeyguardViewManager(
196             StatusBarKeyguardViewManager statusBarKeyguardViewManager) {
197         mStatusBarKeyguardViewManager = statusBarKeyguardViewManager;
198     }
199 
setZenMode(int zen)200     public void setZenMode(int zen) {
201         mZen = zen;
202         updateVolumeZen();
203     }
204 
updateAlarm()205     private void updateAlarm() {
206         final AlarmClockInfo alarm = mAlarmManager.getNextAlarmClock(UserHandle.USER_CURRENT);
207         final boolean hasAlarm = alarm != null && alarm.getTriggerTime() > 0;
208         final boolean zenNone = mZen == Global.ZEN_MODE_NO_INTERRUPTIONS;
209         mIconController.setIcon(mSlotAlarmClock, zenNone ? R.drawable.stat_sys_alarm_dim
210                 : R.drawable.stat_sys_alarm, null);
211         mIconController.setIconVisibility(mSlotAlarmClock, mCurrentUserSetup && hasAlarm);
212     }
213 
updateSimState(Intent intent)214     private final void updateSimState(Intent intent) {
215         String stateExtra = intent.getStringExtra(IccCardConstants.INTENT_KEY_ICC_STATE);
216         if (IccCardConstants.INTENT_VALUE_ICC_ABSENT.equals(stateExtra)) {
217             mSimState = IccCardConstants.State.ABSENT;
218         } else if (IccCardConstants.INTENT_VALUE_ICC_CARD_IO_ERROR.equals(stateExtra)) {
219             mSimState = IccCardConstants.State.CARD_IO_ERROR;
220         } else if (IccCardConstants.INTENT_VALUE_ICC_CARD_RESTRICTED.equals(stateExtra)) {
221             mSimState = IccCardConstants.State.CARD_RESTRICTED;
222         } else if (IccCardConstants.INTENT_VALUE_ICC_READY.equals(stateExtra)) {
223             mSimState = IccCardConstants.State.READY;
224         } else if (IccCardConstants.INTENT_VALUE_ICC_LOCKED.equals(stateExtra)) {
225             final String lockedReason =
226                     intent.getStringExtra(IccCardConstants.INTENT_KEY_LOCKED_REASON);
227             if (IccCardConstants.INTENT_VALUE_LOCKED_ON_PIN.equals(lockedReason)) {
228                 mSimState = IccCardConstants.State.PIN_REQUIRED;
229             } else if (IccCardConstants.INTENT_VALUE_LOCKED_ON_PUK.equals(lockedReason)) {
230                 mSimState = IccCardConstants.State.PUK_REQUIRED;
231             } else {
232                 mSimState = IccCardConstants.State.NETWORK_LOCKED;
233             }
234         } else {
235             mSimState = IccCardConstants.State.UNKNOWN;
236         }
237     }
238 
updateVolumeZen()239     private final void updateVolumeZen() {
240         AudioManager audioManager = (AudioManager) mContext.getSystemService(Context.AUDIO_SERVICE);
241 
242         boolean zenVisible = false;
243         int zenIconId = 0;
244         String zenDescription = null;
245 
246         boolean volumeVisible = false;
247         int volumeIconId = 0;
248         String volumeDescription = null;
249 
250         if (DndTile.isVisible(mContext) || DndTile.isCombinedIcon(mContext)) {
251             zenVisible = mZen != Global.ZEN_MODE_OFF;
252             zenIconId = mZen == Global.ZEN_MODE_NO_INTERRUPTIONS
253                     ? R.drawable.stat_sys_dnd_total_silence : R.drawable.stat_sys_dnd;
254             zenDescription = mContext.getString(R.string.quick_settings_dnd_label);
255         } else if (mZen == Global.ZEN_MODE_NO_INTERRUPTIONS) {
256             zenVisible = true;
257             zenIconId = R.drawable.stat_sys_zen_none;
258             zenDescription = mContext.getString(R.string.interruption_level_none);
259         } else if (mZen == Global.ZEN_MODE_IMPORTANT_INTERRUPTIONS) {
260             zenVisible = true;
261             zenIconId = R.drawable.stat_sys_zen_important;
262             zenDescription = mContext.getString(R.string.interruption_level_priority);
263         }
264 
265         if (DndTile.isVisible(mContext) && !DndTile.isCombinedIcon(mContext)
266                 && audioManager.getRingerModeInternal() == AudioManager.RINGER_MODE_SILENT) {
267             volumeVisible = true;
268             volumeIconId = R.drawable.stat_sys_ringer_silent;
269             volumeDescription = mContext.getString(R.string.accessibility_ringer_silent);
270         } else if (mZen != Global.ZEN_MODE_NO_INTERRUPTIONS && mZen != Global.ZEN_MODE_ALARMS &&
271                 audioManager.getRingerModeInternal() == AudioManager.RINGER_MODE_VIBRATE) {
272             volumeVisible = true;
273             volumeIconId = R.drawable.stat_sys_ringer_vibrate;
274             volumeDescription = mContext.getString(R.string.accessibility_ringer_vibrate);
275         }
276 
277         if (zenVisible) {
278             mIconController.setIcon(mSlotZen, zenIconId, zenDescription);
279         }
280         if (zenVisible != mZenVisible) {
281             mIconController.setIconVisibility(mSlotZen, zenVisible);
282             mZenVisible = zenVisible;
283         }
284 
285         if (volumeVisible) {
286             mIconController.setIcon(mSlotVolume, volumeIconId, volumeDescription);
287         }
288         if (volumeVisible != mVolumeVisible) {
289             mIconController.setIconVisibility(mSlotVolume, volumeVisible);
290             mVolumeVisible = volumeVisible;
291         }
292         updateAlarm();
293     }
294 
295     @Override
onBluetoothDevicesChanged()296     public void onBluetoothDevicesChanged() {
297         updateBluetooth();
298     }
299 
300     @Override
onBluetoothStateChange(boolean enabled)301     public void onBluetoothStateChange(boolean enabled) {
302         updateBluetooth();
303     }
304 
updateBluetooth()305     private final void updateBluetooth() {
306         int iconId = R.drawable.stat_sys_data_bluetooth;
307         String contentDescription =
308                 mContext.getString(R.string.accessibility_quick_settings_bluetooth_on);
309         boolean bluetoothEnabled = false;
310         if (mBluetooth != null) {
311             bluetoothEnabled = mBluetooth.isBluetoothEnabled();
312             if (mBluetooth.isBluetoothConnected()) {
313                 iconId = R.drawable.stat_sys_data_bluetooth_connected;
314                 contentDescription = mContext.getString(R.string.accessibility_bluetooth_connected);
315             }
316         }
317 
318         mIconController.setIcon(mSlotBluetooth, iconId, contentDescription);
319         mIconController.setIconVisibility(mSlotBluetooth, bluetoothEnabled);
320     }
321 
updateTTY(Intent intent)322     private final void updateTTY(Intent intent) {
323         int currentTtyMode = intent.getIntExtra(TelecomManager.EXTRA_CURRENT_TTY_MODE,
324                 TelecomManager.TTY_MODE_OFF);
325         boolean enabled = currentTtyMode != TelecomManager.TTY_MODE_OFF;
326 
327         if (DEBUG) Log.v(TAG, "updateTTY: enabled: " + enabled);
328 
329         if (enabled) {
330             // TTY is on
331             if (DEBUG) Log.v(TAG, "updateTTY: set TTY on");
332             mIconController.setIcon(mSlotTty, R.drawable.stat_sys_tty_mode,
333                     mContext.getString(R.string.accessibility_tty_enabled));
334             mIconController.setIconVisibility(mSlotTty, true);
335         } else {
336             // TTY is off
337             if (DEBUG) Log.v(TAG, "updateTTY: set TTY off");
338             mIconController.setIconVisibility(mSlotTty, false);
339         }
340     }
341 
updateCast()342     private void updateCast() {
343         boolean isCasting = false;
344         for (CastDevice device : mCast.getCastDevices()) {
345             if (device.state == CastDevice.STATE_CONNECTING
346                     || device.state == CastDevice.STATE_CONNECTED) {
347                 isCasting = true;
348                 break;
349             }
350         }
351         if (DEBUG) Log.v(TAG, "updateCast: isCasting: " + isCasting);
352         mHandler.removeCallbacks(mRemoveCastIconRunnable);
353         if (isCasting) {
354             mIconController.setIcon(mSlotCast, R.drawable.stat_sys_cast,
355                     mContext.getString(R.string.accessibility_casting));
356             mIconController.setIconVisibility(mSlotCast, true);
357         } else {
358             // don't turn off the screen-record icon for a few seconds, just to make sure the user
359             // has seen it
360             if (DEBUG) Log.v(TAG, "updateCast: hiding icon in 3 sec...");
361             mHandler.postDelayed(mRemoveCastIconRunnable, 3000);
362         }
363     }
364 
updateQuietState()365     private void updateQuietState() {
366         mManagedProfileInQuietMode = false;
367         int currentUserId = ActivityManager.getCurrentUser();
368         for (UserInfo ui : mUserManager.getEnabledProfiles(currentUserId)) {
369             if (ui.isManagedProfile() && ui.isQuietModeEnabled()) {
370                 mManagedProfileInQuietMode = true;
371                 return;
372             }
373         }
374     }
375 
profileChanged(int userId)376     private void profileChanged(int userId) {
377         UserInfo user = null;
378         if (userId == UserHandle.USER_CURRENT) {
379             try {
380                 user = ActivityManagerNative.getDefault().getCurrentUser();
381             } catch (RemoteException e) {
382                 // Ignore
383             }
384         } else {
385             user = mUserManager.getUserInfo(userId);
386         }
387 
388         mManagedProfileFocused = user != null && user.isManagedProfile();
389         if (DEBUG) Log.v(TAG, "profileChanged: mManagedProfileFocused: " + mManagedProfileFocused);
390         // Actually update the icon later when transition starts.
391     }
392 
updateManagedProfile()393     private void updateManagedProfile() {
394         if (DEBUG) Log.v(TAG, "updateManagedProfile: mManagedProfileFocused: "
395                 + mManagedProfileFocused);
396         final boolean showIcon;
397         if (mManagedProfileFocused && !mStatusBarKeyguardViewManager.isShowing()) {
398             showIcon = true;
399             mIconController.setIcon(mSlotManagedProfile,
400                     R.drawable.stat_sys_managed_profile_status,
401                     mContext.getString(R.string.accessibility_managed_profile));
402         } else if (mManagedProfileInQuietMode) {
403             showIcon = true;
404             mIconController.setIcon(mSlotManagedProfile,
405                     R.drawable.stat_sys_managed_profile_status_off,
406                     mContext.getString(R.string.accessibility_managed_profile));
407         } else {
408             showIcon = false;
409         }
410         if (mManagedProfileIconVisible != showIcon) {
411             mIconController.setIconVisibility(mSlotManagedProfile, showIcon);
412             mManagedProfileIconVisible = showIcon;
413         }
414     }
415 
416     private final SynchronousUserSwitchObserver mUserSwitchListener =
417             new SynchronousUserSwitchObserver() {
418                 @Override
419                 public void onUserSwitching(int newUserId) throws RemoteException {
420                     mHandler.post(new Runnable() {
421                         @Override
422                         public void run() {
423                             mUserInfoController.reloadUserInfo();
424                         }
425                     });
426                 }
427 
428                 @Override
429                 public void onUserSwitchComplete(int newUserId) throws RemoteException {
430                     mHandler.post(new Runnable() {
431                         @Override
432                         public void run() {
433                             updateAlarm();
434                             profileChanged(newUserId);
435                             updateQuietState();
436                             updateManagedProfile();
437                         }
438                     });
439                 }
440 
441                 @Override
442                 public void onForegroundProfileSwitch(int newProfileId) {
443                     mHandler.post(new Runnable() {
444                         @Override
445                         public void run() {
446                             profileChanged(newProfileId);
447                         }
448                     });
449                 }
450             };
451 
452     private final HotspotController.Callback mHotspotCallback = new HotspotController.Callback() {
453         @Override
454         public void onHotspotChanged(boolean enabled) {
455             mIconController.setIconVisibility(mSlotHotspot, enabled);
456         }
457     };
458 
459     private final CastController.Callback mCastCallback = new CastController.Callback() {
460         @Override
461         public void onCastDevicesChanged() {
462             updateCast();
463         }
464     };
465 
appTransitionStarting(long startTime, long duration)466     public void appTransitionStarting(long startTime, long duration) {
467         updateManagedProfile();
468     }
469 
notifyKeyguardShowingChanged()470     public void notifyKeyguardShowingChanged() {
471         updateManagedProfile();
472     }
473 
setCurrentUserSetup(boolean userSetup)474     public void setCurrentUserSetup(boolean userSetup) {
475         if (mCurrentUserSetup == userSetup) return;
476         mCurrentUserSetup = userSetup;
477         updateAlarm();
478         updateQuietState();
479     }
480 
481     @Override
onRotationLockStateChanged(boolean rotationLocked, boolean affordanceVisible)482     public void onRotationLockStateChanged(boolean rotationLocked, boolean affordanceVisible) {
483         boolean portrait = RotationLockTile.isCurrentOrientationLockPortrait(
484                 mRotationLockController, mContext);
485         if (rotationLocked) {
486             if (portrait) {
487                 mIconController.setIcon(mSlotRotate, R.drawable.stat_sys_rotate_portrait,
488                         mContext.getString(R.string.accessibility_rotation_lock_on_portrait));
489             } else {
490                 mIconController.setIcon(mSlotRotate, R.drawable.stat_sys_rotate_landscape,
491                         mContext.getString(R.string.accessibility_rotation_lock_on_landscape));
492             }
493             mIconController.setIconVisibility(mSlotRotate, true);
494         } else {
495             mIconController.setIconVisibility(mSlotRotate, false);
496         }
497     }
498 
updateHeadsetPlug(Intent intent)499     private void updateHeadsetPlug(Intent intent) {
500         boolean connected = intent.getIntExtra("state", 0) != 0;
501         boolean hasMic = intent.getIntExtra("microphone", 0) != 0;
502         if (connected) {
503             String contentDescription = mContext.getString(hasMic
504                     ? R.string.accessibility_status_bar_headset
505                     : R.string.accessibility_status_bar_headphones);
506             mIconController.setIcon(mSlotHeadset, hasMic ? R.drawable.ic_headset_mic
507                     : R.drawable.ic_headset, contentDescription);
508             mIconController.setIconVisibility(mSlotHeadset, true);
509         } else {
510             mIconController.setIconVisibility(mSlotHeadset, false);
511         }
512     }
513 
514     @Override
onDataSaverChanged(boolean isDataSaving)515     public void onDataSaverChanged(boolean isDataSaving) {
516         mIconController.setIconVisibility(mSlotDataSaver, isDataSaving);
517     }
518 
519     private BroadcastReceiver mIntentReceiver = new BroadcastReceiver() {
520         @Override
521         public void onReceive(Context context, Intent intent) {
522             String action = intent.getAction();
523             if (action.equals(AlarmManager.ACTION_NEXT_ALARM_CLOCK_CHANGED)) {
524                 updateAlarm();
525             } else if (action.equals(AudioManager.RINGER_MODE_CHANGED_ACTION) ||
526                     action.equals(AudioManager.INTERNAL_RINGER_MODE_CHANGED_ACTION)) {
527                 updateVolumeZen();
528             } else if (action.equals(TelephonyIntents.ACTION_SIM_STATE_CHANGED)) {
529                 updateSimState(intent);
530             } else if (action.equals(TelecomManager.ACTION_CURRENT_TTY_MODE_CHANGED)) {
531                 updateTTY(intent);
532             } else if (action.equals(Intent.ACTION_MANAGED_PROFILE_AVAILABLE) ||
533                     action.equals(Intent.ACTION_MANAGED_PROFILE_UNAVAILABLE) ||
534                     action.equals(Intent.ACTION_MANAGED_PROFILE_REMOVED)) {
535                 updateQuietState();
536                 updateManagedProfile();
537             } else if (action.equals(AudioManager.ACTION_HEADSET_PLUG)) {
538                 updateHeadsetPlug(intent);
539             }
540         }
541     };
542 
543     private Runnable mRemoveCastIconRunnable = new Runnable() {
544         @Override
545         public void run() {
546             if (DEBUG) Log.v(TAG, "updateCast: hiding icon NOW");
547             mIconController.setIconVisibility(mSlotCast, false);
548         }
549     };
550 }
551