Java tutorial
/* * Copyright (C) 2015 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.messaging.receiver; import android.app.Notification; import android.app.PendingIntent; import android.content.BroadcastReceiver; import android.content.ComponentName; import android.content.ContentValues; import android.content.Context; import android.content.Intent; import android.content.pm.PackageManager; import android.content.res.Resources; import android.provider.Telephony; import android.provider.Telephony.Sms; import android.support.v4.app.NotificationCompat; import android.support.v4.app.NotificationCompat.Builder; import android.support.v4.app.NotificationCompat.Style; import android.support.v4.app.NotificationManagerCompat; import java.util.ArrayList; import java.util.regex.Pattern; import java.util.regex.PatternSyntaxException; import com.android.messaging.Factory; import com.android.messaging.R; import com.android.messaging.datamodel.BugleNotifications; import com.android.messaging.datamodel.MessageNotificationState; import com.android.messaging.datamodel.NoConfirmationSmsSendService; import com.android.messaging.datamodel.action.ReceiveSmsMessageAction; import com.android.messaging.sms.MmsUtils; import com.android.messaging.ui.UIIntents; import com.android.messaging.util.BugleGservices; import com.android.messaging.util.BugleGservicesKeys; import com.android.messaging.util.DebugUtils; import com.android.messaging.util.LogUtil; import com.android.messaging.util.OsUtil; import com.android.messaging.util.PendingIntentConstants; import com.android.messaging.util.PhoneUtils; /** * Class that receives incoming SMS messages through android.provider.Telephony.SMS_RECEIVED * * This class serves two purposes: * - Process phone verification SMS messages * - Handle SMS messages when the user has enabled us to be the default SMS app (Pre-KLP) */ public final class SmsReceiver extends BroadcastReceiver { private static final String TAG = LogUtil.BUGLE_TAG; private static ArrayList<Pattern> sIgnoreSmsPatterns; /** * Enable or disable the SmsReceiver as appropriate. Pre-KLP we use this receiver for * receiving incoming SMS messages. For KLP+ this receiver is not used when running as the * primary user and the SmsDeliverReceiver is used for receiving incoming SMS messages. * When running as a secondary user, this receiver is still used to trigger the incoming * notification. */ public static void updateSmsReceiveHandler(final Context context) { boolean smsReceiverEnabled; boolean mmsWapPushReceiverEnabled; boolean respondViaMessageEnabled; boolean broadcastAbortEnabled; if (OsUtil.isAtLeastKLP()) { // When we're running as the secondary user, we don't get the new SMS_DELIVER intent, // only the primary user receives that. As secondary, we need to go old-school and // listen for the SMS_RECEIVED intent. For the secondary user, use this SmsReceiver // for both sms and mms notification. For the primary user on KLP (and above), we don't // use the SmsReceiver. smsReceiverEnabled = OsUtil.isSecondaryUser(); // On KLP use the new deliver event for mms mmsWapPushReceiverEnabled = false; // On KLP we need to always enable this handler to show in the list of sms apps respondViaMessageEnabled = true; // On KLP we don't need to abort the broadcast broadcastAbortEnabled = false; } else { // On JB we use the sms receiver for both sms/mms delivery final boolean carrierSmsEnabled = PhoneUtils.getDefault().isSmsEnabled(); smsReceiverEnabled = carrierSmsEnabled; // On JB we use the mms receiver when sms/mms is enabled mmsWapPushReceiverEnabled = carrierSmsEnabled; // On JB this is dynamic to make sure we don't show in dialer if sms is disabled respondViaMessageEnabled = carrierSmsEnabled; // On JB we need to abort broadcasts if SMS is enabled broadcastAbortEnabled = carrierSmsEnabled; } final PackageManager packageManager = context.getPackageManager(); final boolean logv = LogUtil.isLoggable(TAG, LogUtil.VERBOSE); if (smsReceiverEnabled) { if (logv) { LogUtil.v(TAG, "Enabling SMS message receiving"); } packageManager.setComponentEnabledSetting(new ComponentName(context, SmsReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } else { if (logv) { LogUtil.v(TAG, "Disabling SMS message receiving"); } packageManager.setComponentEnabledSetting(new ComponentName(context, SmsReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); } if (mmsWapPushReceiverEnabled) { if (logv) { LogUtil.v(TAG, "Enabling MMS message receiving"); } packageManager.setComponentEnabledSetting(new ComponentName(context, MmsWapPushReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } else { if (logv) { LogUtil.v(TAG, "Disabling MMS message receiving"); } packageManager.setComponentEnabledSetting(new ComponentName(context, MmsWapPushReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); } if (broadcastAbortEnabled) { if (logv) { LogUtil.v(TAG, "Enabling SMS/MMS broadcast abort"); } packageManager.setComponentEnabledSetting(new ComponentName(context, AbortSmsReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); packageManager.setComponentEnabledSetting(new ComponentName(context, AbortMmsWapPushReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } else { if (logv) { LogUtil.v(TAG, "Disabling SMS/MMS broadcast abort"); } packageManager.setComponentEnabledSetting(new ComponentName(context, AbortSmsReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); packageManager.setComponentEnabledSetting(new ComponentName(context, AbortMmsWapPushReceiver.class), PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); } if (respondViaMessageEnabled) { if (logv) { LogUtil.v(TAG, "Enabling respond via message intent"); } packageManager.setComponentEnabledSetting( new ComponentName(context, NoConfirmationSmsSendService.class), PackageManager.COMPONENT_ENABLED_STATE_ENABLED, PackageManager.DONT_KILL_APP); } else { if (logv) { LogUtil.v(TAG, "Disabling respond via message intent"); } packageManager.setComponentEnabledSetting( new ComponentName(context, NoConfirmationSmsSendService.class), PackageManager.COMPONENT_ENABLED_STATE_DISABLED, PackageManager.DONT_KILL_APP); } } private static final String EXTRA_ERROR_CODE = "errorCode"; private static final String EXTRA_SUB_ID = "subscription"; public static void deliverSmsIntent(final Context context, final Intent intent) { final android.telephony.SmsMessage[] messages = getMessagesFromIntent(intent); // Check messages for validity if (messages == null || messages.length < 1) { LogUtil.e(TAG, "processReceivedSms: null or zero or ignored message"); return; } final int errorCode = intent.getIntExtra(EXTRA_ERROR_CODE, 0); // Always convert negative subIds into -1 int subId = PhoneUtils.getDefault().getEffectiveIncomingSubIdFromSystem(intent, EXTRA_SUB_ID); deliverSmsMessages(context, subId, errorCode, messages); if (MmsUtils.isDumpSmsEnabled()) { final String format = null; DebugUtils.dumpSms(messages[0].getTimestampMillis(), messages, format); } } public static void deliverSmsMessages(final Context context, final int subId, final int errorCode, final android.telephony.SmsMessage[] messages) { final ContentValues messageValues = MmsUtils.parseReceivedSmsMessage(context, messages, errorCode); LogUtil.v(TAG, "SmsReceiver.deliverSmsMessages"); final long nowInMillis = System.currentTimeMillis(); final long receivedTimestampMs = MmsUtils.getMessageDate(messages[0], nowInMillis); messageValues.put(Sms.Inbox.DATE, receivedTimestampMs); // Default to unread and unseen for us but ReceiveSmsMessageAction will override // seen for the telephony db. messageValues.put(Sms.Inbox.READ, 0); messageValues.put(Sms.Inbox.SEEN, 0); if (OsUtil.isAtLeastL_MR1()) { messageValues.put(Sms.SUBSCRIPTION_ID, subId); } if (messages[0].getMessageClass() == android.telephony.SmsMessage.MessageClass.CLASS_0 || DebugUtils.debugClassZeroSmsEnabled()) { Factory.get().getUIIntents().launchClassZeroActivity(context, messageValues); } else { final ReceiveSmsMessageAction action = new ReceiveSmsMessageAction(messageValues); action.start(); } } @Override public void onReceive(final Context context, final Intent intent) { LogUtil.v(TAG, "SmsReceiver.onReceive " + intent); // On KLP+ we only take delivery of SMS messages in SmsDeliverReceiver. if (PhoneUtils.getDefault().isSmsEnabled()) { final String action = intent.getAction(); if (OsUtil.isSecondaryUser() && (Telephony.Sms.Intents.SMS_RECEIVED_ACTION.equals(action) || // TODO: update this with the actual constant from Telephony "android.provider.Telephony.MMS_DOWNLOADED".equals(action))) { postNewMessageSecondaryUserNotification(); } else if (!OsUtil.isAtLeastKLP()) { deliverSmsIntent(context, intent); } } } private static class SecondaryUserNotificationState extends MessageNotificationState { SecondaryUserNotificationState() { super(null); } @Override protected Style build(Builder builder) { return null; } @Override public boolean getNotificationVibrate() { return true; } } public static void postNewMessageSecondaryUserNotification() { final Context context = Factory.get().getApplicationContext(); final Resources resources = context.getResources(); final PendingIntent pendingIntent = UIIntents.get() .getPendingIntentForSecondaryUserNewMessageNotification(context); final NotificationCompat.Builder builder = new NotificationCompat.Builder(context); builder.setContentTitle(resources.getString(R.string.secondary_user_new_message_title)) .setTicker(resources.getString(R.string.secondary_user_new_message_ticker)) .setSmallIcon(R.drawable.ic_sms_light) // Returning PRIORITY_HIGH causes L to put up a HUD notification. Without it, the ticker // isn't displayed. .setPriority(Notification.PRIORITY_HIGH).setContentIntent(pendingIntent); final NotificationCompat.BigTextStyle bigTextStyle = new NotificationCompat.BigTextStyle(builder); bigTextStyle.bigText(resources.getString(R.string.secondary_user_new_message_title)); final Notification notification = bigTextStyle.build(); final NotificationManagerCompat notificationManager = NotificationManagerCompat .from(Factory.get().getApplicationContext()); int defaults = Notification.DEFAULT_LIGHTS; if (BugleNotifications.shouldVibrate(new SecondaryUserNotificationState())) { defaults |= Notification.DEFAULT_VIBRATE; } notification.defaults = defaults; notificationManager.notify(getNotificationTag(), PendingIntentConstants.SMS_SECONDARY_USER_NOTIFICATION_ID, notification); } /** * Cancel the notification */ public static void cancelSecondaryUserNotification() { final NotificationManagerCompat notificationManager = NotificationManagerCompat .from(Factory.get().getApplicationContext()); notificationManager.cancel(getNotificationTag(), PendingIntentConstants.SMS_SECONDARY_USER_NOTIFICATION_ID); } private static String getNotificationTag() { return Factory.get().getApplicationContext().getPackageName() + ":secondaryuser"; } /** * Compile all of the patterns we check for to ignore system SMS messages. */ private static void compileIgnoreSmsPatterns() { // Get the pattern set from GServices final String smsIgnoreRegex = BugleGservices.get().getString(BugleGservicesKeys.SMS_IGNORE_MESSAGE_REGEX, BugleGservicesKeys.SMS_IGNORE_MESSAGE_REGEX_DEFAULT); if (smsIgnoreRegex != null) { final String[] ignoreSmsExpressions = smsIgnoreRegex.split("\n"); if (ignoreSmsExpressions.length != 0) { sIgnoreSmsPatterns = new ArrayList<Pattern>(); for (int i = 0; i < ignoreSmsExpressions.length; i++) { try { sIgnoreSmsPatterns.add(Pattern.compile(ignoreSmsExpressions[i])); } catch (PatternSyntaxException e) { LogUtil.e(TAG, "compileIgnoreSmsPatterns: Skipping bad expression: " + ignoreSmsExpressions[i]); } } } } } /** * Get the SMS messages from the specified SMS intent. * @return the messages. If there is an error or the message should be ignored, return null. */ public static android.telephony.SmsMessage[] getMessagesFromIntent(Intent intent) { final android.telephony.SmsMessage[] messages = Sms.Intents.getMessagesFromIntent(intent); // Check messages for validity if (messages == null || messages.length < 1) { return null; } // Sometimes, SmsMessage.mWrappedSmsMessage is null causing NPE when we access // the methods on it although the SmsMessage itself is not null. So do this check // before we do anything on the parsed SmsMessages. try { final String messageBody = messages[0].getDisplayMessageBody(); if (messageBody != null) { // Compile patterns if necessary if (sIgnoreSmsPatterns == null) { compileIgnoreSmsPatterns(); } // Check against filters for (final Pattern pattern : sIgnoreSmsPatterns) { if (pattern.matcher(messageBody).matches()) { return null; } } } } catch (final NullPointerException e) { LogUtil.e(TAG, "shouldIgnoreMessage: NPE inside SmsMessage"); return null; } return messages; } /** * Check the specified SMS intent to see if the message should be ignored * @return true if the message should be ignored */ public static boolean shouldIgnoreMessage(Intent intent) { return getMessagesFromIntent(intent) == null; } }