| /* |
| * 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.datamodel.action; |
| |
| import android.content.ContentValues; |
| import android.database.Cursor; |
| import android.os.Parcel; |
| import android.os.Parcelable; |
| import android.telephony.ServiceState; |
| |
| import com.android.messaging.Factory; |
| import com.android.messaging.datamodel.BugleDatabaseOperations; |
| import com.android.messaging.datamodel.DataModel; |
| import com.android.messaging.datamodel.DataModelImpl; |
| import com.android.messaging.datamodel.DatabaseHelper; |
| import com.android.messaging.datamodel.DatabaseHelper.MessageColumns; |
| import com.android.messaging.datamodel.DatabaseWrapper; |
| import com.android.messaging.datamodel.MessagingContentProvider; |
| import com.android.messaging.datamodel.data.MessageData; |
| import com.android.messaging.datamodel.data.ParticipantData; |
| import com.android.messaging.util.BugleGservices; |
| import com.android.messaging.util.BugleGservicesKeys; |
| import com.android.messaging.util.BuglePrefs; |
| import com.android.messaging.util.BuglePrefsKeys; |
| import com.android.messaging.util.ConnectivityUtil; |
| import com.android.messaging.util.ConnectivityUtil.ConnectivityListener; |
| import com.android.messaging.util.LogUtil; |
| import com.android.messaging.util.OsUtil; |
| import com.android.messaging.util.PhoneUtils; |
| |
| import java.util.HashSet; |
| import java.util.Set; |
| |
| /** |
| * Action used to lookup any messages in the pending send/download state and either fail them or |
| * retry their action based on subscriptions. This action only initiates one retry at a time for |
| * both sending/downloading. Further retries should be triggered by successful sending/downloading |
| * of a message, network status change or exponential backoff timer. |
| */ |
| public class ProcessPendingMessagesAction extends Action implements Parcelable { |
| private static final String TAG = LogUtil.BUGLE_DATAMODEL_TAG; |
| // PENDING_INTENT_BASE_REQUEST_CODE + subId(-1 for pre-L_MR1) is used per subscription uniquely. |
| private static final int PENDING_INTENT_BASE_REQUEST_CODE = 103; |
| |
| private static final String KEY_SUB_ID = "sub_id"; |
| |
| public static void processFirstPendingMessage() { |
| PhoneUtils.forEachActiveSubscription(new PhoneUtils.SubscriptionRunnable() { |
| @Override |
| public void runForSubscription(final int subId) { |
| // Clear any pending alarms or connectivity events |
| unregister(subId); |
| // Clear retry count |
| setRetry(0, subId); |
| // Start action |
| final ProcessPendingMessagesAction action = new ProcessPendingMessagesAction(); |
| action.actionParameters.putInt(KEY_SUB_ID, subId); |
| action.start(); |
| } |
| }); |
| } |
| |
| public static void scheduleProcessPendingMessagesAction(final boolean failed, |
| final Action processingAction) { |
| final int subId = processingAction.actionParameters |
| .getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID); |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Scheduling pending messages" |
| + (failed ? "(message failed)" : "") + " for subId " + subId); |
| // Can safely clear any pending alarms or connectivity events as either an action |
| // is currently running or we will run now or register if pending actions possible. |
| unregister(subId); |
| |
| final boolean isDefaultSmsApp = PhoneUtils.getDefault().isDefaultSmsApp(); |
| boolean scheduleAlarm = false; |
| // If message succeeded and if Bugle is default SMS app just carry on with next message |
| if (!failed && isDefaultSmsApp) { |
| // Clear retry attempt count as something just succeeded |
| setRetry(0, subId); |
| |
| // Lookup and queue next message for each sending/downloading for immediate processing |
| // by background worker. If there are no pending messages, this will do nothing and |
| // return true. |
| final ProcessPendingMessagesAction action = new ProcessPendingMessagesAction(); |
| if (action.queueActions(processingAction)) { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| if (processingAction.hasBackgroundActions()) { |
| LogUtil.v(TAG, "ProcessPendingMessagesAction: Action queued"); |
| } else { |
| LogUtil.v(TAG, "ProcessPendingMessagesAction: No actions to queue"); |
| } |
| } |
| // Have queued next action if needed, nothing more to do |
| return; |
| } |
| // In case of error queuing schedule a retry |
| scheduleAlarm = true; |
| LogUtil.w(TAG, "ProcessPendingMessagesAction: Action failed to queue; retrying"); |
| } |
| if (getHavePendingMessages(subId) || scheduleAlarm) { |
| // Still have a pending message that needs to be queued for processing |
| final ConnectivityListener listener = new ConnectivityListener() { |
| @Override |
| public void onPhoneStateChanged(final int serviceState) { |
| if (serviceState == ServiceState.STATE_IN_SERVICE) { |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Now connected for subId " |
| + subId + ", starting action"); |
| |
| // Clear any pending alarms or connectivity events but leave attempt count |
| // alone |
| unregister(subId); |
| |
| // Start action |
| final ProcessPendingMessagesAction action = |
| new ProcessPendingMessagesAction(); |
| action.actionParameters.putInt(KEY_SUB_ID, subId); |
| action.start(); |
| } |
| } |
| }; |
| // Read and increment attempt number from shared prefs |
| final int retryAttempt = getNextRetry(subId); |
| register(listener, retryAttempt, subId); |
| } else { |
| // No more pending messages (presumably the message that failed has expired) or it |
| // may be possible that a send and a download are already in process. |
| // Clear retry attempt count. |
| // TODO Might be premature if send and download in process... |
| // but worst case means we try to send a bit more often. |
| setRetry(0, subId); |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: No more pending messages"); |
| } |
| } |
| |
| private static void register(final ConnectivityListener listener, final int retryAttempt, |
| int subId) { |
| int retryNumber = retryAttempt; |
| |
| // Register to be notified about connectivity changes |
| ConnectivityUtil connectivityUtil = DataModelImpl.getConnectivityUtil(subId); |
| if (connectivityUtil != null) { |
| connectivityUtil.register(listener); |
| } |
| |
| final ProcessPendingMessagesAction action = new ProcessPendingMessagesAction(); |
| action.actionParameters.putInt(KEY_SUB_ID, subId); |
| final long initialBackoffMs = BugleGservices.get().getLong( |
| BugleGservicesKeys.INITIAL_MESSAGE_RESEND_DELAY_MS, |
| BugleGservicesKeys.INITIAL_MESSAGE_RESEND_DELAY_MS_DEFAULT); |
| final long maxDelayMs = BugleGservices.get().getLong( |
| BugleGservicesKeys.MAX_MESSAGE_RESEND_DELAY_MS, |
| BugleGservicesKeys.MAX_MESSAGE_RESEND_DELAY_MS_DEFAULT); |
| long delayMs; |
| long nextDelayMs = initialBackoffMs; |
| do { |
| delayMs = nextDelayMs; |
| retryNumber--; |
| nextDelayMs = delayMs * 2; |
| } |
| while (retryNumber > 0 && nextDelayMs < maxDelayMs); |
| |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Registering for retry #" + retryAttempt |
| + " in " + delayMs + " ms for subId " + subId); |
| |
| action.schedule(PENDING_INTENT_BASE_REQUEST_CODE + subId, delayMs); |
| } |
| |
| private static void unregister(final int subId) { |
| // Clear any pending alarms or connectivity events |
| ConnectivityUtil connectivityUtil = DataModelImpl.getConnectivityUtil(subId); |
| if (connectivityUtil != null) { |
| connectivityUtil.unregister(); |
| } |
| |
| final ProcessPendingMessagesAction action = new ProcessPendingMessagesAction(); |
| action.schedule(PENDING_INTENT_BASE_REQUEST_CODE + subId, Long.MAX_VALUE); |
| |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "ProcessPendingMessagesAction: Unregistering for connectivity changed " |
| + "events and clearing scheduled alarm for subId " + subId); |
| } |
| } |
| |
| private static void setRetry(final int retryAttempt, int subId) { |
| final BuglePrefs prefs = Factory.get().getSubscriptionPrefs(subId); |
| prefs.putInt(BuglePrefsKeys.PROCESS_PENDING_MESSAGES_RETRY_COUNT, retryAttempt); |
| } |
| |
| private static int getNextRetry(int subId) { |
| final BuglePrefs prefs = Factory.get().getSubscriptionPrefs(subId); |
| final int retryAttempt = |
| prefs.getInt(BuglePrefsKeys.PROCESS_PENDING_MESSAGES_RETRY_COUNT, 0) + 1; |
| prefs.putInt(BuglePrefsKeys.PROCESS_PENDING_MESSAGES_RETRY_COUNT, retryAttempt); |
| return retryAttempt; |
| } |
| |
| private ProcessPendingMessagesAction() { |
| } |
| |
| /** |
| * Read from the DB and determine if there are any messages we should process |
| * |
| * @param subId the subId |
| * @return true if we have pending messages |
| */ |
| private static boolean getHavePendingMessages(final int subId) { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final long now = System.currentTimeMillis(); |
| final String selfId = ParticipantData.getParticipantId(db, subId); |
| if (selfId == null) { |
| // This could be happened before refreshing participant. |
| LogUtil.w(TAG, "ProcessPendingMessagesAction: selfId is null for subId " + subId); |
| return false; |
| } |
| |
| final String toSendMessageId = findNextMessageToSend(db, now, selfId); |
| if (toSendMessageId != null) { |
| return true; |
| } else { |
| final String toDownloadMessageId = findNextMessageToDownload(db, now, selfId); |
| if (toDownloadMessageId != null) { |
| return true; |
| } |
| } |
| // Messages may be in the process of sending/downloading even when there are no pending |
| // messages... |
| return false; |
| } |
| |
| /** |
| * Queue any pending actions |
| * |
| * @param actionState |
| * @return true if action queued (or no actions to queue) else false |
| */ |
| private boolean queueActions(final Action processingAction) { |
| final DatabaseWrapper db = DataModel.get().getDatabase(); |
| final long now = System.currentTimeMillis(); |
| boolean succeeded = true; |
| final int subId = processingAction.actionParameters |
| .getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID); |
| |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Start queueing for subId " + subId); |
| |
| final String selfId = ParticipantData.getParticipantId(db, subId); |
| if (selfId == null) { |
| // This could be happened before refreshing participant. |
| LogUtil.w(TAG, "ProcessPendingMessagesAction: selfId is null"); |
| return false; |
| } |
| |
| // Will queue no more than one message to send plus one message to download |
| // This keeps outgoing messages "in order" but allow downloads to happen even if sending |
| // gets blocked until messages time out. Manual resend bumps messages to head of queue. |
| final String toSendMessageId = findNextMessageToSend(db, now, selfId); |
| final String toDownloadMessageId = findNextMessageToDownload(db, now, selfId); |
| if (toSendMessageId != null) { |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Queueing message " + toSendMessageId |
| + " for sending"); |
| // This could queue nothing |
| if (!SendMessageAction.queueForSendInBackground(toSendMessageId, processingAction)) { |
| LogUtil.w(TAG, "ProcessPendingMessagesAction: Failed to queue message " |
| + toSendMessageId + " for sending"); |
| succeeded = false; |
| } |
| } |
| if (toDownloadMessageId != null) { |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: Queueing message " + toDownloadMessageId |
| + " for download"); |
| // This could queue nothing |
| if (!DownloadMmsAction.queueMmsForDownloadInBackground(toDownloadMessageId, |
| processingAction)) { |
| LogUtil.w(TAG, "ProcessPendingMessagesAction: Failed to queue message " |
| + toDownloadMessageId + " for download"); |
| succeeded = false; |
| } |
| } |
| if (toSendMessageId == null && toDownloadMessageId == null) { |
| LogUtil.i(TAG, "ProcessPendingMessagesAction: No messages to send or download"); |
| } |
| return succeeded; |
| } |
| |
| @Override |
| protected Object executeAction() { |
| final int subId = actionParameters.getInt(KEY_SUB_ID, ParticipantData.DEFAULT_SELF_SUB_ID); |
| // If triggered by alarm will not have unregistered yet |
| unregister(subId); |
| |
| if (PhoneUtils.getDefault().isDefaultSmsApp()) { |
| if (!queueActions(this)) { |
| LogUtil.v(TAG, "ProcessPendingMessagesAction: rescheduling"); |
| // TODO: Need to clear retry count here? |
| scheduleProcessPendingMessagesAction(true /* failed */, this); |
| } |
| } else { |
| if (LogUtil.isLoggable(TAG, LogUtil.VERBOSE)) { |
| LogUtil.v(TAG, "ProcessPendingMessagesAction: Not default SMS app; rescheduling"); |
| } |
| scheduleProcessPendingMessagesAction(true /* failed */, this); |
| } |
| |
| return null; |
| } |
| |
| private static String findNextMessageToSend(final DatabaseWrapper db, final long now, |
| final String selfId) { |
| String toSendMessageId = null; |
| Cursor cursor = null; |
| int sendingCnt = 0; |
| int pendingCnt = 0; |
| int failedCnt = 0; |
| db.beginTransaction(); |
| try { |
| // First check to see if we have any messages already sending |
| sendingCnt = (int) db.queryNumEntries(DatabaseHelper.MESSAGES_TABLE, |
| DatabaseHelper.MessageColumns.STATUS + " IN (?, ?) AND " |
| + DatabaseHelper.MessageColumns.SELF_PARTICIPANT_ID + " =? ", |
| new String[] { |
| Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_SENDING), |
| Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_RESENDING), |
| selfId} |
| ); |
| |
| // Look for messages we cound send |
| cursor = db.query(DatabaseHelper.MESSAGES_TABLE, |
| MessageData.getProjection(), |
| DatabaseHelper.MessageColumns.STATUS + " IN (?, ?) AND " |
| + DatabaseHelper.MessageColumns.SELF_PARTICIPANT_ID + " =? ", |
| new String[] { |
| Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_YET_TO_SEND), |
| Integer.toString(MessageData.BUGLE_STATUS_OUTGOING_AWAITING_RETRY), |
| selfId |
| }, |
| null, |
| null, |
| DatabaseHelper.MessageColumns.RECEIVED_TIMESTAMP + " ASC"); |
| pendingCnt = cursor.getCount(); |
| |
| final ContentValues values = new ContentValues(); |
| values.put(DatabaseHelper.MessageColumns.STATUS, |
| MessageData.BUGLE_STATUS_OUTGOING_FAILED); |
| |
| while (cursor.moveToNext()) { |
| final MessageData message = new MessageData(); |
| message.bind(cursor); |
| if (message.getInResendWindow(now)) { |
| // If no messages currently sending |
| if (sendingCnt == 0) { |
| // Resend this message |
| toSendMessageId = message.getMessageId(); |
| // Before queuing the message for resending, check if the message's self is |
| // active. If not, switch back to the system's default subscription. |
| if (OsUtil.isAtLeastL_MR1()) { |
| final ParticipantData messageSelf = BugleDatabaseOperations |
| .getExistingParticipant(db, selfId); |
| if (messageSelf == null || !messageSelf.isActiveSubscription()) { |
| final ParticipantData defaultSelf = BugleDatabaseOperations |
| .getOrCreateSelf(db, PhoneUtils.getDefault() |
| .getDefaultSmsSubscriptionId()); |
| if (defaultSelf != null) { |
| message.bindSelfId(defaultSelf.getId()); |
| final ContentValues selfValues = new ContentValues(); |
| selfValues.put(MessageColumns.SELF_PARTICIPANT_ID, |
| defaultSelf.getId()); |
| BugleDatabaseOperations.updateMessageRow(db, |
| message.getMessageId(), selfValues); |
| MessagingContentProvider.notifyMessagesChanged( |
| message.getConversationId()); |
| } |
| } |
| } |
| } |
| break; |
| } else { |
| failedCnt++; |
| |
| // Mark message as failed |
| BugleDatabaseOperations.updateMessageRow(db, message.getMessageId(), values); |
| MessagingContentProvider.notifyMessagesChanged(message.getConversationId()); |
| } |
| } |
| db.setTransactionSuccessful(); |
| } finally { |
| db.endTransaction(); |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| |
| if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { |
| LogUtil.d(TAG, "ProcessPendingMessagesAction: " |
| + sendingCnt + " messages already sending, " |
| + pendingCnt + " messages to send, " |
| + failedCnt + " failed messages"); |
| } |
| |
| return toSendMessageId; |
| } |
| |
| private static String findNextMessageToDownload(final DatabaseWrapper db, final long now, |
| final String selfId) { |
| String toDownloadMessageId = null; |
| Cursor cursor = null; |
| int downloadingCnt = 0; |
| int pendingCnt = 0; |
| db.beginTransaction(); |
| try { |
| // First check if we have any messages already downloading |
| downloadingCnt = (int) db.queryNumEntries(DatabaseHelper.MESSAGES_TABLE, |
| DatabaseHelper.MessageColumns.STATUS + " IN (?, ?) AND " |
| + DatabaseHelper.MessageColumns.SELF_PARTICIPANT_ID + " =?", |
| new String[] { |
| Integer.toString(MessageData.BUGLE_STATUS_INCOMING_AUTO_DOWNLOADING), |
| Integer.toString(MessageData.BUGLE_STATUS_INCOMING_MANUAL_DOWNLOADING), |
| selfId |
| }); |
| |
| // TODO: This query is not actually needed if downloadingCnt == 0. |
| cursor = db.query(DatabaseHelper.MESSAGES_TABLE, |
| MessageData.getProjection(), |
| DatabaseHelper.MessageColumns.STATUS + " IN (?, ?) AND " |
| + DatabaseHelper.MessageColumns.SELF_PARTICIPANT_ID + " =? ", |
| new String[]{ |
| Integer.toString(MessageData.BUGLE_STATUS_INCOMING_RETRYING_AUTO_DOWNLOAD), |
| Integer.toString( |
| MessageData.BUGLE_STATUS_INCOMING_RETRYING_MANUAL_DOWNLOAD), |
| selfId |
| }, |
| null, |
| null, |
| DatabaseHelper.MessageColumns.RECEIVED_TIMESTAMP + " ASC"); |
| |
| pendingCnt = cursor.getCount(); |
| |
| // If no messages are currently downloading and there is a download pending, |
| // queue the download of the oldest pending message. |
| if (downloadingCnt == 0 && cursor.moveToNext()) { |
| // Always start the next pending message. We will check if a download has |
| // expired in DownloadMmsAction and mark message failed there. |
| final MessageData message = new MessageData(); |
| message.bind(cursor); |
| toDownloadMessageId = message.getMessageId(); |
| } |
| db.setTransactionSuccessful(); |
| } finally { |
| db.endTransaction(); |
| if (cursor != null) { |
| cursor.close(); |
| } |
| } |
| |
| if (LogUtil.isLoggable(TAG, LogUtil.DEBUG)) { |
| LogUtil.d(TAG, "ProcessPendingMessagesAction: " |
| + downloadingCnt + " messages already downloading, " |
| + pendingCnt + " messages to download"); |
| } |
| |
| return toDownloadMessageId; |
| } |
| |
| private ProcessPendingMessagesAction(final Parcel in) { |
| super(in); |
| } |
| |
| public static final Parcelable.Creator<ProcessPendingMessagesAction> CREATOR |
| = new Parcelable.Creator<ProcessPendingMessagesAction>() { |
| @Override |
| public ProcessPendingMessagesAction createFromParcel(final Parcel in) { |
| return new ProcessPendingMessagesAction(in); |
| } |
| |
| @Override |
| public ProcessPendingMessagesAction[] newArray(final int size) { |
| return new ProcessPendingMessagesAction[size]; |
| } |
| }; |
| |
| @Override |
| public void writeToParcel(final Parcel parcel, final int flags) { |
| writeActionToParcel(parcel, flags); |
| } |
| } |