/* * Copyright (C) 2006 The Android Open Source Project * * Licensed under the Apache License, Version 2.0 (the "License"); * you may not use this file except in compliance with the License. * You may obtain a copy of the License at * * http://www.apache.org/licenses/LICENSE-2.0 * * Unless required by applicable law or agreed to in writing, software * distributed under the License is distributed on an "AS IS" BASIS, * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. * See the License for the specific language governing permissions and * limitations under the License. */ package com.android.phone; import android.app.Notification; import android.app.NotificationManager; import android.app.PendingIntent; import android.app.StatusBarManager; import android.content.ComponentName; import android.content.Context; import android.content.Intent; import android.content.SharedPreferences; import android.content.pm.UserInfo; import android.net.Uri; import android.os.SystemProperties; import android.os.UserHandle; import android.os.UserManager; import android.preference.PreferenceManager; import android.provider.ContactsContract.PhoneLookup; import android.provider.Settings; import android.telecom.PhoneAccount; import android.telephony.PhoneNumberUtils; import android.telephony.ServiceState; import android.text.TextUtils; import android.util.Log; import android.widget.Toast; import com.android.internal.telephony.Phone; import com.android.internal.telephony.PhoneBase; import com.android.internal.telephony.TelephonyCapabilities; import java.util.List; /** * NotificationManager-related utility code for the Phone app. * * This is a singleton object which acts as the interface to the * framework's NotificationManager, and is used to display status bar * icons and control other status bar-related behavior. * * @see PhoneGlobals.notificationMgr */ public class NotificationMgr { private static final String LOG_TAG = "NotificationMgr"; private static final boolean DBG = (PhoneGlobals.DBG_LEVEL >= 1) && (SystemProperties.getInt("ro.debuggable", 0) == 1); // Do not check in with VDBG = true, since that may write PII to the system log. private static final boolean VDBG = false; // notification types static final int MMI_NOTIFICATION = 1; static final int NETWORK_SELECTION_NOTIFICATION = 2; static final int VOICEMAIL_NOTIFICATION = 3; static final int CALL_FORWARD_NOTIFICATION = 4; static final int DATA_DISCONNECTED_ROAMING_NOTIFICATION = 5; static final int SELECTED_OPERATOR_FAIL_NOTIFICATION = 6; /** The singleton NotificationMgr instance. */ private static NotificationMgr sInstance; private PhoneGlobals mApp; private Phone mPhone; private Context mContext; private NotificationManager mNotificationManager; private StatusBarManager mStatusBarManager; private UserManager mUserManager; private Toast mToast; public StatusBarHelper statusBarHelper; // used to track the notification of selected network unavailable private boolean mSelectedUnavailableNotify = false; // Retry params for the getVoiceMailNumber() call; see updateMwi(). private static final int MAX_VM_NUMBER_RETRIES = 5; private static final int VM_NUMBER_RETRY_DELAY_MILLIS = 10000; private int mVmNumberRetriesRemaining = MAX_VM_NUMBER_RETRIES; /** * Private constructor (this is a singleton). * @see #init(PhoneGlobals) */ private NotificationMgr(PhoneGlobals app) { mApp = app; mContext = app; mNotificationManager = (NotificationManager) app.getSystemService(Context.NOTIFICATION_SERVICE); mStatusBarManager = (StatusBarManager) app.getSystemService(Context.STATUS_BAR_SERVICE); mUserManager = (UserManager) app.getSystemService(Context.USER_SERVICE); mPhone = app.phone; // TODO: better style to use mCM.getDefaultPhone() everywhere instead statusBarHelper = new StatusBarHelper(); } /** * Initialize the singleton NotificationMgr instance. * * This is only done once, at startup, from PhoneApp.onCreate(). * From then on, the NotificationMgr instance is available via the * PhoneApp's public "notificationMgr" field, which is why there's no * getInstance() method here. */ /* package */ static NotificationMgr init(PhoneGlobals app) { synchronized (NotificationMgr.class) { if (sInstance == null) { sInstance = new NotificationMgr(app); } else { Log.wtf(LOG_TAG, "init() called multiple times! sInstance = " + sInstance); } return sInstance; } } /** * Helper class that's a wrapper around the framework's * StatusBarManager.disable() API. * * This class is used to control features like: * * - Disabling the status bar "notification windowshade" * while the in-call UI is up * * - Disabling notification alerts (audible or vibrating) * while a phone call is active * * - Disabling navigation via the system bar (the "soft buttons" at * the bottom of the screen on devices with no hard buttons) * * We control these features through a single point of control to make * sure that the various StatusBarManager.disable() calls don't * interfere with each other. */ public class StatusBarHelper { // Current desired state of status bar / system bar behavior private boolean mIsNotificationEnabled = true; private boolean mIsExpandedViewEnabled = true; private boolean mIsSystemBarNavigationEnabled = true; private StatusBarHelper () { } /** * Enables or disables auditory / vibrational alerts. * * (We disable these any time a voice call is active, regardless * of whether or not the in-call UI is visible.) */ public void enableNotificationAlerts(boolean enable) { if (mIsNotificationEnabled != enable) { mIsNotificationEnabled = enable; updateStatusBar(); } } /** * Enables or disables the expanded view of the status bar * (i.e. the ability to pull down the "notification windowshade"). * * (This feature is disabled by the InCallScreen while the in-call * UI is active.) */ public void enableExpandedView(boolean enable) { if (mIsExpandedViewEnabled != enable) { mIsExpandedViewEnabled = enable; updateStatusBar(); } } /** * Enables or disables the navigation via the system bar (the * "soft buttons" at the bottom of the screen) * * (This feature is disabled while an incoming call is ringing, * because it's easy to accidentally touch the system bar while * pulling the phone out of your pocket.) */ public void enableSystemBarNavigation(boolean enable) { if (mIsSystemBarNavigationEnabled != enable) { mIsSystemBarNavigationEnabled = enable; updateStatusBar(); } } /** * Updates the status bar to reflect the current desired state. */ private void updateStatusBar() { int state = StatusBarManager.DISABLE_NONE; if (!mIsExpandedViewEnabled) { state |= StatusBarManager.DISABLE_EXPAND; } if (!mIsNotificationEnabled) { state |= StatusBarManager.DISABLE_NOTIFICATION_ALERTS; } if (!mIsSystemBarNavigationEnabled) { // Disable *all* possible navigation via the system bar. state |= StatusBarManager.DISABLE_HOME; state |= StatusBarManager.DISABLE_RECENT; state |= StatusBarManager.DISABLE_BACK; state |= StatusBarManager.DISABLE_SEARCH; } if (DBG) log("updateStatusBar: state = 0x" + Integer.toHexString(state)); mStatusBarManager.disable(state); } } /** The projection to use when querying the phones table */ static final String[] PHONES_PROJECTION = new String[] { PhoneLookup.NUMBER, PhoneLookup.DISPLAY_NAME, PhoneLookup._ID }; /** * Updates the message waiting indicator (voicemail) notification. * * @param visible true if there are messages waiting */ /* package */ void updateMwi(boolean visible) { if (DBG) log("updateMwi(): " + visible); if (visible) { int resId = android.R.drawable.stat_notify_voicemail; // This Notification can get a lot fancier once we have more // information about the current voicemail messages. // (For example, the current voicemail system can't tell // us the caller-id or timestamp of a message, or tell us the // message count.) // But for now, the UI is ultra-simple: if the MWI indication // is supposed to be visible, just show a single generic // notification. String notificationTitle = mContext.getString(R.string.notification_voicemail_title); String vmNumber = mPhone.getVoiceMailNumber(); if (DBG) log("- got vm number: '" + vmNumber + "'"); // Watch out: vmNumber may be null, for two possible reasons: // // (1) This phone really has no voicemail number // // (2) This phone *does* have a voicemail number, but // the SIM isn't ready yet. // // Case (2) *does* happen in practice if you have voicemail // messages when the device first boots: we get an MWI // notification as soon as we register on the network, but the // SIM hasn't finished loading yet. // // So handle case (2) by retrying the lookup after a short // delay. if ((vmNumber == null) && !mPhone.getIccRecordsLoaded()) { if (DBG) log("- Null vm number: SIM records not loaded (yet)..."); // TODO: rather than retrying after an arbitrary delay, it // would be cleaner to instead just wait for a // SIM_RECORDS_LOADED notification. // (Unfortunately right now there's no convenient way to // get that notification in phone app code. We'd first // want to add a call like registerForSimRecordsLoaded() // to Phone.java and GSMPhone.java, and *then* we could // listen for that in the CallNotifier class.) // Limit the number of retries (in case the SIM is broken // or missing and can *never* load successfully.) if (mVmNumberRetriesRemaining-- > 0) { if (DBG) log(" - Retrying in " + VM_NUMBER_RETRY_DELAY_MILLIS + " msec..."); mApp.notifier.sendMwiChangedDelayed(VM_NUMBER_RETRY_DELAY_MILLIS); return; } else { Log.w(LOG_TAG, "NotificationMgr.updateMwi: getVoiceMailNumber() failed after " + MAX_VM_NUMBER_RETRIES + " retries; giving up."); // ...and continue with vmNumber==null, just as if the // phone had no VM number set up in the first place. } } if (TelephonyCapabilities.supportsVoiceMessageCount(mPhone)) { int vmCount = mPhone.getVoiceMessageCount(); String titleFormat = mContext.getString(R.string.notification_voicemail_title_count); notificationTitle = String.format(titleFormat, vmCount); } String notificationText; if (TextUtils.isEmpty(vmNumber)) { notificationText = mContext.getString( R.string.notification_voicemail_no_vm_number); } else { notificationText = String.format( mContext.getString(R.string.notification_voicemail_text_format), PhoneNumberUtils.formatNumber(vmNumber)); } Intent intent = new Intent(Intent.ACTION_CALL, Uri.fromParts(PhoneAccount.SCHEME_VOICEMAIL, "", null)); PendingIntent pendingIntent = PendingIntent.getActivity(mContext, 0, intent, 0); SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(mContext); Uri ringtoneUri; String uriString = prefs.getString( CallFeaturesSetting.BUTTON_VOICEMAIL_NOTIFICATION_RINGTONE_KEY, null); if (!TextUtils.isEmpty(uriString)) { ringtoneUri = Uri.parse(uriString); } else { ringtoneUri = Settings.System.DEFAULT_NOTIFICATION_URI; } Notification.Builder builder = new Notification.Builder(mContext); builder.setSmallIcon(resId) .setWhen(System.currentTimeMillis()) .setContentTitle(notificationTitle) .setContentText(notificationText) .setContentIntent(pendingIntent) .setSound(ringtoneUri) .setColor(mContext.getResources().getColor(R.color.dialer_theme_color)) .setOngoing(true); CallFeaturesSetting.migrateVoicemailVibrationSettingsIfNeeded(prefs); final boolean vibrate = prefs.getBoolean( CallFeaturesSetting.BUTTON_VOICEMAIL_NOTIFICATION_VIBRATE_KEY, false); if (vibrate) { builder.setDefaults(Notification.DEFAULT_VIBRATE); } final Notification notification = builder.build(); List users = mUserManager.getUsers(true); for (int i = 0; i < users.size(); i++) { final UserInfo user = users.get(i); final UserHandle userHandle = user.getUserHandle(); if (!mUserManager.hasUserRestriction( UserManager.DISALLOW_OUTGOING_CALLS, userHandle) && !user.isManagedProfile()) { mNotificationManager.notifyAsUser( null /* tag */, VOICEMAIL_NOTIFICATION, notification, userHandle); } } } else { mNotificationManager.cancelAsUser( null /* tag */, VOICEMAIL_NOTIFICATION, UserHandle.ALL); } } /** * Updates the message call forwarding indicator notification. * * @param visible true if there are messages waiting */ /* package */ void updateCfi(boolean visible) { if (DBG) log("updateCfi(): " + visible); if (visible) { // If Unconditional Call Forwarding (forward all calls) for VOICE // is enabled, just show a notification. We'll default to expanded // view for now, so the there is less confusion about the icon. If // it is deemed too weird to have CF indications as expanded views, // then we'll flip the flag back. // TODO: We may want to take a look to see if the notification can // display the target to forward calls to. This will require some // effort though, since there are multiple layers of messages that // will need to propagate that information. Notification.Builder builder = new Notification.Builder(mContext) .setSmallIcon(R.drawable.stat_sys_phone_call_forward) .setContentTitle(mContext.getString(R.string.labelCF)) .setContentText(mContext.getString(R.string.sum_cfu_enabled_indicator)) .setShowWhen(false) .setOngoing(true); Intent intent = new Intent(Intent.ACTION_MAIN); intent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK); intent.setClassName("com.android.phone", "com.android.phone.CallFeaturesSetting"); PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0); List users = mUserManager.getUsers(true); for (int i = 0; i < users.size(); i++) { UserHandle userHandle = users.get(i).getUserHandle(); builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); mNotificationManager.notifyAsUser( null /* tag */, CALL_FORWARD_NOTIFICATION, builder.build(), userHandle); } } else { mNotificationManager.cancelAsUser( null /* tag */, CALL_FORWARD_NOTIFICATION, UserHandle.ALL); } } /** * Shows the "data disconnected due to roaming" notification, which * appears when you lose data connectivity because you're roaming and * you have the "data roaming" feature turned off. */ /* package */ void showDataDisconnectedRoaming() { if (DBG) log("showDataDisconnectedRoaming()..."); // "Mobile network settings" screen / dialog Intent intent = new Intent(mContext, com.android.phone.MobileNetworkSettings.class); PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0); final CharSequence contentText = mContext.getText(R.string.roaming_reenable_message); final Notification.Builder builder = new Notification.Builder(mContext) .setSmallIcon(android.R.drawable.stat_sys_warning) .setContentTitle(mContext.getText(R.string.roaming)) .setColor(mContext.getResources().getColor(R.color.dialer_theme_color)) .setContentText(contentText); List users = mUserManager.getUsers(true); for (int i = 0; i < users.size(); i++) { UserHandle userHandle = users.get(i).getUserHandle(); builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); final Notification notif = new Notification.BigTextStyle(builder).bigText(contentText).build(); mNotificationManager.notifyAsUser( null /* tag */, DATA_DISCONNECTED_ROAMING_NOTIFICATION, notif, userHandle); } } /** * Turns off the "data disconnected due to roaming" notification. */ /* package */ void hideDataDisconnectedRoaming() { if (DBG) log("hideDataDisconnectedRoaming()..."); mNotificationManager.cancel(DATA_DISCONNECTED_ROAMING_NOTIFICATION); } /** * Display the network selection "no service" notification * @param operator is the numeric operator number */ private void showNetworkSelection(String operator) { if (DBG) log("showNetworkSelection(" + operator + ")..."); Notification.Builder builder = new Notification.Builder(mContext) .setSmallIcon(android.R.drawable.stat_sys_warning) .setContentTitle(mContext.getString(R.string.notification_network_selection_title)) .setContentText( mContext.getString(R.string.notification_network_selection_text, operator)) .setShowWhen(false) .setOngoing(true); // create the target network operators settings intent Intent intent = new Intent(Intent.ACTION_MAIN); intent.setFlags(Intent.FLAG_ACTIVITY_NEW_TASK | Intent.FLAG_ACTIVITY_RESET_TASK_IF_NEEDED); // Use NetworkSetting to handle the selection intent intent.setComponent(new ComponentName("com.android.phone", "com.android.phone.NetworkSetting")); PendingIntent contentIntent = PendingIntent.getActivity(mContext, 0, intent, 0); List users = mUserManager.getUsers(true); for (int i = 0; i < users.size(); i++) { UserHandle userHandle = users.get(i).getUserHandle(); builder.setContentIntent(userHandle.isOwner() ? contentIntent : null); mNotificationManager.notifyAsUser( null /* tag */, SELECTED_OPERATOR_FAIL_NOTIFICATION, builder.build(), userHandle); } } /** * Turn off the network selection "no service" notification */ private void cancelNetworkSelection() { if (DBG) log("cancelNetworkSelection()..."); mNotificationManager.cancelAsUser( null /* tag */, SELECTED_OPERATOR_FAIL_NOTIFICATION, UserHandle.ALL); } /** * Update notification about no service of user selected operator * * @param serviceState Phone service state */ void updateNetworkSelection(int serviceState) { if (TelephonyCapabilities.supportsNetworkSelection(mPhone)) { // get the shared preference of network_selection. // empty is auto mode, otherwise it is the operator alpha name // in case there is no operator name, check the operator numeric SharedPreferences sp = PreferenceManager.getDefaultSharedPreferences(mContext); String networkSelection = sp.getString(PhoneBase.NETWORK_SELECTION_NAME_KEY, ""); if (TextUtils.isEmpty(networkSelection)) { networkSelection = sp.getString(PhoneBase.NETWORK_SELECTION_KEY, ""); } if (DBG) log("updateNetworkSelection()..." + "state = " + serviceState + " new network " + networkSelection); if (serviceState == ServiceState.STATE_OUT_OF_SERVICE && !TextUtils.isEmpty(networkSelection)) { if (!mSelectedUnavailableNotify) { showNetworkSelection(networkSelection); mSelectedUnavailableNotify = true; } } else { if (mSelectedUnavailableNotify) { cancelNetworkSelection(); mSelectedUnavailableNotify = false; } } } } /* package */ void postTransientNotification(int notifyId, CharSequence msg) { if (mToast != null) { mToast.cancel(); } mToast = Toast.makeText(mContext, msg, Toast.LENGTH_LONG); mToast.show(); } private void log(String msg) { Log.d(LOG_TAG, msg); } }