blob: 56e29f07a3052288de943d01693c4a25521212f7 [file] [log] [blame]
/*
* Copyright (C) 2011 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.cellbroadcastreceiver;
import android.app.KeyguardManager;
import android.app.Notification;
import android.app.NotificationManager;
import android.app.PendingIntent;
import android.app.Service;
import android.content.Context;
import android.content.Intent;
import android.content.SharedPreferences;
import android.os.Bundle;
import android.os.IBinder;
import android.os.UserHandle;
import android.preference.PreferenceManager;
import android.provider.Telephony;
import android.telephony.CellBroadcastMessage;
import android.telephony.SmsCbCmasInfo;
import android.telephony.SmsCbLocation;
import android.telephony.SmsCbMessage;
import android.util.Log;
import java.util.ArrayList;
import java.util.HashSet;
/**
* This service manages the display and animation of broadcast messages.
* Emergency messages display with a flashing animated exclamation mark icon,
* and an alert tone is played when the alert is first shown to the user
* (but not when the user views a previously received broadcast).
*/
public class CellBroadcastAlertService extends Service {
private static final String TAG = "CellBroadcastAlertService";
/** Intent action to display alert dialog/notification, after verifying the alert is new. */
static final String SHOW_NEW_ALERT_ACTION = "cellbroadcastreceiver.SHOW_NEW_ALERT";
/** Use the same notification ID for non-emergency alerts. */
static final int NOTIFICATION_ID = 1;
/** Sticky broadcast for latest area info broadcast received. */
static final String CB_AREA_INFO_RECEIVED_ACTION =
"android.cellbroadcastreceiver.CB_AREA_INFO_RECEIVED";
/** Container for message ID and geographical scope, for duplicate message detection. */
private static final class MessageIdAndScope {
private final int mMessageId;
private final SmsCbLocation mLocation;
MessageIdAndScope(int messageId, SmsCbLocation location) {
mMessageId = messageId;
mLocation = location;
}
@Override
public int hashCode() {
return mMessageId * 31 + mLocation.hashCode();
}
@Override
public boolean equals(Object o) {
if (o == this) {
return true;
}
if (o instanceof MessageIdAndScope) {
MessageIdAndScope other = (MessageIdAndScope) o;
return (mMessageId == other.mMessageId && mLocation.equals(other.mLocation));
}
return false;
}
@Override
public String toString() {
return "{messageId: " + mMessageId + " location: " + mLocation.toString() + '}';
}
}
/** Cache of received message IDs, for duplicate message detection. */
private static final HashSet<MessageIdAndScope> sCmasIdSet = new HashSet<MessageIdAndScope>(8);
/** Maximum number of message IDs to save before removing the oldest message ID. */
private static final int MAX_MESSAGE_ID_SIZE = 65535;
/** List of message IDs received, for removing oldest ID when max message IDs are received. */
private static final ArrayList<MessageIdAndScope> sCmasIdList =
new ArrayList<MessageIdAndScope>(8);
/** Index of message ID to replace with new message ID when max message IDs are received. */
private static int sCmasIdListIndex = 0;
@Override
public int onStartCommand(Intent intent, int flags, int startId) {
String action = intent.getAction();
if (Telephony.Sms.Intents.SMS_EMERGENCY_CB_RECEIVED_ACTION.equals(action) ||
Telephony.Sms.Intents.SMS_CB_RECEIVED_ACTION.equals(action)) {
handleCellBroadcastIntent(intent);
} else if (SHOW_NEW_ALERT_ACTION.equals(action)) {
showNewAlert(intent);
} else {
Log.e(TAG, "Unrecognized intent action: " + action);
}
return START_NOT_STICKY;
}
private void handleCellBroadcastIntent(Intent intent) {
Bundle extras = intent.getExtras();
if (extras == null) {
Log.e(TAG, "received SMS_CB_RECEIVED_ACTION with no extras!");
return;
}
SmsCbMessage message = (SmsCbMessage) extras.get("message");
if (message == null) {
Log.e(TAG, "received SMS_CB_RECEIVED_ACTION with no message extra");
return;
}
final CellBroadcastMessage cbm = new CellBroadcastMessage(message);
if (!isMessageEnabledByUser(cbm)) {
Log.d(TAG, "ignoring alert of type " + cbm.getServiceCategory() +
" by user preference");
return;
}
// Check for duplicate message IDs according to CMAS carrier requirements. Message IDs
// are stored in volatile memory. If the maximum of 65535 messages is reached, the
// message ID of the oldest message is deleted from the list.
MessageIdAndScope newMessageId = new MessageIdAndScope(message.getSerialNumber(),
message.getLocation());
// Add the new message ID to the list. It's okay if this is a duplicate message ID,
// because the list is only used for removing old message IDs from the hash set.
if (sCmasIdList.size() < MAX_MESSAGE_ID_SIZE) {
sCmasIdList.add(newMessageId);
} else {
// Get oldest message ID from the list and replace with the new message ID.
MessageIdAndScope oldestId = sCmasIdList.get(sCmasIdListIndex);
sCmasIdList.set(sCmasIdListIndex, newMessageId);
Log.d(TAG, "message ID limit reached, removing oldest message ID " + oldestId);
// Remove oldest message ID from the set.
sCmasIdSet.remove(oldestId);
if (++sCmasIdListIndex >= MAX_MESSAGE_ID_SIZE) {
sCmasIdListIndex = 0;
}
}
// Set.add() returns false if message ID has already been added
if (!sCmasIdSet.add(newMessageId)) {
Log.d(TAG, "ignoring duplicate alert with " + newMessageId);
return;
}
final Intent alertIntent = new Intent(SHOW_NEW_ALERT_ACTION);
alertIntent.setClass(this, CellBroadcastAlertService.class);
alertIntent.putExtra("message", cbm);
// write to database on a background thread
new CellBroadcastContentProvider.AsyncCellBroadcastTask(getContentResolver())
.execute(new CellBroadcastContentProvider.CellBroadcastOperation() {
@Override
public boolean execute(CellBroadcastContentProvider provider) {
if (provider.insertNewBroadcast(cbm)) {
// new message, show the alert or notification on UI thread
startService(alertIntent);
return true;
} else {
return false;
}
}
});
}
private void showNewAlert(Intent intent) {
Bundle extras = intent.getExtras();
if (extras == null) {
Log.e(TAG, "received SHOW_NEW_ALERT_ACTION with no extras!");
return;
}
CellBroadcastMessage cbm = (CellBroadcastMessage) extras.get("message");
if (cbm == null) {
Log.e(TAG, "received SHOW_NEW_ALERT_ACTION with no message extra");
return;
}
if (CellBroadcastConfigService.isEmergencyAlertMessage(cbm)) {
// start alert sound / vibration / TTS and display full-screen alert
openEmergencyAlertNotification(cbm);
} else {
// add notification to the bar
addToNotificationBar(cbm);
}
}
/**
* Filter out broadcasts on the test channels that the user has not enabled,
* and types of notifications that the user is not interested in receiving.
* This allows us to enable an entire range of message identifiers in the
* radio and not have to explicitly disable the message identifiers for
* test broadcasts. In the unlikely event that the default shared preference
* values were not initialized in CellBroadcastReceiverApp, the second parameter
* to the getBoolean() calls match the default values in res/xml/preferences.xml.
*
* @param message the message to check
* @return true if the user has enabled this message type; false otherwise
*/
private boolean isMessageEnabledByUser(CellBroadcastMessage message) {
if (message.isEtwsTestMessage()) {
return PreferenceManager.getDefaultSharedPreferences(this)
.getBoolean(CellBroadcastSettings.KEY_ENABLE_ETWS_TEST_ALERTS, false);
}
if (message.isCmasMessage()) {
switch (message.getCmasMessageClass()) {
case SmsCbCmasInfo.CMAS_CLASS_EXTREME_THREAT:
return PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
CellBroadcastSettings.KEY_ENABLE_CMAS_EXTREME_THREAT_ALERTS, true);
case SmsCbCmasInfo.CMAS_CLASS_SEVERE_THREAT:
return PreferenceManager.getDefaultSharedPreferences(this).getBoolean(
CellBroadcastSettings.KEY_ENABLE_CMAS_SEVERE_THREAT_ALERTS, true);
case SmsCbCmasInfo.CMAS_CLASS_CHILD_ABDUCTION_EMERGENCY:
return PreferenceManager.getDefaultSharedPreferences(this)
.getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_AMBER_ALERTS, true);
case SmsCbCmasInfo.CMAS_CLASS_REQUIRED_MONTHLY_TEST:
case SmsCbCmasInfo.CMAS_CLASS_CMAS_EXERCISE:
case SmsCbCmasInfo.CMAS_CLASS_OPERATOR_DEFINED_USE:
return PreferenceManager.getDefaultSharedPreferences(this)
.getBoolean(CellBroadcastSettings.KEY_ENABLE_CMAS_TEST_ALERTS, false);
default:
return true; // presidential-level CMAS alerts are always enabled
}
}
if (message.getServiceCategory() == 50) {
// save latest area info broadcast for Settings display and send as broadcast
CellBroadcastReceiverApp.setLatestAreaInfo(message);
Intent intent = new Intent(CB_AREA_INFO_RECEIVED_ACTION);
intent.putExtra("message", message);
sendBroadcastAsUser(intent, UserHandle.ALL,
android.Manifest.permission.READ_PHONE_STATE);
return false; // area info broadcasts are displayed in Settings status screen
}
return true; // other broadcast messages are always enabled
}
/**
* Display a full-screen alert message for emergency alerts.
* @param message the alert to display
*/
private void openEmergencyAlertNotification(CellBroadcastMessage message) {
// Acquire a CPU wake lock until the alert dialog and audio start playing.
CellBroadcastAlertWakeLock.acquireScreenCpuWakeLock(this);
// Close dialogs and window shade
Intent closeDialogs = new Intent(Intent.ACTION_CLOSE_SYSTEM_DIALOGS);
sendBroadcast(closeDialogs);
// start audio/vibration/speech service for emergency alerts
Intent audioIntent = new Intent(this, CellBroadcastAlertAudio.class);
audioIntent.setAction(CellBroadcastAlertAudio.ACTION_START_ALERT_AUDIO);
SharedPreferences prefs = PreferenceManager.getDefaultSharedPreferences(this);
int duration; // alert audio duration in ms
if (message.isCmasMessage()) {
// CMAS requirement: duration of the audio attention signal is 10.5 seconds.
duration = 10500;
} else {
duration = Integer.parseInt(prefs.getString(
CellBroadcastSettings.KEY_ALERT_SOUND_DURATION,
CellBroadcastSettings.ALERT_SOUND_DEFAULT_DURATION)) * 1000;
}
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_DURATION_EXTRA, duration);
if (message.isEtwsMessage()) {
// For ETWS, always vibrate, even in silent mode.
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_VIBRATE_EXTRA, true);
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_ETWS_VIBRATE_EXTRA, true);
} else {
// For other alerts, vibration can be disabled in app settings.
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_VIBRATE_EXTRA,
prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_VIBRATE, true));
}
String messageBody = message.getMessageBody();
if (prefs.getBoolean(CellBroadcastSettings.KEY_ENABLE_ALERT_SPEECH, true)) {
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_MESSAGE_BODY, messageBody);
String language = message.getLanguageCode();
if (message.isEtwsMessage() && !"ja".equals(language)) {
Log.w(TAG, "bad language code for ETWS - using Japanese TTS");
language = "ja";
} else if (message.isCmasMessage() && !"en".equals(language)) {
Log.w(TAG, "bad language code for CMAS - using English TTS");
language = "en";
}
audioIntent.putExtra(CellBroadcastAlertAudio.ALERT_AUDIO_MESSAGE_LANGUAGE,
language);
}
startService(audioIntent);
// Decide which activity to start based on the state of the keyguard.
Class c = CellBroadcastAlertDialog.class;
KeyguardManager km = (KeyguardManager) getSystemService(Context.KEYGUARD_SERVICE);
if (km.inKeyguardRestrictedInputMode()) {
// Use the full screen activity for security.
c = CellBroadcastAlertFullScreen.class;
}
ArrayList<CellBroadcastMessage> messageList = new ArrayList<CellBroadcastMessage>(1);
messageList.add(message);
Intent alertDialogIntent = createDisplayMessageIntent(this, c, messageList);
alertDialogIntent.addFlags(Intent.FLAG_ACTIVITY_NEW_TASK);
startActivity(alertDialogIntent);
}
/**
* Add the new alert to the notification bar (non-emergency alerts), or launch a
* high-priority immediate intent for emergency alerts.
* @param message the alert to display
*/
private void addToNotificationBar(CellBroadcastMessage message) {
int channelTitleId = CellBroadcastResources.getDialogTitleResource(message);
CharSequence channelName = getText(channelTitleId);
String messageBody = message.getMessageBody();
// Pass the list of unread non-emergency CellBroadcastMessages
ArrayList<CellBroadcastMessage> messageList = CellBroadcastReceiverApp
.addNewMessageToList(message);
// Create intent to show the new messages when user selects the notification.
Intent intent = createDisplayMessageIntent(this, CellBroadcastAlertDialog.class,
messageList);
intent.putExtra(CellBroadcastAlertFullScreen.FROM_NOTIFICATION_EXTRA, true);
PendingIntent pi = PendingIntent.getActivity(this, NOTIFICATION_ID, intent,
PendingIntent.FLAG_ONE_SHOT | PendingIntent.FLAG_UPDATE_CURRENT);
// use default sound/vibration/lights for non-emergency broadcasts
Notification.Builder builder = new Notification.Builder(this)
.setSmallIcon(R.drawable.ic_notify_alert)
.setTicker(channelName)
.setWhen(System.currentTimeMillis())
.setContentIntent(pi)
.setDefaults(Notification.DEFAULT_ALL);
builder.setDefaults(Notification.DEFAULT_ALL);
// increment unread alert count (decremented when user dismisses alert dialog)
int unreadCount = messageList.size();
if (unreadCount > 1) {
// use generic count of unread broadcasts if more than one unread
builder.setContentTitle(getString(R.string.notification_multiple_title));
builder.setContentText(getString(R.string.notification_multiple, unreadCount));
} else {
builder.setContentTitle(channelName).setContentText(messageBody);
}
NotificationManager notificationManager =
(NotificationManager)getSystemService(Context.NOTIFICATION_SERVICE);
notificationManager.notify(NOTIFICATION_ID, builder.build());
}
static Intent createDisplayMessageIntent(Context context, Class intentClass,
ArrayList<CellBroadcastMessage> messageList) {
// Trigger the list activity to fire up a dialog that shows the received messages
Intent intent = new Intent(context, intentClass);
intent.putParcelableArrayListExtra(CellBroadcastMessage.SMS_CB_MESSAGE_EXTRA, messageList);
return intent;
}
@Override
public IBinder onBind(Intent intent) {
return null; // clients can't bind to this service
}
}