| /* |
| * 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.sms; |
| |
| import android.app.Activity; |
| import android.app.PendingIntent; |
| import android.content.Context; |
| import android.content.Intent; |
| import android.net.Uri; |
| import android.os.Bundle; |
| import android.support.v7.mms.MmsManager; |
| import android.telephony.SmsManager; |
| |
| import com.android.messaging.datamodel.MmsFileProvider; |
| import com.android.messaging.datamodel.action.SendMessageAction; |
| import com.android.messaging.datamodel.data.MessageData; |
| import com.android.messaging.mmslib.InvalidHeaderValueException; |
| import com.android.messaging.mmslib.pdu.AcknowledgeInd; |
| import com.android.messaging.mmslib.pdu.EncodedStringValue; |
| import com.android.messaging.mmslib.pdu.GenericPdu; |
| import com.android.messaging.mmslib.pdu.NotifyRespInd; |
| import com.android.messaging.mmslib.pdu.PduComposer; |
| import com.android.messaging.mmslib.pdu.PduHeaders; |
| import com.android.messaging.mmslib.pdu.PduParser; |
| import com.android.messaging.mmslib.pdu.RetrieveConf; |
| import com.android.messaging.mmslib.pdu.SendConf; |
| import com.android.messaging.mmslib.pdu.SendReq; |
| import com.android.messaging.receiver.SendStatusReceiver; |
| import com.android.messaging.util.Assert; |
| import com.android.messaging.util.LogUtil; |
| import com.android.messaging.util.PhoneUtils; |
| |
| import java.io.File; |
| import java.io.FileOutputStream; |
| import java.io.IOException; |
| |
| /** |
| * Class that sends chat message via MMS. |
| * |
| * The interface emulates a blocking send similar to making an HTTP request. |
| */ |
| public class MmsSender { |
| private static final String TAG = LogUtil.BUGLE_TAG; |
| |
| /** |
| * Send an MMS message. |
| * |
| * @param context Context |
| * @param messageUri The unique URI of the message for identifying it during sending |
| * @param sendReq The SendReq PDU of the message |
| * @throws MmsFailureException |
| */ |
| public static void sendMms(final Context context, final int subId, final Uri messageUri, |
| final SendReq sendReq, final Bundle sentIntentExras) throws MmsFailureException { |
| sendMms(context, |
| subId, |
| messageUri, |
| null /* locationUrl */, |
| sendReq, |
| true /* responseImportant */, |
| sentIntentExras); |
| } |
| |
| /** |
| * Send NotifyRespInd (response to mms auto download). |
| * |
| * @param context Context |
| * @param subId subscription to use to send the response |
| * @param transactionId The transaction id of the MMS message |
| * @param contentLocation The url of the MMS message |
| * @param status The status to send with the NotifyRespInd |
| * @throws MmsFailureException |
| * @throws InvalidHeaderValueException |
| */ |
| public static void sendNotifyResponseForMmsDownload(final Context context, final int subId, |
| final byte[] transactionId, final String contentLocation, final int status) |
| throws MmsFailureException, InvalidHeaderValueException { |
| // Create the M-NotifyResp.ind |
| final NotifyRespInd notifyRespInd = new NotifyRespInd( |
| PduHeaders.CURRENT_MMS_VERSION, transactionId, status); |
| final Uri messageUri = Uri.parse(contentLocation); |
| // Pack M-NotifyResp.ind and send it |
| sendMms(context, |
| subId, |
| messageUri, |
| MmsConfig.get(subId).getNotifyWapMMSC() ? contentLocation : null, |
| notifyRespInd, |
| false /* responseImportant */, |
| null /* sentIntentExtras */); |
| } |
| |
| /** |
| * Send AcknowledgeInd (response to mms manual download). Ignore failures. |
| * |
| * @param context Context |
| * @param subId The SIM's subId we are currently using |
| * @param transactionId The transaction id of the MMS message |
| * @param contentLocation The url of the MMS message |
| * @throws MmsFailureException |
| * @throws InvalidHeaderValueException |
| */ |
| public static void sendAcknowledgeForMmsDownload(final Context context, final int subId, |
| final byte[] transactionId, final String contentLocation) |
| throws MmsFailureException, InvalidHeaderValueException { |
| final String selfNumber = PhoneUtils.get(subId).getCanonicalForSelf(true/*allowOverride*/); |
| // Create the M-Acknowledge.ind |
| final AcknowledgeInd acknowledgeInd = new AcknowledgeInd(PduHeaders.CURRENT_MMS_VERSION, |
| transactionId); |
| acknowledgeInd.setFrom(new EncodedStringValue(selfNumber)); |
| final Uri messageUri = Uri.parse(contentLocation); |
| // Sending |
| sendMms(context, |
| subId, |
| messageUri, |
| MmsConfig.get(subId).getNotifyWapMMSC() ? contentLocation : null, |
| acknowledgeInd, |
| false /*responseImportant*/, |
| null /* sentIntentExtras */); |
| } |
| |
| /** |
| * Send a generic PDU. |
| * |
| * @param context Context |
| * @param messageUri The unique URI of the message for identifying it during sending |
| * @param locationUrl The optional URL to send to |
| * @param pdu The PDU to send |
| * @param responseImportant If the sending response is important. Responses to the |
| * Sending of AcknowledgeInd and NotifyRespInd are not important. |
| * @throws MmsFailureException |
| */ |
| private static void sendMms(final Context context, final int subId, final Uri messageUri, |
| final String locationUrl, final GenericPdu pdu, final boolean responseImportant, |
| final Bundle sentIntentExtras) throws MmsFailureException { |
| // Write PDU to temporary file to send to platform |
| final Uri contentUri = writePduToTempFile(context, pdu, subId); |
| |
| // Construct PendingIntent that will notify us when message sending is complete |
| final Intent sentIntent = new Intent(SendStatusReceiver.MMS_SENT_ACTION, |
| messageUri, |
| context, |
| SendStatusReceiver.class); |
| sentIntent.putExtra(SendMessageAction.EXTRA_CONTENT_URI, contentUri); |
| sentIntent.putExtra(SendMessageAction.EXTRA_RESPONSE_IMPORTANT, responseImportant); |
| if (sentIntentExtras != null) { |
| sentIntent.putExtras(sentIntentExtras); |
| } |
| final PendingIntent sentPendingIntent = PendingIntent.getBroadcast( |
| context, |
| 0 /*request code*/, |
| sentIntent, |
| PendingIntent.FLAG_UPDATE_CURRENT); |
| |
| // Send the message |
| MmsManager.sendMultimediaMessage(subId, context, contentUri, locationUrl, |
| sentPendingIntent); |
| } |
| |
| private static Uri writePduToTempFile(final Context context, final GenericPdu pdu, int subId) |
| throws MmsFailureException { |
| final Uri contentUri = MmsFileProvider.buildRawMmsUri(); |
| final File tempFile = MmsFileProvider.getFile(contentUri); |
| FileOutputStream writer = null; |
| try { |
| // Ensure rawmms directory exists |
| tempFile.getParentFile().mkdirs(); |
| writer = new FileOutputStream(tempFile); |
| final byte[] pduBytes = new PduComposer(context, pdu).make(); |
| if (pduBytes == null) { |
| throw new MmsFailureException( |
| MmsUtils.MMS_REQUEST_NO_RETRY, "Failed to compose PDU"); |
| } |
| if (pduBytes.length > MmsConfig.get(subId).getMaxMessageSize()) { |
| throw new MmsFailureException( |
| MmsUtils.MMS_REQUEST_NO_RETRY, |
| MessageData.RAW_TELEPHONY_STATUS_MESSAGE_TOO_BIG); |
| } |
| writer.write(pduBytes); |
| } catch (final IOException e) { |
| if (tempFile != null) { |
| tempFile.delete(); |
| } |
| LogUtil.e(TAG, "Cannot create temporary file " + tempFile.getAbsolutePath(), e); |
| throw new MmsFailureException( |
| MmsUtils.MMS_REQUEST_AUTO_RETRY, "Cannot create raw mms file"); |
| } catch (final OutOfMemoryError e) { |
| if (tempFile != null) { |
| tempFile.delete(); |
| } |
| LogUtil.e(TAG, "Out of memory in composing PDU", e); |
| throw new MmsFailureException( |
| MmsUtils.MMS_REQUEST_MANUAL_RETRY, |
| MessageData.RAW_TELEPHONY_STATUS_MESSAGE_TOO_BIG); |
| } finally { |
| if (writer != null) { |
| try { |
| writer.close(); |
| } catch (final IOException e) { |
| // no action we can take here |
| } |
| } |
| } |
| return contentUri; |
| } |
| |
| public static SendConf parseSendConf(byte[] response, int subId) { |
| if (response != null) { |
| final GenericPdu respPdu = new PduParser( |
| response, MmsConfig.get(subId).getSupportMmsContentDisposition()).parse(); |
| if (respPdu != null) { |
| if (respPdu instanceof SendConf) { |
| return (SendConf) respPdu; |
| } else { |
| LogUtil.e(TAG, "MmsSender: send response not SendConf"); |
| } |
| } else { |
| // Invalid PDU |
| LogUtil.e(TAG, "MmsSender: send invalid response"); |
| } |
| } |
| // Empty or invalid response |
| return null; |
| } |
| |
| /** |
| * Download an MMS message. |
| * |
| * @param context Context |
| * @param contentLocation The url of the MMS message |
| * @throws MmsFailureException |
| * @throws InvalidHeaderValueException |
| */ |
| public static void downloadMms(final Context context, final int subId, |
| final String contentLocation, Bundle extras) throws MmsFailureException, |
| InvalidHeaderValueException { |
| final Uri requestUri = Uri.parse(contentLocation); |
| final Uri contentUri = MmsFileProvider.buildRawMmsUri(); |
| |
| final Intent downloadedIntent = new Intent(SendStatusReceiver.MMS_DOWNLOADED_ACTION, |
| requestUri, |
| context, |
| SendStatusReceiver.class); |
| downloadedIntent.putExtra(SendMessageAction.EXTRA_CONTENT_URI, contentUri); |
| if (extras != null) { |
| downloadedIntent.putExtras(extras); |
| } |
| final PendingIntent downloadedPendingIntent = PendingIntent.getBroadcast( |
| context, |
| 0 /*request code*/, |
| downloadedIntent, |
| PendingIntent.FLAG_UPDATE_CURRENT); |
| |
| MmsManager.downloadMultimediaMessage(subId, context, contentLocation, contentUri, |
| downloadedPendingIntent); |
| } |
| |
| public static RetrieveConf parseRetrieveConf(byte[] data, int subId) { |
| if (data != null) { |
| final GenericPdu pdu = new PduParser( |
| data, MmsConfig.get(subId).getSupportMmsContentDisposition()).parse(); |
| if (pdu != null) { |
| if (pdu instanceof RetrieveConf) { |
| return (RetrieveConf) pdu; |
| } else { |
| LogUtil.e(TAG, "MmsSender: downloaded pdu not RetrieveConf: " |
| + pdu.getClass().getName()); |
| } |
| } else { |
| LogUtil.e(TAG, "MmsSender: downloaded pdu could not be parsed (invalid)"); |
| } |
| } |
| LogUtil.e(TAG, "MmsSender: downloaded pdu is empty"); |
| return null; |
| } |
| |
| // Process different result code from platform MMS service |
| public static int getErrorResultStatus(int resultCode, int httpStatusCode) { |
| Assert.isFalse(resultCode == Activity.RESULT_OK); |
| switch (resultCode) { |
| case SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS: |
| case SmsManager.MMS_ERROR_IO_ERROR: |
| return MmsUtils.MMS_REQUEST_AUTO_RETRY; |
| case SmsManager.MMS_ERROR_INVALID_APN: |
| case SmsManager.MMS_ERROR_CONFIGURATION_ERROR: |
| case SmsManager.MMS_ERROR_NO_DATA_NETWORK: |
| case SmsManager.MMS_ERROR_UNSPECIFIED: |
| return MmsUtils.MMS_REQUEST_MANUAL_RETRY; |
| case SmsManager.MMS_ERROR_HTTP_FAILURE: |
| if (httpStatusCode == 404) { |
| return MmsUtils.MMS_REQUEST_NO_RETRY; |
| } else { |
| return MmsUtils.MMS_REQUEST_AUTO_RETRY; |
| } |
| default: |
| return MmsUtils.MMS_REQUEST_MANUAL_RETRY; |
| } |
| } |
| } |
