diff options
Diffstat (limited to 'src/android')
44 files changed, 10359 insertions, 0 deletions
diff --git a/src/android/support/v7/mms/ApnException.java b/src/android/support/v7/mms/ApnException.java new file mode 100644 index 0000000..075d92d --- /dev/null +++ b/src/android/support/v7/mms/ApnException.java @@ -0,0 +1,39 @@ +/* + * 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 android.support.v7.mms; + +/** + * APN exception + */ +public class ApnException extends Exception { + + public ApnException() { + super(); + } + + public ApnException(String message) { + super(message); + } + + public ApnException(Throwable cause) { + super(cause); + } + + public ApnException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/android/support/v7/mms/ApnSettingsLoader.java b/src/android/support/v7/mms/ApnSettingsLoader.java new file mode 100644 index 0000000..ff8ed12 --- /dev/null +++ b/src/android/support/v7/mms/ApnSettingsLoader.java @@ -0,0 +1,63 @@ +/* + * 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 android.support.v7.mms; + +import java.util.List; + +/** + * Interface for loading APNs for default SMS SIM + */ +public interface ApnSettingsLoader { + /** + * Interface to represent the minimal information MMS lib needs from an APN + */ + interface Apn { + /** + * Get the MMSC URL string + * + * @return MMSC URL + */ + String getMmsc(); + + /** + * Get the MMS proxy host address + * + * @return MMS proxy + */ + String getMmsProxy(); + + /** + * Get the MMS proxy host port + * + * @return the port of MMS proxy + */ + int getMmsProxyPort(); + + /** + * Flag the APN as a successful APN to use + */ + void setSuccess(); + } + + /** + * Get a list possible APN matching the subId and APN name + * + * @param apnName the APN name + * @return a list of possible APNs + */ + List<Apn> get(String apnName); +} diff --git a/src/android/support/v7/mms/ApnsXmlParser.java b/src/android/support/v7/mms/ApnsXmlParser.java new file mode 100644 index 0000000..eeafcf6 --- /dev/null +++ b/src/android/support/v7/mms/ApnsXmlParser.java @@ -0,0 +1,73 @@ +/* + * 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 android.support.v7.mms; + +import android.content.ContentValues; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; + +/** + * Parser for built-in XML resource file for APN list + */ +class ApnsXmlParser extends MmsXmlResourceParser { + interface ApnProcessor { + void process(ContentValues apnValues); + } + + private static final String TAG_APNS = "apns"; + private static final String TAG_APN = "apn"; + + private final ApnProcessor mApnProcessor; + + private final ContentValues mValues = new ContentValues(); + + ApnsXmlParser(final XmlPullParser parser, final ApnProcessor apnProcessor) { + super(parser); + mApnProcessor = apnProcessor; + } + + // Parse one APN + @Override + protected void parseRecord() throws IOException, XmlPullParserException { + if (TAG_APN.equals(mInputParser.getName())) { + mValues.clear(); + // Collect all the attributes + for (int i = 0; i < mInputParser.getAttributeCount(); i++) { + final String key = mInputParser.getAttributeName(i); + if (key != null) { + mValues.put(key, mInputParser.getAttributeValue(i)); + } + } + // We are done parsing one APN, call the handler + if (mApnProcessor != null) { + mApnProcessor.process(mValues); + } + } + // We are at the end tag + if (mInputParser.next() != XmlPullParser.END_TAG) { + throw new XmlPullParserException("Expecting end tag @" + xmlParserDebugContext()); + } + } + + @Override + protected String getRootTag() { + return TAG_APNS; + } +} diff --git a/src/android/support/v7/mms/CarrierConfigValuesLoader.java b/src/android/support/v7/mms/CarrierConfigValuesLoader.java new file mode 100644 index 0000000..ad94fb2 --- /dev/null +++ b/src/android/support/v7/mms/CarrierConfigValuesLoader.java @@ -0,0 +1,198 @@ +/* + * 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 android.support.v7.mms; + +import android.os.Bundle; + +/** + * Loader for carrier dependent configuration values + */ +public interface CarrierConfigValuesLoader { + /** + * Get the carrier config values in a bundle + * + * @param subId the associated subscription ID for the carrier configuration + * @return a bundle of all the values + */ + Bundle get(int subId); + + // Configuration keys and default values + + /** Boolean value: if MMS is enabled */ + public static final String CONFIG_ENABLED_MMS = "enabledMMS"; + public static final boolean CONFIG_ENABLED_MMS_DEFAULT = true; + /** + * Boolean value: if transaction ID should be appended to + * the download URL of a single segment WAP push message + */ + public static final String CONFIG_ENABLED_TRANS_ID = "enabledTransID"; + public static final boolean CONFIG_ENABLED_TRANS_ID_DEFAULT = false; + /** + * Boolean value: if acknowledge or notify response to a download + * should be sent to the WAP push message's download URL + */ + public static final String CONFIG_ENABLED_NOTIFY_WAP_MMSC = "enabledNotifyWapMMSC"; + public static final boolean CONFIG_ENABLED_NOTIFY_WAP_MMSC_DEFAULT = false; + /** + * Boolean value: if phone number alias can be used + */ + public static final String CONFIG_ALIAS_ENABLED = "aliasEnabled"; + public static final boolean CONFIG_ALIAS_ENABLED_DEFAULT = false; + /** + * Boolean value: if audio is allowed in attachment + */ + public static final String CONFIG_ALLOW_ATTACH_AUDIO = "allowAttachAudio"; + public static final boolean CONFIG_ALLOW_ATTACH_AUDIO_DEFAULT = true; + /** + * Boolean value: if true, long sms messages are always sent as multi-part sms + * messages, with no checked limit on the number of segments. If false, then + * as soon as the user types a message longer than a single segment (i.e. 140 chars), + * the message will turn into and be sent as an mms message or separate, + * independent SMS messages (dependent on CONFIG_SEND_MULTIPART_SMS_AS_SEPARATE_MESSAGES flag). + * This feature exists for carriers that don't support multi-part sms. + */ + public static final String CONFIG_ENABLE_MULTIPART_SMS = "enableMultipartSMS"; + public static final boolean CONFIG_ENABLE_MULTIPART_SMS_DEFAULT = true; + /** + * Boolean value: if SMS delivery report is supported + */ + public static final String CONFIG_ENABLE_SMS_DELIVERY_REPORTS = "enableSMSDeliveryReports"; + public static final boolean CONFIG_ENABLE_SMS_DELIVERY_REPORTS_DEFAULT = true; + /** + * Boolean value: if group MMS is supported + */ + public static final String CONFIG_ENABLE_GROUP_MMS = "enableGroupMms"; + public static final boolean CONFIG_ENABLE_GROUP_MMS_DEFAULT = true; + /** + * Boolean value: if the content_disposition field of an MMS part should be parsed + * Check wap-230-wsp-20010705-a.pdf, chapter 8.4.2.21. Most carriers support it except some. + */ + public static final String CONFIG_SUPPORT_MMS_CONTENT_DISPOSITION = + "supportMmsContentDisposition"; + public static final boolean CONFIG_SUPPORT_MMS_CONTENT_DISPOSITION_DEFAULT = true; + /** + * Boolean value: if the sms app should support a link to the system settings + * where amber alerts are configured. + */ + public static final String CONFIG_CELL_BROADCAST_APP_LINKS = "config_cellBroadcastAppLinks"; + public static final boolean CONFIG_CELL_BROADCAST_APP_LINKS_DEFAULT = true; + /** + * Boolean value: if multipart SMS should be sent as separate SMS messages + */ + public static final String CONFIG_SEND_MULTIPART_SMS_AS_SEPARATE_MESSAGES = + "sendMultipartSmsAsSeparateMessages"; + public static final boolean CONFIG_SEND_MULTIPART_SMS_AS_SEPARATE_MESSAGES_DEFAULT = false; + /** + * Boolean value: if MMS read report is supported + */ + public static final String CONFIG_ENABLE_MMS_READ_REPORTS = "enableMMSReadReports"; + public static final boolean CONFIG_ENABLE_MMS_READ_REPORTS_DEFAULT = false; + /** + * Boolean value: if MMS delivery report is supported + */ + public static final String CONFIG_ENABLE_MMS_DELIVERY_REPORTS = "enableMMSDeliveryReports"; + public static final boolean CONFIG_ENABLE_MMS_DELIVERY_REPORTS_DEFAULT = false; + /** + * Boolean value: if "charset" value is supported in the "Content-Type" HTTP header + */ + public static final String CONFIG_SUPPORT_HTTP_CHARSET_HEADER = "supportHttpCharsetHeader"; + public static final boolean CONFIG_SUPPORT_HTTP_CHARSET_HEADER_DEFAULT = false; + /** + * Integer value: maximal MMS message size in bytes + */ + public static final String CONFIG_MAX_MESSAGE_SIZE = "maxMessageSize"; + public static final int CONFIG_MAX_MESSAGE_SIZE_DEFAULT = 300 * 1024; + /** + * Integer value: maximal MMS image height in pixels + */ + public static final String CONFIG_MAX_IMAGE_HEIGHT = "maxImageHeight"; + public static final int CONFIG_MAX_IMAGE_HEIGHT_DEFAULT = 480; + /** + * Integer value: maximal MMS image width in pixels + */ + public static final String CONFIG_MAX_IMAGE_WIDTH = "maxImageWidth"; + public static final int CONFIG_MAX_IMAGE_WIDTH_DEFAULT = 640; + /** + * Integer value: limit on recipient list of an MMS message + */ + public static final String CONFIG_RECIPIENT_LIMIT = "recipientLimit"; + public static final int CONFIG_RECIPIENT_LIMIT_DEFAULT = Integer.MAX_VALUE; + /** + * Integer value: HTTP socket timeout in milliseconds for MMS + */ + public static final String CONFIG_HTTP_SOCKET_TIMEOUT = "httpSocketTimeout"; + public static final int CONFIG_HTTP_SOCKET_TIMEOUT_DEFAULT = 60 * 1000; + /** + * Integer value: minimal number of characters of an alias + */ + public static final String CONFIG_ALIAS_MIN_CHARS = "aliasMinChars"; + public static final int CONFIG_ALIAS_MIN_CHARS_DEFAULT = 2; + /** + * Integer value: maximal number of characters of an alias + */ + public static final String CONFIG_ALIAS_MAX_CHARS = "aliasMaxChars"; + public static final int CONFIG_ALIAS_MAX_CHARS_DEFAULT = 48; + /** + * Integer value: the threshold of number of SMS parts when an multipart SMS will be + * converted into an MMS, e.g. if this is "4", when an multipart SMS message has 5 + * parts, then it will be sent as MMS message instead. "-1" indicates no such conversion + * can happen. + */ + public static final String CONFIG_SMS_TO_MMS_TEXT_THRESHOLD = "smsToMmsTextThreshold"; + public static final int CONFIG_SMS_TO_MMS_TEXT_THRESHOLD_DEFAULT = -1; + /** + * Integer value: the threshold of SMS length when it will be converted into an MMS. + * "-1" indicates no such conversion can happen. + */ + public static final String CONFIG_SMS_TO_MMS_TEXT_LENGTH_THRESHOLD = + "smsToMmsTextLengthThreshold"; + public static final int CONFIG_SMS_TO_MMS_TEXT_LENGTH_THRESHOLD_DEFAULT = -1; + /** + * Integer value: maximal length in bytes of SMS message + */ + public static final String CONFIG_MAX_MESSAGE_TEXT_SIZE = "maxMessageTextSize"; + public static final int CONFIG_MAX_MESSAGE_TEXT_SIZE_DEFAULT = -1; + /** + * Integer value: maximum number of characters allowed for mms subject + */ + public static final String CONFIG_MAX_SUBJECT_LENGTH = "maxSubjectLength"; + public static final int CONFIG_MAX_SUBJECT_LENGTH_DEFAULT = 40; + /** + * String value: name for the user agent profile HTTP header + */ + public static final String CONFIG_UA_PROF_TAG_NAME = "mUaProfTagName"; + public static final String CONFIG_UA_PROF_TAG_NAME_DEFAULT = "x-wap-profile"; + /** + * String value: additional HTTP headers for MMS HTTP requests. + * The format is + * header_1:header_value_1|header_2:header_value_2|... + * Each value can contain macros. + */ + public static final String CONFIG_HTTP_PARAMS = "httpParams"; + public static final String CONFIG_HTTP_PARAMS_DEFAULT = null; + /** + * String value: number of email gateway + */ + public static final String CONFIG_EMAIL_GATEWAY_NUMBER = "emailGatewayNumber"; + public static final String CONFIG_EMAIL_GATEWAY_NUMBER_DEFAULT = null; + /** + * String value: suffix for the NAI HTTP header value, e.g. ":pcs" + * (NAI is used as authentication in HTTP headers for some carriers) + */ + public static final String CONFIG_NAI_SUFFIX = "naiSuffix"; + public static final String CONFIG_NAI_SUFFIX_DEFAULT = null; +} diff --git a/src/android/support/v7/mms/CarrierConfigXmlParser.java b/src/android/support/v7/mms/CarrierConfigXmlParser.java new file mode 100644 index 0000000..42e7c21 --- /dev/null +++ b/src/android/support/v7/mms/CarrierConfigXmlParser.java @@ -0,0 +1,68 @@ +/* + * 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 android.support.v7.mms; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; + +/** + * XML parser for carrier config (i.e. mms_config) + */ +class CarrierConfigXmlParser extends MmsXmlResourceParser { + interface KeyValueProcessor { + void process(String type, String key, String value); + } + + private static final String TAG_MMS_CONFIG = "mms_config"; + + private final KeyValueProcessor mKeyValueProcessor; + + CarrierConfigXmlParser(final XmlPullParser parser, final KeyValueProcessor keyValueProcessor) { + super(parser); + mKeyValueProcessor = keyValueProcessor; + } + + // Parse one key/value + @Override + protected void parseRecord() throws IOException, XmlPullParserException { + final String key = mInputParser.getAttributeValue(null, "name"); + // We are at the start tag, the name of the tag is the type + // e.g. <int name="key">value</int> + final String type = mInputParser.getName(); + int nextEvent = mInputParser.next(); + String value = null; + if (nextEvent == XmlPullParser.TEXT) { + value = mInputParser.getText(); + nextEvent = mInputParser.next(); + } + if (nextEvent != XmlPullParser.END_TAG) { + throw new XmlPullParserException("Expecting end tag @" + xmlParserDebugContext()); + } + // We are done parsing one mms_config key/value, call the handler + if (mKeyValueProcessor != null) { + mKeyValueProcessor.process(type, key, value); + } + } + + @Override + protected String getRootTag() { + return TAG_MMS_CONFIG; + } + +} diff --git a/src/android/support/v7/mms/DefaultApnSettingsLoader.java b/src/android/support/v7/mms/DefaultApnSettingsLoader.java new file mode 100644 index 0000000..83f2fd3 --- /dev/null +++ b/src/android/support/v7/mms/DefaultApnSettingsLoader.java @@ -0,0 +1,497 @@ +/* + * 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 android.support.v7.mms; + +import android.content.ContentValues; +import android.content.Context; +import android.content.res.Resources; +import android.content.res.XmlResourceParser; +import android.database.Cursor; +import android.database.sqlite.SQLiteException; +import android.net.Uri; +import android.provider.Telephony; +import android.text.TextUtils; +import android.util.Log; +import android.util.SparseArray; + +import com.android.messaging.R; + +import java.net.URI; +import java.net.URISyntaxException; +import java.util.ArrayList; +import java.util.List; + +/** + * Default implementation of APN settings loader + */ +class DefaultApnSettingsLoader implements ApnSettingsLoader { + /** + * The base implementation of an APN + */ + private static class BaseApn implements Apn { + /** + * Create a base APN from parameters + * + * @param typesIn the APN type field + * @param mmscIn the APN mmsc field + * @param proxyIn the APN mmsproxy field + * @param portIn the APN mmsport field + * @return an instance of base APN, or null if any of the parameter is invalid + */ + public static BaseApn from(final String typesIn, final String mmscIn, final String proxyIn, + final String portIn) { + if (!isValidApnType(trimWithNullCheck(typesIn), APN_TYPE_MMS)) { + return null; + } + String mmsc = trimWithNullCheck(mmscIn); + if (TextUtils.isEmpty(mmsc)) { + return null; + } + mmsc = trimV4AddrZeros(mmsc); + try { + new URI(mmsc); + } catch (final URISyntaxException e) { + return null; + } + String mmsProxy = trimWithNullCheck(proxyIn); + int mmsProxyPort = 80; + if (!TextUtils.isEmpty(mmsProxy)) { + mmsProxy = trimV4AddrZeros(mmsProxy); + final String portString = trimWithNullCheck(portIn); + if (portString != null) { + try { + mmsProxyPort = Integer.parseInt(portString); + } catch (final NumberFormatException e) { + // Ignore, just use 80 to try + } + } + } + return new BaseApn(mmsc, mmsProxy, mmsProxyPort); + } + + private final String mMmsc; + private final String mMmsProxy; + private final int mMmsProxyPort; + + public BaseApn(final String mmsc, final String proxy, final int port) { + mMmsc = mmsc; + mMmsProxy = proxy; + mMmsProxyPort = port; + } + + @Override + public String getMmsc() { + return mMmsc; + } + + @Override + public String getMmsProxy() { + return mMmsProxy; + } + + @Override + public int getMmsProxyPort() { + return mMmsProxyPort; + } + + @Override + public void setSuccess() { + // Do nothing + } + + public boolean equals(final BaseApn other) { + return TextUtils.equals(mMmsc, other.getMmsc()) && + TextUtils.equals(mMmsProxy, other.getMmsProxy()) && + mMmsProxyPort == other.getMmsProxyPort(); + } + } + + /** + * An in-memory implementation of an APN. These APNs are organized into an in-memory list. + * The order of the list can be changed by the setSuccess method. + */ + private static class MemoryApn implements Apn { + /** + * Create an in-memory APN loaded from resources + * + * @param apns the in-memory APN list + * @param typesIn the APN type field + * @param mmscIn the APN mmsc field + * @param proxyIn the APN mmsproxy field + * @param portIn the APN mmsport field + * @return an in-memory APN instance, null if there is invalid parameter + */ + public static MemoryApn from(final List<Apn> apns, final String typesIn, + final String mmscIn, final String proxyIn, final String portIn) { + if (apns == null) { + return null; + } + final BaseApn base = BaseApn.from(typesIn, mmscIn, proxyIn, portIn); + if (base == null) { + return null; + } + for (final Apn apn : apns) { + if (apn instanceof MemoryApn && ((MemoryApn) apn).equals(base)) { + return null; + } + } + return new MemoryApn(apns, base); + } + + private final List<Apn> mApns; + private final BaseApn mBase; + + public MemoryApn(final List<Apn> apns, final BaseApn base) { + mApns = apns; + mBase = base; + } + + @Override + public String getMmsc() { + return mBase.getMmsc(); + } + + @Override + public String getMmsProxy() { + return mBase.getMmsProxy(); + } + + @Override + public int getMmsProxyPort() { + return mBase.getMmsProxyPort(); + } + + @Override + public void setSuccess() { + // If this is being marked as a successful APN, move it to the top of the list so + // next time it will be tried first + boolean moved = false; + synchronized (mApns) { + if (mApns.get(0) != this) { + mApns.remove(this); + mApns.add(0, this); + moved = true; + } + } + if (moved) { + Log.d(MmsService.TAG, "Set APN [" + + "MMSC=" + getMmsc() + ", " + + "PROXY=" + getMmsProxy() + ", " + + "PORT=" + getMmsProxyPort() + "] to be first"); + } + } + + public boolean equals(final BaseApn other) { + if (other == null) { + return false; + } + return mBase.equals(other); + } + } + + /** + * APN_TYPE_ALL is a special type to indicate that this APN entry can + * service all data connections. + */ + public static final String APN_TYPE_ALL = "*"; + /** APN type for MMS traffic */ + public static final String APN_TYPE_MMS = "mms"; + + private static final String[] APN_PROJECTION = { + Telephony.Carriers.TYPE, + Telephony.Carriers.MMSC, + Telephony.Carriers.MMSPROXY, + Telephony.Carriers.MMSPORT, + }; + private static final int COLUMN_TYPE = 0; + private static final int COLUMN_MMSC = 1; + private static final int COLUMN_MMSPROXY = 2; + private static final int COLUMN_MMSPORT = 3; + + private static final String APN_MCC = "mcc"; + private static final String APN_MNC = "mnc"; + private static final String APN_APN = "apn"; + private static final String APN_TYPE = "type"; + private static final String APN_MMSC = "mmsc"; + private static final String APN_MMSPROXY = "mmsproxy"; + private static final String APN_MMSPORT = "mmsport"; + + private final Context mContext; + + // Cached APNs for subIds + private final SparseArray<List<Apn>> mApnsCache; + + DefaultApnSettingsLoader(final Context context) { + mContext = context; + mApnsCache = new SparseArray<>(); + } + + @Override + public List<Apn> get(final String apnName) { + final int subId = Utils.getEffectiveSubscriptionId(MmsManager.DEFAULT_SUB_ID); + List<Apn> apns; + boolean didLoad = false; + synchronized (this) { + apns = mApnsCache.get(subId); + if (apns == null) { + apns = new ArrayList<>(); + mApnsCache.put(subId, apns); + loadLocked(subId, apnName, apns); + didLoad = true; + } + } + if (didLoad) { + Log.i(MmsService.TAG, "Loaded " + apns.size() + " APNs"); + } + return apns; + } + + private void loadLocked(final int subId, final String apnName, final List<Apn> apns) { + // Try system APN table first + loadFromSystem(subId, apnName, apns); + if (apns.size() > 0) { + return; + } + // Try loading from apns.xml in resources + loadFromResources(subId, apnName, apns); + if (apns.size() > 0) { + return; + } + // Try resources but without APN name + loadFromResources(subId, null/*apnName*/, apns); + } + + /** + * Load matching APNs from telephony provider. + * We try different combinations of the query to work around some platform quirks. + * + * @param subId the SIM subId + * @param apnName the APN name to match + * @param apns the list used to return results + */ + private void loadFromSystem(final int subId, final String apnName, final List<Apn> apns) { + Uri uri; + if (Utils.supportMSim() && subId != MmsManager.DEFAULT_SUB_ID) { + uri = Uri.withAppendedPath(Telephony.Carriers.CONTENT_URI, "/subId/" + subId); + } else { + uri = Telephony.Carriers.CONTENT_URI; + } + Cursor cursor = null; + try { + for (; ; ) { + // Try different combinations of queries. Some would work on some platforms. + // So we query each combination until we find one returns non-empty result. + cursor = querySystem(uri, true/*checkCurrent*/, apnName); + if (cursor != null) { + break; + } + cursor = querySystem(uri, false/*checkCurrent*/, apnName); + if (cursor != null) { + break; + } + cursor = querySystem(uri, true/*checkCurrent*/, null/*apnName*/); + if (cursor != null) { + break; + } + cursor = querySystem(uri, false/*checkCurrent*/, null/*apnName*/); + break; + } + } catch (final SecurityException e) { + // Can't access platform APN table, return directly + return; + } + if (cursor == null) { + return; + } + try { + if (cursor.moveToFirst()) { + final Apn apn = BaseApn.from( + cursor.getString(COLUMN_TYPE), + cursor.getString(COLUMN_MMSC), + cursor.getString(COLUMN_MMSPROXY), + cursor.getString(COLUMN_MMSPORT)); + if (apn != null) { + apns.add(apn); + } + } + } finally { + cursor.close(); + } + } + + /** + * Query system APN table + * + * @param uri The APN query URL to use + * @param checkCurrent If add "CURRENT IS NOT NULL" condition + * @param apnName The optional APN name for query condition + * @return A cursor of the query result. If a cursor is returned as not null, it is + * guaranteed to contain at least one row. + */ + private Cursor querySystem(final Uri uri, final boolean checkCurrent, String apnName) { + Log.i(MmsService.TAG, "Loading APNs from system, " + + "checkCurrent=" + checkCurrent + " apnName=" + apnName); + final StringBuilder selectionBuilder = new StringBuilder(); + String[] selectionArgs = null; + if (checkCurrent) { + selectionBuilder.append(Telephony.Carriers.CURRENT).append(" IS NOT NULL"); + } + apnName = trimWithNullCheck(apnName); + if (!TextUtils.isEmpty(apnName)) { + if (selectionBuilder.length() > 0) { + selectionBuilder.append(" AND "); + } + selectionBuilder.append(Telephony.Carriers.APN).append("=?"); + selectionArgs = new String[] { apnName }; + } + try { + final Cursor cursor = mContext.getContentResolver().query( + uri, + APN_PROJECTION, + selectionBuilder.toString(), + selectionArgs, + null/*sortOrder*/); + if (cursor == null || cursor.getCount() < 1) { + if (cursor != null) { + cursor.close(); + } + Log.w(MmsService.TAG, "Query " + uri + " with apn " + apnName + " and " + + (checkCurrent ? "checking CURRENT" : "not checking CURRENT") + + " returned empty"); + return null; + } + return cursor; + } catch (final SQLiteException e) { + Log.w(MmsService.TAG, "APN table query exception: " + e); + } catch (final SecurityException e) { + Log.w(MmsService.TAG, "Platform restricts APN table access: " + e); + throw e; + } + return null; + } + + /** + * Find matching APNs using builtin APN list resource + * + * @param subId the SIM subId + * @param apnName the APN name to match + * @param apns the list for returning results + */ + private void loadFromResources(final int subId, final String apnName, final List<Apn> apns) { + Log.i(MmsService.TAG, "Loading APNs from resources, apnName=" + apnName); + final int[] mccMnc = Utils.getMccMnc(mContext, subId); + if (mccMnc[0] == 0 && mccMnc[0] == 0) { + Log.w(MmsService.TAG, "Can not get valid mcc/mnc from system"); + return; + } + // MCC/MNC is good, loading/querying APNs from XML + XmlResourceParser xml = null; + try { + xml = mContext.getResources().getXml(R.xml.apns); + new ApnsXmlParser(xml, new ApnsXmlParser.ApnProcessor() { + @Override + public void process(ContentValues apnValues) { + final String mcc = trimWithNullCheck(apnValues.getAsString(APN_MCC)); + final String mnc = trimWithNullCheck(apnValues.getAsString(APN_MNC)); + final String apn = trimWithNullCheck(apnValues.getAsString(APN_APN)); + try { + if (mccMnc[0] == Integer.parseInt(mcc) && + mccMnc[1] == Integer.parseInt(mnc) && + (TextUtils.isEmpty(apnName) || apnName.equalsIgnoreCase(apn))) { + final String type = apnValues.getAsString(APN_TYPE); + final String mmsc = apnValues.getAsString(APN_MMSC); + final String mmsproxy = apnValues.getAsString(APN_MMSPROXY); + final String mmsport = apnValues.getAsString(APN_MMSPORT); + final Apn newApn = MemoryApn.from(apns, type, mmsc, mmsproxy, mmsport); + if (newApn != null) { + apns.add(newApn); + } + } + } catch (final NumberFormatException e) { + // Ignore + } + } + }).parse(); + } catch (final Resources.NotFoundException e) { + Log.w(MmsService.TAG, "Can not get apns.xml " + e); + } finally { + if (xml != null) { + xml.close(); + } + } + } + + private static String trimWithNullCheck(final String value) { + return value != null ? value.trim() : null; + } + + /** + * Trim leading zeros from IPv4 address strings + * Our base libraries will interpret that as octel.. + * Must leave non v4 addresses and host names alone. + * For example, 192.168.000.010 -> 192.168.0.10 + * + * @param addr a string representing an ip addr + * @return a string propertly trimmed + */ + private static String trimV4AddrZeros(final String addr) { + if (addr == null) { + return null; + } + final String[] octets = addr.split("\\."); + if (octets.length != 4) { + return addr; + } + final StringBuilder builder = new StringBuilder(16); + String result = null; + for (int i = 0; i < 4; i++) { + try { + if (octets[i].length() > 3) { + return addr; + } + builder.append(Integer.parseInt(octets[i])); + } catch (final NumberFormatException e) { + return addr; + } + if (i < 3) { + builder.append('.'); + } + } + result = builder.toString(); + return result; + } + + /** + * Check if the APN contains the APN type we want + * + * @param types The string encodes a list of supported types + * @param requestType The type we want + * @return true if the input types string contains the requestType + */ + public static boolean isValidApnType(final String types, final String requestType) { + // If APN type is unspecified, assume APN_TYPE_ALL. + if (TextUtils.isEmpty(types)) { + return true; + } + for (final String t : types.split(",")) { + if (t.equals(requestType) || t.equals(APN_TYPE_ALL)) { + return true; + } + } + return false; + } +} diff --git a/src/android/support/v7/mms/DefaultCarrierConfigValuesLoader.java b/src/android/support/v7/mms/DefaultCarrierConfigValuesLoader.java new file mode 100644 index 0000000..1d45f8f --- /dev/null +++ b/src/android/support/v7/mms/DefaultCarrierConfigValuesLoader.java @@ -0,0 +1,126 @@ +/* + * 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 android.support.v7.mms; + +import android.content.Context; +import android.content.res.Resources; +import android.content.res.XmlResourceParser; +import android.os.Bundle; +import android.util.Log; +import android.util.SparseArray; + +import com.android.messaging.R; + +/** + * The default implementation of loader for carrier config values + */ +class DefaultCarrierConfigValuesLoader implements CarrierConfigValuesLoader { + /* + * Key types + */ + public static final String KEY_TYPE_INT = "int"; + public static final String KEY_TYPE_BOOL = "bool"; + public static final String KEY_TYPE_STRING = "string"; + + private final Context mContext; + + // Cached values for subIds + private final SparseArray<Bundle> mValuesCache; + + DefaultCarrierConfigValuesLoader(final Context context) { + mContext = context; + mValuesCache = new SparseArray<>(); + } + + @Override + public Bundle get(int subId) { + subId = Utils.getEffectiveSubscriptionId(subId); + Bundle values; + boolean didLoad = false; + synchronized (this) { + values = mValuesCache.get(subId); + if (values == null) { + values = new Bundle(); + mValuesCache.put(subId, values); + loadLocked(subId, values); + didLoad = true; + } + } + if (didLoad) { + Log.i(MmsService.TAG, "Carrier configs loaded: " + values); + } + return values; + } + + private void loadLocked(final int subId, final Bundle values) { + // For K and earlier, load from resources + loadFromResources(subId, values); + if (Utils.hasMmsApi()) { + // For L and later, also load from system MMS service + loadFromSystem(subId, values); + } + } + + /** + * Load from system, using MMS API + * + * @param subId which SIM to load for + * @param values the result to add to + */ + private static void loadFromSystem(final int subId, final Bundle values) { + try { + final Bundle systemValues = Utils.getSmsManager(subId).getCarrierConfigValues(); + if (systemValues != null) { + values.putAll(systemValues); + } + } catch (final Exception e) { + Log.w(MmsService.TAG, "Calling system getCarrierConfigValues exception", e); + } + } + + private void loadFromResources(final int subId, final Bundle values) { + // Get a subscription-dependent context for loading the mms_config.xml + final Context subContext = Utils.getSubDepContext(mContext, subId); + XmlResourceParser xml = null; + try { + xml = subContext.getResources().getXml(R.xml.mms_config); + new CarrierConfigXmlParser(xml, new CarrierConfigXmlParser.KeyValueProcessor() { + @Override + public void process(String type, String key, String value) { + try { + if (KEY_TYPE_INT.equals(type)) { + values.putInt(key, Integer.parseInt(value)); + } else if (KEY_TYPE_BOOL.equals(type)) { + values.putBoolean(key, Boolean.parseBoolean(value)); + } else if (KEY_TYPE_STRING.equals(type)) { + values.putString(key, value); + } + } catch (final NumberFormatException e) { + Log.w(MmsService.TAG, "Load carrier value from resources: " + + "invalid " + key + "," + value + "," + type); + } + } + }).parse(); + } catch (final Resources.NotFoundException e) { + Log.w(MmsService.TAG, "Can not get mms_config.xml"); + } finally { + if (xml != null) { + xml.close(); + } + } + } +} diff --git a/src/android/support/v7/mms/DefaultUserAgentInfoLoader.java b/src/android/support/v7/mms/DefaultUserAgentInfoLoader.java new file mode 100644 index 0000000..e59a234 --- /dev/null +++ b/src/android/support/v7/mms/DefaultUserAgentInfoLoader.java @@ -0,0 +1,88 @@ +/* + * 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 android.support.v7.mms; + +import android.content.Context; +import android.telephony.TelephonyManager; +import android.text.TextUtils; +import android.util.Log; + +/** + * The default implementation of loader of UA and UAProfUrl + */ +class DefaultUserAgentInfoLoader implements UserAgentInfoLoader { + // Default values to be used as user agent info + private static final String DEFAULT_USER_AGENT = "Android MmsLib/1.0"; + private static final String DEFAULT_UA_PROF_URL = + "http://www.gstatic.com/android/sms/mms_ua_profile.xml"; + + private Context mContext; + private boolean mLoaded; + + private String mUserAgent; + private String mUAProfUrl; + + DefaultUserAgentInfoLoader(final Context context) { + mContext = context; + } + + @Override + public String getUserAgent() { + load(); + return mUserAgent; + } + + @Override + public String getUAProfUrl() { + load(); + return mUAProfUrl; + } + + private void load() { + if (mLoaded) { + return; + } + boolean didLoad = false; + synchronized (this) { + if (!mLoaded) { + loadLocked(); + mLoaded = true; + didLoad = true; + } + } + if (didLoad) { + Log.i(MmsService.TAG, "Loaded user agent info: " + + "UA=" + mUserAgent + ", UAProfUrl=" + mUAProfUrl); + } + } + + private void loadLocked() { + if (Utils.hasUserAgentApi()) { + // load the MMS User agent and UaProfUrl from TelephonyManager APIs + final TelephonyManager telephonyManager = (TelephonyManager) mContext.getSystemService( + Context.TELEPHONY_SERVICE); + mUserAgent = telephonyManager.getMmsUserAgent(); + mUAProfUrl = telephonyManager.getMmsUAProfUrl(); + } + if (TextUtils.isEmpty(mUserAgent)) { + mUserAgent = DEFAULT_USER_AGENT; + } + if (TextUtils.isEmpty(mUAProfUrl)) { + mUAProfUrl = DEFAULT_UA_PROF_URL; + } + } +} diff --git a/src/android/support/v7/mms/DownloadRequest.java b/src/android/support/v7/mms/DownloadRequest.java new file mode 100644 index 0000000..254c8ca --- /dev/null +++ b/src/android/support/v7/mms/DownloadRequest.java @@ -0,0 +1,132 @@ +/* + * 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 android.support.v7.mms; + +import android.app.PendingIntent; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.Parcelable; +import android.text.TextUtils; +import android.util.Log; + +import java.io.IOException; +import java.util.concurrent.Callable; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +/** + * Request to download an MMS + */ +class DownloadRequest extends MmsRequest { + + DownloadRequest(final String locationUrl, final Uri pduUri, + final PendingIntent sentIntent) { + super(locationUrl, pduUri, sentIntent); + } + + @Override + protected boolean loadRequest(final Context context, final Bundle mmsConfig) { + // No need to load PDU from app. Always true. + return true; + } + + @Override + protected boolean transferResponse(Context context, Intent fillIn, byte[] response) { + return writePduToContentUri(context, mPduUri, response); + } + + @Override + protected byte[] doHttp(Context context, MmsNetworkManager netMgr, ApnSettingsLoader.Apn apn, + Bundle mmsConfig, String userAgent, String uaProfUrl) throws MmsHttpException { + final MmsHttpClient httpClient = netMgr.getHttpClient(); + return httpClient.execute(getHttpRequestUrl(apn), null/*pdu*/, MmsHttpClient.METHOD_GET, + !TextUtils.isEmpty(apn.getMmsProxy()), apn.getMmsProxy(), apn.getMmsProxyPort(), + mmsConfig, userAgent, uaProfUrl); + + } + + @Override + protected String getHttpRequestUrl(final ApnSettingsLoader.Apn apn) { + return mLocationUrl; + } + + /** + * Write pdu bytes to content provider uri + * + * @param contentUri content provider uri to which bytes should be written + * @param pdu Bytes to write + * @return true if all bytes successfully written else false + */ + public boolean writePduToContentUri(final Context context, final Uri contentUri, + final byte[] pdu) { + if (contentUri == null || pdu == null) { + return false; + } + final Callable<Boolean> copyDownloadedPduToOutput = new Callable<Boolean>() { + public Boolean call() { + ParcelFileDescriptor.AutoCloseOutputStream outStream = null; + try { + final ContentResolver cr = context.getContentResolver(); + final ParcelFileDescriptor pduFd = cr.openFileDescriptor(contentUri, "w"); + outStream = new ParcelFileDescriptor.AutoCloseOutputStream(pduFd); + outStream.write(pdu); + return true; + } catch (IOException e) { + Log.e(MmsService.TAG, "Writing PDU to downloader: IO exception", e); + return false; + } finally { + if (outStream != null) { + try { + outStream.close(); + } catch (IOException ex) { + // Ignore + } + } + } + } + }; + final Future<Boolean> pendingResult = + mPduTransferExecutor.submit(copyDownloadedPduToOutput); + try { + return pendingResult.get(TASK_TIMEOUT_MS, TimeUnit.MILLISECONDS); + } catch (Exception e) { + // Typically a timeout occurred - cancel task + pendingResult.cancel(true); + } + return false; + } + + public static final Parcelable.Creator<DownloadRequest> CREATOR + = new Parcelable.Creator<DownloadRequest>() { + public DownloadRequest createFromParcel(Parcel in) { + return new DownloadRequest(in); + } + + public DownloadRequest[] newArray(int size) { + return new DownloadRequest[size]; + } + }; + + private DownloadRequest(Parcel in) { + super(in); + } +} diff --git a/src/android/support/v7/mms/MmsHttpClient.java b/src/android/support/v7/mms/MmsHttpClient.java new file mode 100644 index 0000000..8ca34da --- /dev/null +++ b/src/android/support/v7/mms/MmsHttpClient.java @@ -0,0 +1,523 @@ +/* + * 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 android.support.v7.mms; + +import android.content.Context; +import android.os.Bundle; +import android.telephony.SmsManager; +import android.telephony.SubscriptionInfo; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.text.TextUtils; +import android.util.Base64; +import android.util.Log; + +import java.io.BufferedInputStream; +import java.io.BufferedOutputStream; +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.InputStream; +import java.io.OutputStream; +import java.io.UnsupportedEncodingException; +import java.lang.reflect.Method; +import java.net.HttpURLConnection; +import java.net.InetSocketAddress; +import java.net.MalformedURLException; +import java.net.ProtocolException; +import java.net.Proxy; +import java.net.URL; +import java.util.List; +import java.util.Locale; +import java.util.Map; +import java.util.regex.Matcher; +import java.util.regex.Pattern; + +/** + * MMS HTTP client for sending and downloading MMS messages + */ +public class MmsHttpClient { + static final String METHOD_POST = "POST"; + static final String METHOD_GET = "GET"; + + private static final String HEADER_CONTENT_TYPE = "Content-Type"; + private static final String HEADER_ACCEPT = "Accept"; + private static final String HEADER_ACCEPT_LANGUAGE = "Accept-Language"; + private static final String HEADER_USER_AGENT = "User-Agent"; + + // The "Accept" header value + private static final String HEADER_VALUE_ACCEPT = + "*/*, application/vnd.wap.mms-message, application/vnd.wap.sic"; + // The "Content-Type" header value + private static final String HEADER_VALUE_CONTENT_TYPE_WITH_CHARSET = + "application/vnd.wap.mms-message; charset=utf-8"; + private static final String HEADER_VALUE_CONTENT_TYPE_WITHOUT_CHARSET = + "application/vnd.wap.mms-message"; + + /* + * Macro names + */ + // The raw phone number + private static final String MACRO_LINE1 = "LINE1"; + // The phone number without country code + private static final String MACRO_LINE1NOCOUNTRYCODE = "LINE1NOCOUNTRYCODE"; + // NAI (Network Access Identifier) + private static final String MACRO_NAI = "NAI"; + + // The possible NAI system property name + private static final String NAI_PROPERTY = "persist.radio.cdma.nai"; + + private final Context mContext; + private final TelephonyManager mTelephonyManager; + + /** + * Constructor + * + * @param context The Context object + */ + MmsHttpClient(Context context) { + mContext = context; + mTelephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + } + + /** + * Execute an MMS HTTP request, either a POST (sending) or a GET (downloading) + * + * @param urlString The request URL, for sending it is usually the MMSC, and for downloading + * it is the message URL + * @param pdu For POST (sending) only, the PDU to send + * @param method HTTP method, POST for sending and GET for downloading + * @param isProxySet Is there a proxy for the MMSC + * @param proxyHost The proxy host + * @param proxyPort The proxy port + * @param mmsConfig The MMS config to use + * @param userAgent The user agent header value + * @param uaProfUrl The UA Prof URL header value + * @return The HTTP response body + * @throws MmsHttpException For any failures + */ + public byte[] execute(String urlString, byte[] pdu, String method, boolean isProxySet, + String proxyHost, int proxyPort, Bundle mmsConfig, String userAgent, String uaProfUrl) + throws MmsHttpException { + Log.d(MmsService.TAG, "HTTP: " + method + " " + Utils.redactUrlForNonVerbose(urlString) + + (isProxySet ? (", proxy=" + proxyHost + ":" + proxyPort) : "") + + ", PDU size=" + (pdu != null ? pdu.length : 0)); + checkMethod(method); + HttpURLConnection connection = null; + try { + Proxy proxy = Proxy.NO_PROXY; + if (isProxySet) { + proxy = new Proxy(Proxy.Type.HTTP, new InetSocketAddress(proxyHost, proxyPort)); + } + final URL url = new URL(urlString); + // Now get the connection + connection = (HttpURLConnection) url.openConnection(proxy); + connection.setDoInput(true); + connection.setConnectTimeout( + mmsConfig.getInt(CarrierConfigValuesLoader.CONFIG_HTTP_SOCKET_TIMEOUT, + CarrierConfigValuesLoader.CONFIG_HTTP_SOCKET_TIMEOUT_DEFAULT)); + // ------- COMMON HEADERS --------- + // Header: Accept + connection.setRequestProperty(HEADER_ACCEPT, HEADER_VALUE_ACCEPT); + // Header: Accept-Language + connection.setRequestProperty( + HEADER_ACCEPT_LANGUAGE, getCurrentAcceptLanguage(Locale.getDefault())); + // Header: User-Agent + Log.i(MmsService.TAG, "HTTP: User-Agent=" + userAgent); + connection.setRequestProperty(HEADER_USER_AGENT, userAgent); + // Header: x-wap-profile + final String uaProfUrlTagName = mmsConfig.getString( + CarrierConfigValuesLoader.CONFIG_UA_PROF_TAG_NAME, + CarrierConfigValuesLoader.CONFIG_UA_PROF_TAG_NAME_DEFAULT); + if (uaProfUrl != null) { + Log.i(MmsService.TAG, "HTTP: UaProfUrl=" + uaProfUrl); + connection.setRequestProperty(uaProfUrlTagName, uaProfUrl); + } + // Add extra headers specified by mms_config.xml's httpparams + addExtraHeaders(connection, mmsConfig); + // Different stuff for GET and POST + if (METHOD_POST.equals(method)) { + if (pdu == null || pdu.length < 1) { + Log.e(MmsService.TAG, "HTTP: empty pdu"); + throw new MmsHttpException(0/*statusCode*/, "Sending empty PDU"); + } + connection.setDoOutput(true); + connection.setRequestMethod(METHOD_POST); + if (mmsConfig.getBoolean( + CarrierConfigValuesLoader.CONFIG_SUPPORT_HTTP_CHARSET_HEADER, + CarrierConfigValuesLoader.CONFIG_SUPPORT_HTTP_CHARSET_HEADER_DEFAULT)) { + connection.setRequestProperty(HEADER_CONTENT_TYPE, + HEADER_VALUE_CONTENT_TYPE_WITH_CHARSET); + } else { + connection.setRequestProperty(HEADER_CONTENT_TYPE, + HEADER_VALUE_CONTENT_TYPE_WITHOUT_CHARSET); + } + if (Log.isLoggable(MmsService.TAG, Log.VERBOSE)) { + logHttpHeaders(connection.getRequestProperties()); + } + connection.setFixedLengthStreamingMode(pdu.length); + // Sending request body + final OutputStream out = + new BufferedOutputStream(connection.getOutputStream()); + out.write(pdu); + out.flush(); + out.close(); + } else if (METHOD_GET.equals(method)) { + if (Log.isLoggable(MmsService.TAG, Log.VERBOSE)) { + logHttpHeaders(connection.getRequestProperties()); + } + connection.setRequestMethod(METHOD_GET); + } + // Get response + final int responseCode = connection.getResponseCode(); + final String responseMessage = connection.getResponseMessage(); + Log.d(MmsService.TAG, "HTTP: " + responseCode + " " + responseMessage); + if (Log.isLoggable(MmsService.TAG, Log.VERBOSE)) { + logHttpHeaders(connection.getHeaderFields()); + } + if (responseCode / 100 != 2) { + throw new MmsHttpException(responseCode, responseMessage); + } + final InputStream in = new BufferedInputStream(connection.getInputStream()); + final ByteArrayOutputStream byteOut = new ByteArrayOutputStream(); + final byte[] buf = new byte[4096]; + int count = 0; + while ((count = in.read(buf)) > 0) { + byteOut.write(buf, 0, count); + } + in.close(); + final byte[] responseBody = byteOut.toByteArray(); + Log.d(MmsService.TAG, "HTTP: response size=" + + (responseBody != null ? responseBody.length : 0)); + return responseBody; + } catch (MalformedURLException e) { + final String redactedUrl = Utils.redactUrlForNonVerbose(urlString); + Log.e(MmsService.TAG, "HTTP: invalid URL " + redactedUrl, e); + throw new MmsHttpException(0/*statusCode*/, "Invalid URL " + redactedUrl, e); + } catch (ProtocolException e) { + final String redactedUrl = Utils.redactUrlForNonVerbose(urlString); + Log.e(MmsService.TAG, "HTTP: invalid URL protocol " + redactedUrl, e); + throw new MmsHttpException(0/*statusCode*/, "Invalid URL protocol " + redactedUrl, e); + } catch (IOException e) { + Log.e(MmsService.TAG, "HTTP: IO failure", e); + throw new MmsHttpException(0/*statusCode*/, e); + } finally { + if (connection != null) { + connection.disconnect(); + } + } + } + + private static void logHttpHeaders(Map<String, List<String>> headers) { + final StringBuilder sb = new StringBuilder(); + if (headers != null) { + for (Map.Entry<String, List<String>> entry : headers.entrySet()) { + final String key = entry.getKey(); + final List<String> values = entry.getValue(); + if (values != null) { + for (String value : values) { + sb.append(key).append('=').append(value).append('\n'); + } + } + } + Log.v(MmsService.TAG, "HTTP: headers\n" + sb.toString()); + } + } + + private static void checkMethod(String method) throws MmsHttpException { + if (!METHOD_GET.equals(method) && !METHOD_POST.equals(method)) { + throw new MmsHttpException(0/*statusCode*/, "Invalid method " + method); + } + } + + private static final String ACCEPT_LANG_FOR_US_LOCALE = "en-US"; + + /** + * Return the Accept-Language header. Use the current locale plus + * US if we are in a different locale than US. + * This code copied from the browser's WebSettings.java + * + * @return Current AcceptLanguage String. + */ + public static String getCurrentAcceptLanguage(Locale locale) { + final StringBuilder buffer = new StringBuilder(); + addLocaleToHttpAcceptLanguage(buffer, locale); + + if (!Locale.US.equals(locale)) { + if (buffer.length() > 0) { + buffer.append(", "); + } + buffer.append(ACCEPT_LANG_FOR_US_LOCALE); + } + + return buffer.toString(); + } + + /** + * Convert obsolete language codes, including Hebrew/Indonesian/Yiddish, + * to new standard. + */ + private static String convertObsoleteLanguageCodeToNew(String langCode) { + if (langCode == null) { + return null; + } + if ("iw".equals(langCode)) { + // Hebrew + return "he"; + } else if ("in".equals(langCode)) { + // Indonesian + return "id"; + } else if ("ji".equals(langCode)) { + // Yiddish + return "yi"; + } + return langCode; + } + + private static void addLocaleToHttpAcceptLanguage(StringBuilder builder, Locale locale) { + final String language = convertObsoleteLanguageCodeToNew(locale.getLanguage()); + if (language != null) { + builder.append(language); + final String country = locale.getCountry(); + if (country != null) { + builder.append("-"); + builder.append(country); + } + } + } + + private static final Pattern MACRO_P = Pattern.compile("##(\\S+)##"); + /** + * Resolve the macro in HTTP param value text + * For example, "something##LINE1##something" is resolved to "something9139531419something" + * + * @param value The HTTP param value possibly containing macros + * @return The HTTP param with macro resolved to real value + */ + private String resolveMacro(String value, Bundle mmsConfig) { + if (TextUtils.isEmpty(value)) { + return value; + } + final Matcher matcher = MACRO_P.matcher(value); + int nextStart = 0; + StringBuilder replaced = null; + while (matcher.find()) { + if (replaced == null) { + replaced = new StringBuilder(); + } + final int matchedStart = matcher.start(); + if (matchedStart > nextStart) { + replaced.append(value.substring(nextStart, matchedStart)); + } + final String macro = matcher.group(1); + final String macroValue = getHttpParamMacro(macro, mmsConfig); + if (macroValue != null) { + replaced.append(macroValue); + } + nextStart = matcher.end(); + } + if (replaced != null && nextStart < value.length()) { + replaced.append(value.substring(nextStart)); + } + return replaced == null ? value : replaced.toString(); + } + + /** + * Add extra HTTP headers from mms_config.xml's httpParams, which is a list of key/value + * pairs separated by "|". Each key/value pair is separated by ":". Value may contain + * macros like "##LINE1##" or "##NAI##" which is resolved with methods in this class + * + * @param connection The HttpURLConnection that we add headers to + * @param mmsConfig The MmsConfig object + */ + private void addExtraHeaders(HttpURLConnection connection, Bundle mmsConfig) { + final String extraHttpParams = mmsConfig.getString( + CarrierConfigValuesLoader.CONFIG_HTTP_PARAMS); + if (!TextUtils.isEmpty(extraHttpParams)) { + // Parse the parameter list + String paramList[] = extraHttpParams.split("\\|"); + for (String paramPair : paramList) { + String splitPair[] = paramPair.split(":", 2); + if (splitPair.length == 2) { + final String name = splitPair[0].trim(); + final String value = resolveMacro(splitPair[1].trim(), mmsConfig); + if (!TextUtils.isEmpty(name) && !TextUtils.isEmpty(value)) { + // Add the header if the param is valid + connection.setRequestProperty(name, value); + } + } + } + } + } + + /** + * Return the HTTP param macro value. + * Example: LINE1 returns the phone number, etc. + * + * @param macro The macro name + * @param mmsConfig The carrier configuration values + * @return The value of the defined macro + */ + private String getHttpParamMacro(final String macro, final Bundle mmsConfig) { + if (MACRO_LINE1.equals(macro)) { + return getSelfNumber(); + } else if (MACRO_LINE1NOCOUNTRYCODE.equals(macro)) { + return PhoneNumberHelper.getNumberNoCountryCode( + getSelfNumber(), getSimOrLocaleCountry()); + } else if (MACRO_NAI.equals(macro)) { + return getEncodedNai(mmsConfig.getString( + CarrierConfigValuesLoader.CONFIG_NAI_SUFFIX, + CarrierConfigValuesLoader.CONFIG_NAI_SUFFIX_DEFAULT)); + } + return null; + } + + /** + * Get the device phone number + * + * @return the phone number text + */ + private String getSelfNumber() { + if (Utils.supportMSim()) { + final SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + final SubscriptionInfo info = subscriptionManager.getActiveSubscriptionInfo( + SmsManager.getDefaultSmsSubscriptionId()); + if (info != null) { + return info.getNumber(); + } else { + return null; + } + } else { + return mTelephonyManager.getLine1Number(); + } + } + + /** + * Get the country ISO code from SIM or system locale + * + * @return the country ISO code + */ + private String getSimOrLocaleCountry() { + String country = null; + if (Utils.supportMSim()) { + final SubscriptionManager subscriptionManager = SubscriptionManager.from(mContext); + final SubscriptionInfo info = subscriptionManager.getActiveSubscriptionInfo( + SmsManager.getDefaultSmsSubscriptionId()); + if (info != null) { + country = info.getCountryIso(); + } + } else { + country = mTelephonyManager.getSimCountryIso(); + } + if (!TextUtils.isEmpty(country)) { + return country.toUpperCase(); + } else { + return Locale.getDefault().getCountry(); + } + } + + /** + * Get encoded NAI string to use as the HTTP header for some carriers. + * On L-MR1+, we call the hidden system API to get this + * On L-MR1-, we try to find it via system property. + * + * @param naiSuffix the suffix to append to NAI before encoding + * @return the Base64 encoded NAI string to use as HTTP header + */ + private String getEncodedNai(final String naiSuffix) { + String nai; + if (Utils.supportMSim()) { + nai = getNaiBySystemApi( + getSlotId(Utils.getEffectiveSubscriptionId(MmsManager.DEFAULT_SUB_ID))); + } else { + nai = getNaiBySystemProperty(); + } + if (!TextUtils.isEmpty(nai)) { + Log.i(MmsService.TAG, "NAI is not empty"); + if (!TextUtils.isEmpty(naiSuffix)) { + nai = nai + naiSuffix; + } + byte[] encoded = null; + try { + encoded = Base64.encode(nai.getBytes("UTF-8"), Base64.NO_WRAP); + } catch (UnsupportedEncodingException e) { + encoded = Base64.encode(nai.getBytes(), Base64.NO_WRAP); + } + try { + return new String(encoded, "UTF-8"); + } catch (UnsupportedEncodingException e) { + return new String(encoded); + } + } + return null; + } + + /** + * Invoke hidden SubscriptionManager.getSlotId(int) + * + * @param subId the subId + * @return the SIM slot ID + */ + private static int getSlotId(final int subId) { + try { + final Method method = SubscriptionManager.class.getMethod("getSlotId", Integer.TYPE); + if (method != null) { + return (Integer) method.invoke(null, subId); + } + } catch (Exception e) { + Log.w(MmsService.TAG, "SubscriptionManager.getSlotId failed " + e); + } + return -1; + } + + /** + * Get NAI using hidden TelephonyManager.getNai(int) + * + * @param slotId the SIM slot ID + * @return the NAI string + */ + private String getNaiBySystemApi(final int slotId) { + try { + final Method method = mTelephonyManager.getClass().getMethod("getNai", Integer.TYPE); + if (method != null) { + return (String) method.invoke(mTelephonyManager, slotId); + } + } catch (Exception e) { + Log.w(MmsService.TAG, "TelephonyManager.getNai failed " + e); + } + return null; + } + + /** + * Get NAI using hidden SystemProperties.get(String) + * + * @return the NAI string as system property + */ + private static String getNaiBySystemProperty() { + try { + final Class systemPropertiesClass = Class.forName("android.os.SystemProperties"); + if (systemPropertiesClass != null) { + final Method method = systemPropertiesClass.getMethod("get", String.class); + if (method != null) { + return (String) method.invoke(null, NAI_PROPERTY); + } + } + } catch (Exception e) { + Log.w(MmsService.TAG, "SystemProperties.get failed " + e); + } + return null; + } +} diff --git a/src/android/support/v7/mms/MmsHttpException.java b/src/android/support/v7/mms/MmsHttpException.java new file mode 100644 index 0000000..913ba55 --- /dev/null +++ b/src/android/support/v7/mms/MmsHttpException.java @@ -0,0 +1,50 @@ +/* + * 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 android.support.v7.mms; + +/** + * HTTP exception + */ +public class MmsHttpException extends Exception { + // Optional HTTP status code. 0 means ignore. Otherwise this + // should be a valid HTTP status code. + private final int mStatusCode; + + public MmsHttpException(int statusCode) { + super(); + mStatusCode = statusCode; + } + + public MmsHttpException(int statusCode, String message) { + super(message); + mStatusCode = statusCode; + } + + public MmsHttpException(int statusCode, Throwable cause) { + super(cause); + mStatusCode = statusCode; + } + + public MmsHttpException(int statusCode, String message, Throwable cause) { + super(message, cause); + mStatusCode = statusCode; + } + + public int getStatusCode() { + return mStatusCode; + } +} diff --git a/src/android/support/v7/mms/MmsManager.java b/src/android/support/v7/mms/MmsManager.java new file mode 100644 index 0000000..f9c0a91 --- /dev/null +++ b/src/android/support/v7/mms/MmsManager.java @@ -0,0 +1,256 @@ +/* + * 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 android.support.v7.mms; + +import android.app.PendingIntent; +import android.content.Context; +import android.net.Uri; +import android.os.Bundle; +import android.telephony.SmsManager; +import android.util.SparseArray; + +/** + * The public interface of MMS library + */ +public class MmsManager { + /** + * Default subscription ID + */ + public static final int DEFAULT_SUB_ID = -1; + + // Whether to force legacy MMS sending + private static volatile boolean sForceLegacyMms = false; + + // Cached computed overrides for carrier configuration values + private static SparseArray<Bundle> sConfigOverridesMap = new SparseArray<>(); + + /** + * Set the flag about whether to force to use legacy system APIs instead of system MMS API + * + * @param forceLegacyMms value to set + */ + public static void setForceLegacyMms(boolean forceLegacyMms) { + sForceLegacyMms = forceLegacyMms; + } + + /** + * Set the size of thread pool for request execution. + * + * Default is 4 + * + * Note: if system MMS API is used, this has no effect + * + * @param size thread pool size + */ + public static void setThreadPoolSize(int size) { + MmsService.setThreadPoolSize(size); + } + + /** + * Set whether to use wake lock while sending or downloading MMS. + * + * Default value is true + * + * Note: if system MMS API is used, this has no effect + * + * @param useWakeLock true to use wake lock, false otherwise + */ + public static void setUseWakeLock(final boolean useWakeLock) { + MmsService.setUseWakeLock(useWakeLock); + } + + /** + * Set the optional carrier config values loader + * + * Note: if system MMS API is used, this is used to compute the overrides + * of carrier configuration values + * + * @param loader the carrier config values loader + */ + public static void setCarrierConfigValuesLoader(CarrierConfigValuesLoader loader) { + if (loader == null) { + throw new IllegalArgumentException("Carrier configuration loader can not be empty"); + } + synchronized (sConfigOverridesMap) { + MmsService.setCarrierConfigValuesLoader(loader); + sConfigOverridesMap.clear(); + } + } + + /** + * Set the optional APN settings loader + * + * Note: if system MMS API is used, this has no effect + * + * @param loader the APN settings loader + */ + public static void setApnSettingsLoader(ApnSettingsLoader loader) { + if (loader == null) { + throw new IllegalArgumentException("APN settings loader can not be empty"); + } + MmsService.setApnSettingsLoader(loader); + } + + /** + * Set user agent info loader + * + * Note: if system MMS API is used, this is used to compute the overrides + * of carrier configuration values + + * @param loader the user agent info loader + */ + public static void setUserAgentInfoLoader(final UserAgentInfoLoader loader) { + if (loader == null) { + throw new IllegalArgumentException("User agent info loader can not be empty"); + } + synchronized (sConfigOverridesMap) { + MmsService.setUserAgentInfoLoader(loader); + sConfigOverridesMap.clear(); + } + } + + /** + * Send MMS via platform MMS API (if platform supports and not forced to + * use legacy APIs) or legacy APIs + * + * @param subId the subscription ID of the SIM to use + * @param context the Context to use + * @param contentUri the content URI of the PDU to be sent + * @param locationUrl the optional location URL to use for sending + * @param sentIntent the pending intent for returning results + */ + public static void sendMultimediaMessage(int subId, Context context, Uri contentUri, + String locationUrl, PendingIntent sentIntent) { + if (Utils.hasMmsApi() && !sForceLegacyMms) { + subId = Utils.getEffectiveSubscriptionId(subId); + final SmsManager smsManager = Utils.getSmsManager(subId); + smsManager.sendMultimediaMessage(context, contentUri, locationUrl, + getConfigOverrides(subId), sentIntent); + } else { + MmsService.startRequest(context, new SendRequest(locationUrl, contentUri, sentIntent)); + } + } + + /** + * Download MMS via platform MMS API (if platform supports and not forced to + * use legacy APIs) or legacy APIs + * + * @param subId the subscription ID of the SIM to use + * @param context the Context to use + * @param contentUri the content URI of the PDU to be sent + * @param locationUrl the optional location URL to use for sending + * @param downloadedIntent the pending intent for returning results + */ + public static void downloadMultimediaMessage(int subId, Context context, String locationUrl, + Uri contentUri, PendingIntent downloadedIntent) { + if (Utils.hasMmsApi() && !sForceLegacyMms) { + subId = Utils.getEffectiveSubscriptionId(subId); + final SmsManager smsManager = Utils.getSmsManager(subId); + smsManager.downloadMultimediaMessage(context, locationUrl, contentUri, + getConfigOverrides(subId), downloadedIntent); + } else { + MmsService.startRequest(context, + new DownloadRequest(locationUrl, contentUri, downloadedIntent)); + } + } + + /** + * Get carrier configuration values overrides when platform MMS API is called. + * We only need to compute this if customized carrier config values loader or + * user agent info loader are set + * + * @param subId the ID of the SIM to use + * @return a Bundle containing the overrides + */ + private static Bundle getConfigOverrides(final int subId) { + if (!Utils.hasMmsApi()) { + // If MMS API is not present, it is not necessary to compute overrides + return null; + } + Bundle overrides = null; + synchronized (sConfigOverridesMap) { + overrides = sConfigOverridesMap.get(subId); + if (overrides == null) { + overrides = new Bundle(); + sConfigOverridesMap.put(subId, overrides); + computeOverridesLocked(subId, overrides); + } + } + return overrides; + } + + /** + * Compute the overrides, incorporating the user agent info + * + * @param subId the subId of the SIM to use + * @param overrides the computed values overrides + */ + private static void computeOverridesLocked(final int subId, final Bundle overrides) { + // Overrides not computed yet + final CarrierConfigValuesLoader carrierConfigValuesLoader = + MmsService.getCarrierConfigValuesLoader(); + if (carrierConfigValuesLoader != null && + !(carrierConfigValuesLoader instanceof DefaultCarrierConfigValuesLoader)) { + // Compute the overrides for carrier config values first if the config loader + // is not the default one. + final Bundle systemValues = Utils.getSmsManager(subId).getCarrierConfigValues(); + final Bundle callerValues = + MmsService.getCarrierConfigValuesLoader().get(subId); + if (systemValues != null && callerValues != null) { + computeConfigDelta(systemValues, callerValues, overrides); + } else if (systemValues == null && callerValues != null) { + overrides.putAll(callerValues); + } + } + final UserAgentInfoLoader userAgentInfoLoader = MmsService.getUserAgentInfoLoader(); + if (userAgentInfoLoader != null && + !(userAgentInfoLoader instanceof DefaultUserAgentInfoLoader)) { + // Also set the user agent and ua prof url via the overrides + // if the user agent loader is not the default one. + overrides.putString(UserAgentInfoLoader.CONFIG_USER_AGENT, + userAgentInfoLoader.getUserAgent()); + overrides.putString(UserAgentInfoLoader.CONFIG_UA_PROF_URL, + userAgentInfoLoader.getUAProfUrl()); + } + } + + /** + * Compute the delta between two sets of carrier configuration values: system and caller + * + * @param systemValues the system config values + * @param callerValues the caller's config values + * @param delta the delta of values (caller - system), using caller value to override system's + */ + private static void computeConfigDelta(final Bundle systemValues, final Bundle callerValues, + final Bundle delta) { + for (final String key : callerValues.keySet()) { + final Object callerValue = callerValues.get(key); + final Object systemValue = systemValues.get(key); + if ((callerValue != null && systemValue != null && !callerValue.equals(systemValue)) || + (callerValue != null && systemValue == null) || + (callerValue == null && systemValue != null)) { + if (callerValue == null || callerValue instanceof String) { + delta.putString(key, (String) callerValue); + } else if (callerValue instanceof Integer) { + delta.putInt(key, (Integer) callerValue); + } else if (callerValue instanceof Boolean) { + delta.putBoolean(key, (Boolean) callerValue); + } + } + } + } +} diff --git a/src/android/support/v7/mms/MmsNetworkException.java b/src/android/support/v7/mms/MmsNetworkException.java new file mode 100644 index 0000000..776d8ee --- /dev/null +++ b/src/android/support/v7/mms/MmsNetworkException.java @@ -0,0 +1,39 @@ +/* + * 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 android.support.v7.mms; + +/** + * MMS network exception + */ +class MmsNetworkException extends Exception { + + public MmsNetworkException() { + super(); + } + + public MmsNetworkException(String message) { + super(message); + } + + public MmsNetworkException(Throwable cause) { + super(cause); + } + + public MmsNetworkException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/android/support/v7/mms/MmsNetworkManager.java b/src/android/support/v7/mms/MmsNetworkManager.java new file mode 100644 index 0000000..0630293 --- /dev/null +++ b/src/android/support/v7/mms/MmsNetworkManager.java @@ -0,0 +1,382 @@ +/* + * 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 android.support.v7.mms; + +import android.content.BroadcastReceiver; +import android.content.Context; +import android.content.Intent; +import android.content.IntentFilter; +import android.net.ConnectivityManager; +import android.net.NetworkInfo; +import android.os.Build; +import android.os.SystemClock; +import android.util.Log; + +import java.lang.reflect.Method; +import java.util.Timer; +import java.util.TimerTask; + +/** + * Class manages MMS network connectivity using legacy platform APIs + * (deprecated since Android L) on pre-L devices (or when forced to + * be used on L and later) + */ +class MmsNetworkManager { + // Hidden platform constants + private static final String FEATURE_ENABLE_MMS = "enableMMS"; + private static final String REASON_VOICE_CALL_ENDED = "2GVoiceCallEnded"; + private static final int APN_ALREADY_ACTIVE = 0; + private static final int APN_REQUEST_STARTED = 1; + private static final int APN_TYPE_NOT_AVAILABLE = 2; + private static final int APN_REQUEST_FAILED = 3; + private static final int APN_ALREADY_INACTIVE = 4; + // A map from platform APN constant to text string + private static final String[] APN_RESULT_STRING = new String[]{ + "already active", + "request started", + "type not available", + "request failed", + "already inactive", + "unknown", + }; + + private static final long NETWORK_ACQUIRE_WAIT_INTERVAL_MS = 15000; + private static final long DEFAULT_NETWORK_ACQUIRE_TIMEOUT_MS = 180000; + private static final String MMS_NETWORK_EXTENSION_TIMER = "mms_network_extension_timer"; + private static final long MMS_NETWORK_EXTENSION_TIMER_WAIT_MS = 30000; + + private static volatile long sNetworkAcquireTimeoutMs = DEFAULT_NETWORK_ACQUIRE_TIMEOUT_MS; + + /** + * Set the network acquire timeout + * + * @param timeoutMs timeout in millisecond + */ + static void setNetworkAcquireTimeout(final long timeoutMs) { + sNetworkAcquireTimeoutMs = timeoutMs; + } + + private final Context mContext; + private final ConnectivityManager mConnectivityManager; + + // If the connectivity intent receiver is registered + private boolean mReceiverRegistered; + // Count of requests that are using the MMS network + private int mUseCount; + // Count of requests that are waiting for connectivity (i.e. in acquireNetwork wait loop) + private int mWaitCount; + // Timer to extend the network connectivity + private Timer mExtensionTimer; + + private final MmsHttpClient mHttpClient; + + private final IntentFilter mConnectivityIntentFilter; + private final BroadcastReceiver mConnectivityChangeReceiver = new BroadcastReceiver() { + @Override + public void onReceive(final Context context, final Intent intent) { + if (!ConnectivityManager.CONNECTIVITY_ACTION.equals(intent.getAction())) { + return; + } + final int networkType = getConnectivityChangeNetworkType(intent); + if (networkType != ConnectivityManager.TYPE_MOBILE_MMS) { + return; + } + onMmsConnectivityChange(context, intent); + } + }; + + MmsNetworkManager(final Context context) { + mContext = context; + mConnectivityManager = (ConnectivityManager) mContext.getSystemService( + Context.CONNECTIVITY_SERVICE); + mHttpClient = new MmsHttpClient(mContext); + mConnectivityIntentFilter = new IntentFilter(); + mConnectivityIntentFilter.addAction(ConnectivityManager.CONNECTIVITY_ACTION); + mUseCount = 0; + mWaitCount = 0; + } + + ConnectivityManager getConnectivityManager() { + return mConnectivityManager; + } + + MmsHttpClient getHttpClient() { + return mHttpClient; + } + + /** + * Synchronously acquire MMS network connectivity + * + * @throws MmsNetworkException If failed permanently or timed out + */ + void acquireNetwork() throws MmsNetworkException { + Log.i(MmsService.TAG, "Acquire MMS network"); + synchronized (this) { + try { + mUseCount++; + mWaitCount++; + if (mWaitCount == 1) { + // Register the receiver for the first waiting request + registerConnectivityChangeReceiverLocked(); + } + long waitMs = sNetworkAcquireTimeoutMs; + final long beginMs = SystemClock.elapsedRealtime(); + do { + if (!isMobileDataEnabled()) { + // Fast fail if mobile data is not enabled + throw new MmsNetworkException("Mobile data is disabled"); + } + // Always try to extend and check the MMS network connectivity + // before we start waiting to make sure we don't miss the change + // of MMS connectivity. As one example, some devices fail to send + // connectivity change intent. So this would make sure we catch + // the state change. + if (extendMmsConnectivityLocked()) { + // Connected + return; + } + try { + wait(Math.min(waitMs, NETWORK_ACQUIRE_WAIT_INTERVAL_MS)); + } catch (final InterruptedException e) { + Log.w(MmsService.TAG, "Unexpected exception", e); + } + // Calculate the remaining time to wait + waitMs = sNetworkAcquireTimeoutMs - (SystemClock.elapsedRealtime() - beginMs); + } while (waitMs > 0); + // Last check + if (extendMmsConnectivityLocked()) { + return; + } else { + // Reaching here means timed out. + throw new MmsNetworkException("Acquiring MMS network timed out"); + } + } finally { + mWaitCount--; + if (mWaitCount == 0) { + // Receiver is used to listen to connectivity change and unblock + // the waiting requests. If nobody's waiting on change, there is + // no need for the receiver. The auto extension timer will try + // to maintain the connectivity periodically. + unregisterConnectivityChangeReceiverLocked(); + } + } + } + } + + /** + * Release MMS network connectivity. This is ref counted. So it only disconnect + * when the ref count is 0. + */ + void releaseNetwork() { + Log.i(MmsService.TAG, "release MMS network"); + synchronized (this) { + mUseCount--; + if (mUseCount == 0) { + stopNetworkExtensionTimerLocked(); + endMmsConnectivity(); + } + } + } + + String getApnName() { + String apnName = null; + final NetworkInfo mmsNetworkInfo = mConnectivityManager.getNetworkInfo( + ConnectivityManager.TYPE_MOBILE_MMS); + if (mmsNetworkInfo != null) { + apnName = mmsNetworkInfo.getExtraInfo(); + } + return apnName; + } + + // Process mobile MMS connectivity change, waking up the waiting request thread + // in certain conditions: + // - Successfully connected + // - Failed permanently + // - Required another kickoff + // We don't initiate connection here but just notifyAll so the waiting request + // would wake up and retry connection before next wait. + private void onMmsConnectivityChange(final Context context, final Intent intent) { + if (mUseCount < 1) { + return; + } + final NetworkInfo mmsNetworkInfo = + mConnectivityManager.getNetworkInfo(ConnectivityManager.TYPE_MOBILE_MMS); + // Check availability of the mobile network. + if (mmsNetworkInfo != null) { + if (REASON_VOICE_CALL_ENDED.equals(mmsNetworkInfo.getReason())) { + // This is a very specific fix to handle the case where the phone receives an + // incoming call during the time we're trying to setup the mms connection. + // When the call ends, restart the process of mms connectivity. + // Once the waiting request is unblocked, before the next wait, we would start + // MMS network again. + unblockWait(); + } else { + final NetworkInfo.State state = mmsNetworkInfo.getState(); + if (state == NetworkInfo.State.CONNECTED || + (state == NetworkInfo.State.DISCONNECTED && !isMobileDataEnabled())) { + // Unblock the waiting request when we either connected + // OR + // disconnected due to mobile data disabled therefore needs to fast fail + // (on some devices if mobile data disabled and starting MMS would cause + // an immediate state change to disconnected, so causing a tight loop of + // trying and failing) + // Once the waiting request is unblocked, before the next wait, we would + // check mobile data and start MMS network again. So we should catch + // both the success and the fast failure. + unblockWait(); + } + } + } + } + + private void unblockWait() { + synchronized (this) { + notifyAll(); + } + } + + private void startNetworkExtensionTimerLocked() { + if (mExtensionTimer == null) { + mExtensionTimer = new Timer(MMS_NETWORK_EXTENSION_TIMER, true/*daemon*/); + mExtensionTimer.schedule( + new TimerTask() { + @Override + public void run() { + synchronized (this) { + if (mUseCount > 0) { + try { + // Try extending the connectivity + extendMmsConnectivityLocked(); + } catch (final MmsNetworkException e) { + // Ignore the exception + } + } + } + } + }, + MMS_NETWORK_EXTENSION_TIMER_WAIT_MS); + } + } + + private void stopNetworkExtensionTimerLocked() { + if (mExtensionTimer != null) { + mExtensionTimer.cancel(); + mExtensionTimer = null; + } + } + + private boolean extendMmsConnectivityLocked() throws MmsNetworkException { + final int result = startMmsConnectivity(); + if (result == APN_ALREADY_ACTIVE) { + // Already active + startNetworkExtensionTimerLocked(); + return true; + } else if (result != APN_REQUEST_STARTED) { + stopNetworkExtensionTimerLocked(); + throw new MmsNetworkException("Cannot acquire MMS network: " + + result + " - " + getMmsConnectivityResultString(result)); + } + return false; + } + + private int startMmsConnectivity() { + Log.i(MmsService.TAG, "Start MMS connectivity"); + try { + final Method method = mConnectivityManager.getClass().getMethod( + "startUsingNetworkFeature", Integer.TYPE, String.class); + if (method != null) { + return (Integer) method.invoke( + mConnectivityManager, ConnectivityManager.TYPE_MOBILE, FEATURE_ENABLE_MMS); + } + } catch (final Exception e) { + Log.w(MmsService.TAG, "ConnectivityManager.startUsingNetworkFeature failed " + e); + } + return APN_REQUEST_FAILED; + } + + private void endMmsConnectivity() { + Log.i(MmsService.TAG, "End MMS connectivity"); + try { + final Method method = mConnectivityManager.getClass().getMethod( + "stopUsingNetworkFeature", Integer.TYPE, String.class); + if (method != null) { + method.invoke( + mConnectivityManager, ConnectivityManager.TYPE_MOBILE, FEATURE_ENABLE_MMS); + } + } catch (final Exception e) { + Log.w(MmsService.TAG, "ConnectivityManager.stopUsingNetworkFeature failed " + e); + } + } + + private void registerConnectivityChangeReceiverLocked() { + if (!mReceiverRegistered) { + mContext.registerReceiver(mConnectivityChangeReceiver, mConnectivityIntentFilter); + mReceiverRegistered = true; + } + } + + private void unregisterConnectivityChangeReceiverLocked() { + if (mReceiverRegistered) { + mContext.unregisterReceiver(mConnectivityChangeReceiver); + mReceiverRegistered = false; + } + } + + /** + * The absence of a connection type. + */ + private static final int TYPE_NONE = -1; + + /** + * Get the network type of the connectivity change + * + * @param intent the broadcast intent of connectivity change + * @return The change's network type + */ + private static int getConnectivityChangeNetworkType(final Intent intent) { + if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.JELLY_BEAN_MR1) { + return intent.getIntExtra(ConnectivityManager.EXTRA_NETWORK_TYPE, TYPE_NONE); + } else { + final NetworkInfo info = intent.getParcelableExtra( + ConnectivityManager.EXTRA_NETWORK_INFO); + if (info != null) { + return info.getType(); + } + } + return TYPE_NONE; + } + + private static String getMmsConnectivityResultString(int result) { + if (result < 0 || result >= APN_RESULT_STRING.length) { + result = APN_RESULT_STRING.length - 1; + } + return APN_RESULT_STRING[result]; + } + + private boolean isMobileDataEnabled() { + try { + final Class cmClass = mConnectivityManager.getClass(); + final Method method = cmClass.getDeclaredMethod("getMobileDataEnabled"); + method.setAccessible(true); // Make the method callable + // get the setting for "mobile data" + return (Boolean) method.invoke(mConnectivityManager); + } catch (final Exception e) { + Log.w(MmsService.TAG, "TelephonyManager.getMobileDataEnabled failed", e); + } + return false; + } +} diff --git a/src/android/support/v7/mms/MmsRequest.java b/src/android/support/v7/mms/MmsRequest.java new file mode 100644 index 0000000..edf3606 --- /dev/null +++ b/src/android/support/v7/mms/MmsRequest.java @@ -0,0 +1,391 @@ +/* + * 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 android.support.v7.mms; + +import android.app.Activity; +import android.app.PendingIntent; +import android.content.Context; +import android.content.Intent; +import android.net.ConnectivityManager; +import android.net.Uri; +import android.os.Bundle; +import android.os.Parcel; +import android.os.Parcelable; +import android.support.v7.mms.pdu.GenericPdu; +import android.support.v7.mms.pdu.PduHeaders; +import android.support.v7.mms.pdu.PduParser; +import android.support.v7.mms.pdu.SendConf; +import android.telephony.SmsManager; +import android.text.TextUtils; +import android.util.Log; + +import java.lang.reflect.Method; +import java.net.Inet4Address; +import java.net.InetAddress; +import java.net.UnknownHostException; +import java.util.List; +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; + +/** + * MMS request base class. This handles the execution of any MMS request. + */ +abstract class MmsRequest implements Parcelable { + /** + * Prepare to make the HTTP request - will download message for sending + * + * @param context the Context + * @param mmsConfig carrier config values to use + * @return true if loading request PDU from calling app succeeds, false otherwise + */ + protected abstract boolean loadRequest(Context context, Bundle mmsConfig); + + /** + * Transfer the received response to the caller + * + * @param context the Context + * @param fillIn the content of pending intent to be returned + * @param response the pdu to transfer + * @return true if transferring response PDU to calling app succeeds, false otherwise + */ + protected abstract boolean transferResponse(Context context, Intent fillIn, byte[] response); + + /** + * Making the HTTP request to MMSC + * + * @param context The context + * @param netMgr The current {@link MmsNetworkManager} + * @param apn The APN + * @param mmsConfig The carrier configuration values to use + * @param userAgent The User-Agent header value + * @param uaProfUrl The UA Prof URL header value + * @return The HTTP response data + * @throws MmsHttpException If any network error happens + */ + protected abstract byte[] doHttp(Context context, MmsNetworkManager netMgr, + ApnSettingsLoader.Apn apn, Bundle mmsConfig, String userAgent, String uaProfUrl) + throws MmsHttpException; + + /** + * Get the HTTP request URL for this MMS request + * + * @param apn The APN to use + * @return The HTTP request URL in text + */ + protected abstract String getHttpRequestUrl(ApnSettingsLoader.Apn apn); + + // Maximum time to spend waiting to read data from a content provider before failing with error. + protected static final int TASK_TIMEOUT_MS = 30 * 1000; + + protected final String mLocationUrl; + protected final Uri mPduUri; + protected final PendingIntent mPendingIntent; + // Thread pool for transferring PDU with MMS apps + protected final ExecutorService mPduTransferExecutor = Executors.newCachedThreadPool(); + + // Whether this request should acquire wake lock + private boolean mUseWakeLock; + + protected MmsRequest(final String locationUrl, final Uri pduUri, + final PendingIntent pendingIntent) { + mLocationUrl = locationUrl; + mPduUri = pduUri; + mPendingIntent = pendingIntent; + mUseWakeLock = true; + } + + void setUseWakeLock(final boolean useWakeLock) { + mUseWakeLock = useWakeLock; + } + + boolean getUseWakeLock() { + return mUseWakeLock; + } + + /** + * Run the MMS request. + * + * @param context the context to use + * @param networkManager the MmsNetworkManager to use to setup MMS network + * @param apnSettingsLoader the APN loader + * @param carrierConfigValuesLoader the carrier config loader + * @param userAgentInfoLoader the user agent info loader + */ + void execute(final Context context, final MmsNetworkManager networkManager, + final ApnSettingsLoader apnSettingsLoader, + final CarrierConfigValuesLoader carrierConfigValuesLoader, + final UserAgentInfoLoader userAgentInfoLoader) { + Log.i(MmsService.TAG, "Execute " + this.getClass().getSimpleName()); + int result = SmsManager.MMS_ERROR_UNSPECIFIED; + int httpStatusCode = 0; + byte[] response = null; + final Bundle mmsConfig = carrierConfigValuesLoader.get(MmsManager.DEFAULT_SUB_ID); + if (mmsConfig == null) { + Log.e(MmsService.TAG, "Failed to load carrier configuration values"); + result = SmsManager.MMS_ERROR_CONFIGURATION_ERROR; + } else if (!loadRequest(context, mmsConfig)) { + Log.e(MmsService.TAG, "Failed to load PDU"); + result = SmsManager.MMS_ERROR_IO_ERROR; + } else { + // Everything's OK. Now execute the request. + try { + // Acquire the MMS network + networkManager.acquireNetwork(); + // Load the potential APNs. In most cases there should be only one APN available. + // On some devices on which we can't obtain APN from system, we look up our own + // APN list. Since we don't have exact information, we may get a list of potential + // APNs to try. Whenever we found a successful APN, we signal it and return. + final String apnName = networkManager.getApnName(); + final List<ApnSettingsLoader.Apn> apns = apnSettingsLoader.get(apnName); + if (apns.size() < 1) { + throw new ApnException("No valid APN"); + } else { + Log.d(MmsService.TAG, "Trying " + apns.size() + " APNs"); + } + final String userAgent = userAgentInfoLoader.getUserAgent(); + final String uaProfUrl = userAgentInfoLoader.getUAProfUrl(); + MmsHttpException lastException = null; + for (ApnSettingsLoader.Apn apn : apns) { + Log.i(MmsService.TAG, "Using APN [" + + "MMSC=" + apn.getMmsc() + ", " + + "PROXY=" + apn.getMmsProxy() + ", " + + "PORT=" + apn.getMmsProxyPort() + "]"); + try { + final String url = getHttpRequestUrl(apn); + // Request a global route for the host to connect + requestRoute(networkManager.getConnectivityManager(), apn, url); + // Perform the HTTP request + response = doHttp( + context, networkManager, apn, mmsConfig, userAgent, uaProfUrl); + // Additional check of whether this is a success + if (isWrongApnResponse(response, mmsConfig)) { + throw new MmsHttpException(0/*statusCode*/, "Invalid sending address"); + } + // Notify APN loader this is a valid APN + apn.setSuccess(); + result = Activity.RESULT_OK; + break; + } catch (MmsHttpException e) { + Log.w(MmsService.TAG, "HTTP or network failure", e); + lastException = e; + } + } + if (lastException != null) { + throw lastException; + } + } catch (ApnException e) { + Log.e(MmsService.TAG, "MmsRequest: APN failure", e); + result = SmsManager.MMS_ERROR_INVALID_APN; + } catch (MmsNetworkException e) { + Log.e(MmsService.TAG, "MmsRequest: MMS network acquiring failure", e); + result = SmsManager.MMS_ERROR_UNABLE_CONNECT_MMS; + } catch (MmsHttpException e) { + Log.e(MmsService.TAG, "MmsRequest: HTTP or network I/O failure", e); + result = SmsManager.MMS_ERROR_HTTP_FAILURE; + httpStatusCode = e.getStatusCode(); + } catch (Exception e) { + Log.e(MmsService.TAG, "MmsRequest: unexpected failure", e); + result = SmsManager.MMS_ERROR_UNSPECIFIED; + } finally { + // Release MMS network + networkManager.releaseNetwork(); + } + } + // Process result and send back via PendingIntent + returnResult(context, result, response, httpStatusCode); + } + + /** + * Check if the response indicates a failure when we send to wrong APN. + * Sometimes even if you send to the wrong APN, a response in valid PDU format can still + * be sent back but with an error status. Check one specific case here. + * + * TODO: maybe there are other possibilities. + * + * @param response the response data + * @param mmsConfig the carrier configuration values to use + * @return false if we find an invalid response case, otherwise true + */ + static boolean isWrongApnResponse(final byte[] response, final Bundle mmsConfig) { + if (response != null && response.length > 0) { + try { + final GenericPdu pdu = new PduParser( + response, + mmsConfig.getBoolean( + CarrierConfigValuesLoader + .CONFIG_SUPPORT_MMS_CONTENT_DISPOSITION, + CarrierConfigValuesLoader + .CONFIG_SUPPORT_MMS_CONTENT_DISPOSITION_DEFAULT)) + .parse(); + if (pdu != null && pdu instanceof SendConf) { + final SendConf sendConf = (SendConf) pdu; + final int responseStatus = sendConf.getResponseStatus(); + return responseStatus == + PduHeaders.RESPONSE_STATUS_ERROR_PERMANENT_SENDING_ADDRESS_UNRESOLVED || + responseStatus == + PduHeaders.RESPONSE_STATUS_ERROR_SENDING_ADDRESS_UNRESOLVED; + } + } catch (RuntimeException e) { + Log.w(MmsService.TAG, "Parsing response failed", e); + } + } + return false; + } + + /** + * Return the result back via pending intent + * + * @param context The context + * @param result The result code of execution + * @param response The response body + * @param httpStatusCode The optional http status code in case of http failure + */ + void returnResult(final Context context, int result, final byte[] response, + final int httpStatusCode) { + if (mPendingIntent == null) { + // Result not needed + return; + } + // Extra information to send back with the pending intent + final Intent fillIn = new Intent(); + if (response != null) { + if (!transferResponse(context, fillIn, response)) { + // Failed to send PDU data back to caller + result = SmsManager.MMS_ERROR_IO_ERROR; + } + } + if (result == SmsManager.MMS_ERROR_HTTP_FAILURE && httpStatusCode != 0) { + // For HTTP failure, fill in the status code for more information + fillIn.putExtra(SmsManager.EXTRA_MMS_HTTP_STATUS, httpStatusCode); + } + try { + mPendingIntent.send(context, result, fillIn); + } catch (PendingIntent.CanceledException e) { + Log.e(MmsService.TAG, "Sending pending intent canceled", e); + } + } + + /** + * Request the route to the APN (either proxy host or the MMSC host) + * + * @param connectivityManager the ConnectivityManager to use + * @param apn the current APN + * @param url the URL to connect to + * @throws MmsHttpException for unknown host or route failure + */ + private static void requestRoute(final ConnectivityManager connectivityManager, + final ApnSettingsLoader.Apn apn, final String url) throws MmsHttpException { + String host = apn.getMmsProxy(); + if (TextUtils.isEmpty(host)) { + final Uri uri = Uri.parse(url); + host = uri.getHost(); + } + boolean success = false; + // Request route to all resolved host addresses + try { + for (final InetAddress addr : InetAddress.getAllByName(host)) { + final boolean requested = requestRouteToHostAddress(connectivityManager, addr); + if (requested) { + success = true; + Log.i(MmsService.TAG, "Requested route to " + addr); + } else { + Log.i(MmsService.TAG, "Could not requested route to " + addr); + } + } + if (!success) { + throw new MmsHttpException(0/*statusCode*/, "No route requested"); + } + } catch (UnknownHostException e) { + Log.w(MmsService.TAG, "Unknown host " + host); + throw new MmsHttpException(0/*statusCode*/, "Unknown host"); + } + } + + private static final Integer TYPE_MOBILE_MMS = + Integer.valueOf(ConnectivityManager.TYPE_MOBILE_MMS); + /** + * Wrapper for platform API requestRouteToHostAddress + * + * We first try the hidden but correct method on ConnectivityManager. If we can't, use + * the old but buggy one + * + * @param connMgr the ConnectivityManager instance + * @param inetAddr the InetAddress to request + * @return true if route is successfully setup, false otherwise + */ + private static boolean requestRouteToHostAddress(final ConnectivityManager connMgr, + final InetAddress inetAddr) { + // First try the good method using reflection + try { + final Method method = connMgr.getClass().getMethod("requestRouteToHostAddress", + Integer.TYPE, InetAddress.class); + if (method != null) { + return (Boolean) method.invoke(connMgr, TYPE_MOBILE_MMS, inetAddr); + } + } catch (Exception e) { + Log.w(MmsService.TAG, "ConnectivityManager.requestRouteToHostAddress failed " + e); + } + // If we fail, try the old but buggy one + if (inetAddr instanceof Inet4Address) { + try { + final Method method = connMgr.getClass().getMethod("requestRouteToHost", + Integer.TYPE, Integer.TYPE); + if (method != null) { + return (Boolean) method.invoke(connMgr, TYPE_MOBILE_MMS, + inetAddressToInt(inetAddr)); + } + } catch (Exception e) { + Log.w(MmsService.TAG, "ConnectivityManager.requestRouteToHost failed " + e); + } + } + return false; + } + + /** + * Convert a IPv4 address from an InetAddress to an integer + * + * @param inetAddr is an InetAddress corresponding to the IPv4 address + * @return the IP address as an integer in network byte order + */ + private static int inetAddressToInt(final InetAddress inetAddr) + throws IllegalArgumentException { + final byte [] addr = inetAddr.getAddress(); + return ((addr[3] & 0xff) << 24) | ((addr[2] & 0xff) << 16) | + ((addr[1] & 0xff) << 8) | (addr[0] & 0xff); + } + + @Override + public int describeContents() { + return 0; + } + + @Override + public void writeToParcel(Parcel parcel, int flags) { + parcel.writeByte((byte) (mUseWakeLock ? 1 : 0)); + parcel.writeString(mLocationUrl); + parcel.writeParcelable(mPduUri, 0); + parcel.writeParcelable(mPendingIntent, 0); + } + + protected MmsRequest(final Parcel in) { + final ClassLoader classLoader = MmsRequest.class.getClassLoader(); + mUseWakeLock = in.readByte() != 0; + mLocationUrl = in.readString(); + mPduUri = in.readParcelable(classLoader); + mPendingIntent = in.readParcelable(classLoader); + } +} diff --git a/src/android/support/v7/mms/MmsService.java b/src/android/support/v7/mms/MmsService.java new file mode 100644 index 0000000..650562f --- /dev/null +++ b/src/android/support/v7/mms/MmsService.java @@ -0,0 +1,465 @@ +/* + * 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 android.support.v7.mms; + +import android.app.Service; +import android.content.Context; +import android.content.Intent; +import android.os.Handler; +import android.os.IBinder; +import android.os.PowerManager; +import android.os.Process; +import android.telephony.SmsManager; +import android.util.Log; + +import java.util.concurrent.ExecutorService; +import java.util.concurrent.Executors; +import java.util.concurrent.RejectedExecutionException; + +/** + * Service to execute MMS requests using deprecated legacy APIs on older platform (prior to L) + */ +public class MmsService extends Service { + static final String TAG = "MmsLib"; + + //The default number of threads allowed to run MMS requests + private static final int DEFAULT_THREAD_POOL_SIZE = 4; + // Delay before stopping the service + private static final int SERVICE_STOP_DELAY_MILLIS = 2000; + + private static final String EXTRA_REQUEST = "request"; + private static final String EXTRA_MYPID = "mypid"; + + private static final String WAKELOCK_ID = "mmslib_wakelock"; + + /** + * Thread pool size for each request queue + */ + private static volatile int sThreadPoolSize = DEFAULT_THREAD_POOL_SIZE; + + /** + * Optional wake lock to use + */ + private static volatile boolean sUseWakeLock = true; + private static volatile PowerManager.WakeLock sWakeLock = null; + private static final Object sWakeLockLock = new Object(); + + /** + * Carrier configuration values loader + */ + private static volatile CarrierConfigValuesLoader sCarrierConfigValuesLoader = null; + + /** + * APN loader + */ + private static volatile ApnSettingsLoader sApnSettingsLoader = null; + + /** + * UserAgent and UA Prof URL loader + */ + private static volatile UserAgentInfoLoader sUserAgentInfoLoader = null; + + /** + * Set the size of thread pool for request execution. + * Default is DEFAULT_THREAD_POOL_SIZE + * + * @param size thread pool size + */ + static void setThreadPoolSize(final int size) { + sThreadPoolSize = size; + } + + /** + * Set whether to use wake lock + * + * @param useWakeLock true to use wake lock, false otherwise + */ + static void setUseWakeLock(final boolean useWakeLock) { + sUseWakeLock = useWakeLock; + } + + /** + * Set the optional carrier config values + * + * @param loader the carrier config values loader + */ + static void setCarrierConfigValuesLoader(final CarrierConfigValuesLoader loader) { + sCarrierConfigValuesLoader = loader; + } + + /** + * Get the current carrier config values loader + * + * @return the carrier config values loader currently set + */ + static CarrierConfigValuesLoader getCarrierConfigValuesLoader() { + return sCarrierConfigValuesLoader; + } + + /** + * Set APN settings loader + * + * @param loader the APN settings loader + */ + static void setApnSettingsLoader(final ApnSettingsLoader loader) { + sApnSettingsLoader = loader; + } + + /** + * Get the current APN settings loader + * + * @return the APN settings loader currently set + */ + static ApnSettingsLoader getApnSettingsLoader() { + return sApnSettingsLoader; + } + + /** + * Set user agent info loader + * + * @param loader the user agent info loader + */ + static void setUserAgentInfoLoader(final UserAgentInfoLoader loader) { + sUserAgentInfoLoader = loader; + } + + /** + * Get the current user agent info loader + * + * @return the user agent info loader currently set + */ + static UserAgentInfoLoader getUserAgentInfoLoader() { + return sUserAgentInfoLoader; + } + + /** + * Make sure loaders are not null. Set to default if that's the case + * + * @param context the Context to use + */ + private static void ensureLoaders(final Context context) { + if (sUserAgentInfoLoader == null) { + sUserAgentInfoLoader = new DefaultUserAgentInfoLoader(context); + } + if (sCarrierConfigValuesLoader == null) { + sCarrierConfigValuesLoader = new DefaultCarrierConfigValuesLoader(context); + } + if (sApnSettingsLoader == null) { + sApnSettingsLoader = new DefaultApnSettingsLoader(context); + } + } + + /** + * Acquire the wake lock + * + * @param context the context to use + */ + private static void acquireWakeLock(final Context context) { + synchronized (sWakeLockLock) { + if (sWakeLock == null) { + final PowerManager pm = + (PowerManager) context.getSystemService(Context.POWER_SERVICE); + sWakeLock = pm.newWakeLock(PowerManager.PARTIAL_WAKE_LOCK, WAKELOCK_ID); + } + sWakeLock.acquire(); + } + } + + /** + * Release the wake lock + */ + private static void releaseWakeLock() { + boolean releasedEmptyWakeLock = false; + synchronized (sWakeLockLock) { + if (sWakeLock != null) { + sWakeLock.release(); + } else { + releasedEmptyWakeLock = true; + } + } + if (releasedEmptyWakeLock) { + Log.w(TAG, "Releasing empty wake lock"); + } + } + + /** + * Check if wake lock is not held (e.g. when service stops) + */ + private static void verifyWakeLockNotHeld() { + boolean wakeLockHeld = false; + synchronized (sWakeLockLock) { + wakeLockHeld = sWakeLock != null && sWakeLock.isHeld(); + } + if (wakeLockHeld) { + Log.e(TAG, "Wake lock still held!"); + } + } + + // Remember my PID to discard restarted intent + private static volatile int sMyPid = -1; + + /** + * Get the current PID + * + * @return the current PID + */ + private static int getMyPid() { + if (sMyPid < 0) { + sMyPid = Process.myPid(); + } + return sMyPid; + } + + /** + * Check if the intent is coming from this process + * + * @param intent the incoming intent for the service + * @return true if the intent is from the current process + */ + private static boolean fromThisProcess(final Intent intent) { + final int pid = intent.getIntExtra(EXTRA_MYPID, -1); + return pid == getMyPid(); + } + + // Request execution thread pools. One thread pool for sending and one for downloading. + // The size of the thread pool controls the parallelism of request execution. + // See {@link setThreadPoolSize} + private ExecutorService[] mExecutors = new ExecutorService[2]; + + // Active request count + private int mActiveRequestCount; + // The latest intent startId, used for safely stopping service + private int mLastStartId; + + private MmsNetworkManager mNetworkManager; + + // Handler for scheduling service stop + private final Handler mHandler = new Handler(); + // Service stop task + private final Runnable mServiceStopRunnable = new Runnable() { + @Override + public void run() { + tryStopService(); + } + }; + + /** + * Start the service with a request + * + * @param context the Context to use + * @param request the request to start + */ + public static void startRequest(final Context context, final MmsRequest request) { + final boolean useWakeLock = sUseWakeLock; + request.setUseWakeLock(useWakeLock); + final Intent intent = new Intent(context, MmsService.class); + intent.putExtra(EXTRA_REQUEST, request); + intent.putExtra(EXTRA_MYPID, getMyPid()); + if (useWakeLock) { + acquireWakeLock(context); + } + if (context.startService(intent) == null) { + if (useWakeLock) { + releaseWakeLock(); + } + } + } + + @Override + public void onCreate() { + super.onCreate(); + + ensureLoaders(this); + + for (int i = 0; i < mExecutors.length; i++) { + mExecutors[i] = Executors.newFixedThreadPool(sThreadPoolSize); + } + + mNetworkManager = new MmsNetworkManager(this); + + synchronized (this) { + mActiveRequestCount = 0; + mLastStartId = -1; + } + } + + @Override + public void onDestroy() { + super.onDestroy(); + + for (ExecutorService executor : mExecutors) { + executor.shutdown(); + } + } + + @Override + public int onStartCommand(Intent intent, int flags, int startId) { + // Always remember the latest startId for use when we try releasing the service + synchronized (this) { + mLastStartId = startId; + } + boolean scheduled = false; + if (intent != null) { + // There is a rare situation that right after a intent is started, + // the service gets killed. Then the service will restart with + // the old intent which we don't want it to run since it will + // break our assumption for wake lock. Check the process ID + // embedded in the intent to make sure it is indeed from the + // the current life of this service. + if (fromThisProcess(intent)) { + final MmsRequest request = intent.getParcelableExtra(EXTRA_REQUEST); + if (request != null) { + try { + retainService(request, new Runnable() { + @Override + public void run() { + try { + request.execute( + MmsService.this, + mNetworkManager, + getApnSettingsLoader(), + getCarrierConfigValuesLoader(), + getUserAgentInfoLoader()); + } catch (Exception e) { + Log.w(TAG, "Unexpected execution failure", e); + } finally { + if (request.getUseWakeLock()) { + releaseWakeLock(); + } + releaseService(); + } + } + }); + scheduled = true; + } catch (RejectedExecutionException e) { + // Rare thing happened. Send back failure using the pending intent + // and also release the wake lock. + Log.w(TAG, "Executing request failed " + e); + request.returnResult(this, SmsManager.MMS_ERROR_UNSPECIFIED, + null/*response*/, 0/*httpStatusCode*/); + if (request.getUseWakeLock()) { + releaseWakeLock(); + } + } + } else { + Log.w(TAG, "Empty request"); + } + } else { + Log.w(TAG, "Got a restarted intent from previous incarnation"); + } + } else { + Log.w(TAG, "Empty intent"); + } + if (!scheduled) { + // If the request is not started successfully, we need to try shutdown the service + // if nobody is using it. + tryScheduleStop(); + } + return START_NOT_STICKY; + } + + /** + * Retain the service for executing the request in service thread pool + * + * @param request The request to execute + * @param runnable The runnable to run the request in thread pool + */ + private void retainService(final MmsRequest request, final Runnable runnable) { + final ExecutorService executor = getRequestExecutor(request); + synchronized (this) { + executor.execute(runnable); + mActiveRequestCount++; + } + } + + /** + * Release the service from the request. If nobody is using it, schedule service stop. + */ + private void releaseService() { + synchronized (this) { + mActiveRequestCount--; + if (mActiveRequestCount <= 0) { + mActiveRequestCount = 0; + rescheduleServiceStop(); + } + } + } + + /** + * Schedule the service stop if there is no active request + */ + private void tryScheduleStop() { + synchronized (this) { + if (mActiveRequestCount == 0) { + rescheduleServiceStop(); + } + } + } + + /** + * Reschedule service stop task + */ + private void rescheduleServiceStop() { + mHandler.removeCallbacks(mServiceStopRunnable); + mHandler.postDelayed(mServiceStopRunnable, SERVICE_STOP_DELAY_MILLIS); + } + + /** + * Really try to stop the service if there is not active request + */ + private void tryStopService() { + Boolean stopped = null; + synchronized (this) { + if (mActiveRequestCount == 0) { + stopped = stopSelfResult(mLastStartId); + } + } + logServiceStop(stopped); + } + + /** + * Log the result of service stopping. Also check wake lock status when service stops. + * + * @param stopped Not empty if service stop is performed: true if really stopped, false + * if cancelled. + */ + private void logServiceStop(final Boolean stopped) { + if (stopped != null) { + if (stopped) { + Log.i(TAG, "Service successfully stopped"); + verifyWakeLockNotHeld(); + } else { + Log.i(TAG, "Service stopping cancelled"); + } + } + } + + private ExecutorService getRequestExecutor(final MmsRequest request) { + if (request instanceof SendRequest) { + // Send + return mExecutors[0]; + } else { + // Download + return mExecutors[1]; + } + } + + @Override + public IBinder onBind(Intent intent) { + return null; + } +} diff --git a/src/android/support/v7/mms/MmsXmlResourceParser.java b/src/android/support/v7/mms/MmsXmlResourceParser.java new file mode 100644 index 0000000..1ee73e2 --- /dev/null +++ b/src/android/support/v7/mms/MmsXmlResourceParser.java @@ -0,0 +1,143 @@ +/* + * 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 android.support.v7.mms; + +import android.util.Log; + +import org.xmlpull.v1.XmlPullParser; +import org.xmlpull.v1.XmlPullParserException; + +import java.io.IOException; + +/** + * Base class for a parser of XML resources + */ +abstract class MmsXmlResourceParser { + /** + * Parse the content + * + * @throws IOException + * @throws XmlPullParserException + */ + protected abstract void parseRecord() throws IOException, XmlPullParserException; + + /** + * Get the root tag of the content + * + * @return the text of root tag + */ + protected abstract String getRootTag(); + + private final StringBuilder mLogStringBuilder = new StringBuilder(); + + protected final XmlPullParser mInputParser; + + protected MmsXmlResourceParser(XmlPullParser parser) { + mInputParser = parser; + } + + void parse() { + try { + // Find the first element + if (advanceToNextEvent(XmlPullParser.START_TAG) != XmlPullParser.START_TAG) { + throw new XmlPullParserException("ApnsXmlProcessor: expecting start tag @" + + xmlParserDebugContext()); + } + if (!getRootTag().equals(mInputParser.getName())) { + Log.w(MmsService.TAG, "Carrier config does not start with " + getRootTag()); + return; + } + // We are at the start tag + for (;;) { + int nextEvent; + // Skipping spaces + while ((nextEvent = mInputParser.next()) == XmlPullParser.TEXT); + if (nextEvent == XmlPullParser.START_TAG) { + // Parse one record + parseRecord(); + } else if (nextEvent == XmlPullParser.END_TAG) { + break; + } else { + throw new XmlPullParserException("Expecting start or end tag @" + + xmlParserDebugContext()); + } + } + } catch (IOException e) { + Log.w(MmsService.TAG, "XmlResourceParser: I/O failure", e); + } catch (XmlPullParserException e) { + Log.w(MmsService.TAG, "XmlResourceParser: parsing failure", e); + } + } + + /** + * Move XML parser forward to next event type or the end of doc + * + * @param eventType + * @return The final event type we meet + * @throws XmlPullParserException + * @throws IOException + */ + protected int advanceToNextEvent(int eventType) throws XmlPullParserException, IOException { + for (;;) { + int nextEvent = mInputParser.next(); + if (nextEvent == eventType + || nextEvent == XmlPullParser.END_DOCUMENT) { + return nextEvent; + } + } + } + + /** + * @return The debugging information of the parser's current position + */ + protected String xmlParserDebugContext() { + mLogStringBuilder.setLength(0); + if (mInputParser != null) { + try { + final int eventType = mInputParser.getEventType(); + mLogStringBuilder.append(xmlParserEventString(eventType)); + if (eventType == XmlPullParser.START_TAG + || eventType == XmlPullParser.END_TAG + || eventType == XmlPullParser.TEXT) { + mLogStringBuilder.append('<').append(mInputParser.getName()); + for (int i = 0; i < mInputParser.getAttributeCount(); i++) { + mLogStringBuilder.append(' ') + .append(mInputParser.getAttributeName(i)) + .append('=') + .append(mInputParser.getAttributeValue(i)); + } + mLogStringBuilder.append("/>"); + } + return mLogStringBuilder.toString(); + } catch (XmlPullParserException e) { + Log.w(MmsService.TAG, "XmlResourceParser exception", e); + } + } + return "Unknown"; + } + + private static String xmlParserEventString(int event) { + switch (event) { + case XmlPullParser.START_DOCUMENT: return "START_DOCUMENT"; + case XmlPullParser.END_DOCUMENT: return "END_DOCUMENT"; + case XmlPullParser.START_TAG: return "START_TAG"; + case XmlPullParser.END_TAG: return "END_TAG"; + case XmlPullParser.TEXT: return "TEXT"; + } + return Integer.toString(event); + } +} diff --git a/src/android/support/v7/mms/PhoneNumberHelper.java b/src/android/support/v7/mms/PhoneNumberHelper.java new file mode 100644 index 0000000..99551c0 --- /dev/null +++ b/src/android/support/v7/mms/PhoneNumberHelper.java @@ -0,0 +1,54 @@ +/* + * 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 android.support.v7.mms; + +import android.text.TextUtils; +import android.util.Log; + +import com.google.i18n.phonenumbers.NumberParseException; +import com.google.i18n.phonenumbers.PhoneNumberUtil; +import com.google.i18n.phonenumbers.Phonenumber; + +/** + * Helper methods for phone number formatting + * This is isolated into a standalone class since it depends on libphonenumber + */ +public class PhoneNumberHelper { + /** + * Given a phone number, get its national part without country code + * + * @param number the original number + * @param country the country ISO code + * @return the national number + */ + static String getNumberNoCountryCode(final String number, final String country) { + if (!TextUtils.isEmpty(number)) { + final PhoneNumberUtil phoneNumberUtil = PhoneNumberUtil.getInstance(); + try { + final Phonenumber.PhoneNumber phoneNumber = phoneNumberUtil.parse(number, country); + if (phoneNumber != null && phoneNumberUtil.isValidNumber(phoneNumber)) { + return phoneNumberUtil + .format(phoneNumber, PhoneNumberUtil.PhoneNumberFormat.NATIONAL) + .replaceAll("\\D", ""); + } + } catch (final NumberParseException e) { + Log.w(MmsService.TAG, "getNumberNoCountryCode: invalid number " + e); + } + } + return number; + } +} diff --git a/src/android/support/v7/mms/SendRequest.java b/src/android/support/v7/mms/SendRequest.java new file mode 100644 index 0000000..1b7b1db --- /dev/null +++ b/src/android/support/v7/mms/SendRequest.java @@ -0,0 +1,163 @@ +/* + * 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 android.support.v7.mms; + +import android.app.PendingIntent; +import android.content.ContentResolver; +import android.content.Context; +import android.content.Intent; +import android.net.Uri; +import android.os.Bundle; +import android.os.Parcel; +import android.os.ParcelFileDescriptor; +import android.os.Parcelable; +import android.telephony.SmsManager; +import android.text.TextUtils; +import android.util.Log; + +import java.io.IOException; +import java.util.concurrent.Callable; +import java.util.concurrent.Future; +import java.util.concurrent.TimeUnit; + +/** + * Request to send an MMS + */ +class SendRequest extends MmsRequest { + // Max send response PDU size in bytes (exceeding this may cause problem with + // system intent delivery). + private static final int MAX_SEND_RESPONSE_SIZE = 1000 * 1024; + + private byte[] mPduData; + + SendRequest(final String locationUrl, final Uri pduUri, final PendingIntent sentIntent) { + super(locationUrl, pduUri, sentIntent); + } + + @Override + protected boolean loadRequest(final Context context, final Bundle mmsConfig) { + mPduData = readPduFromContentUri( + context, + mPduUri, + mmsConfig.getInt( + CarrierConfigValuesLoader.CONFIG_MAX_MESSAGE_SIZE, + CarrierConfigValuesLoader.CONFIG_MAX_MESSAGE_SIZE_DEFAULT)); + return (mPduData != null); + } + + @Override + protected boolean transferResponse(final Context context, final Intent fillIn, + final byte[] response) { + // SendConf pdus are always small and can be included in the intent + if (response != null && fillIn != null) { + if (response.length > MAX_SEND_RESPONSE_SIZE) { + // If the response PDU is too large, it won't be able to fit in + // the PendingIntent to be transferred via system IPC. + return false; + } + fillIn.putExtra(SmsManager.EXTRA_MMS_DATA, response); + } + return true; + } + + @Override + protected byte[] doHttp(Context context, MmsNetworkManager netMgr, ApnSettingsLoader.Apn apn, + Bundle mmsConfig, String userAgent, String uaProfUrl) throws MmsHttpException { + final MmsHttpClient httpClient = netMgr.getHttpClient(); + return httpClient.execute(getHttpRequestUrl(apn), mPduData, MmsHttpClient.METHOD_POST, + !TextUtils.isEmpty(apn.getMmsProxy()), apn.getMmsProxy(), apn.getMmsProxyPort(), + mmsConfig, userAgent, uaProfUrl); + } + + @Override + protected String getHttpRequestUrl(final ApnSettingsLoader.Apn apn) { + return !TextUtils.isEmpty(mLocationUrl) ? mLocationUrl : apn.getMmsc(); + } + + /** + * Read pdu from content provider uri + * + * @param contentUri content provider uri from which to read + * @param maxSize maximum number of bytes to read + * @return pdu bytes if succeeded else null + */ + public byte[] readPduFromContentUri(final Context context, final Uri contentUri, + final int maxSize) { + if (contentUri == null) { + return null; + } + final Callable<byte[]> copyPduToArray = new Callable<byte[]>() { + public byte[] call() { + ParcelFileDescriptor.AutoCloseInputStream inStream = null; + try { + final ContentResolver cr = context.getContentResolver(); + final ParcelFileDescriptor pduFd = cr.openFileDescriptor(contentUri, "r"); + inStream = new ParcelFileDescriptor.AutoCloseInputStream(pduFd); + // Request one extra byte to make sure file not bigger than maxSize + final byte[] readBuf = new byte[maxSize+1]; + final int bytesRead = inStream.read(readBuf, 0, maxSize+1); + if (bytesRead <= 0) { + Log.e(MmsService.TAG, "Reading PDU from sender: empty PDU"); + return null; + } + if (bytesRead > maxSize) { + Log.e(MmsService.TAG, "Reading PDU from sender: PDU too large"); + return null; + } + // Copy and return the exact length of bytes + final byte[] result = new byte[bytesRead]; + System.arraycopy(readBuf, 0, result, 0, bytesRead); + return result; + } catch (IOException e) { + Log.e(MmsService.TAG, "Reading PDU from sender: IO exception", e); + return null; + } finally { + if (inStream != null) { + try { + inStream.close(); + } catch (IOException ex) { + // Ignore + } + } + } + } + }; + final Future<byte[]> pendingResult = mPduTransferExecutor.submit(copyPduToArray); + try { + return pendingResult.get(TASK_TIMEOUT_MS, TimeUnit.MILLISECONDS); + } catch (Exception e) { + // Typically a timeout occurred - cancel task + pendingResult.cancel(true); + } + return null; + } + + public static final Parcelable.Creator<SendRequest> CREATOR + = new Parcelable.Creator<SendRequest>() { + public SendRequest createFromParcel(Parcel in) { + return new SendRequest(in); + } + + public SendRequest[] newArray(int size) { + return new SendRequest[size]; + } + }; + + private SendRequest(Parcel in) { + super(in); + } +} diff --git a/src/android/support/v7/mms/UserAgentInfoLoader.java b/src/android/support/v7/mms/UserAgentInfoLoader.java new file mode 100644 index 0000000..214d58d --- /dev/null +++ b/src/android/support/v7/mms/UserAgentInfoLoader.java @@ -0,0 +1,40 @@ +/* + * 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 android.support.v7.mms; + +/** + * Interface to load UserAgent and UA Prof URL + */ +public interface UserAgentInfoLoader { + // Carrier configuration keys for passing as config overrides into system MMS service + public static final String CONFIG_USER_AGENT = "userAgent"; + public static final String CONFIG_UA_PROF_URL = "uaProfUrl"; + + /** + * Get UserAgent value + * + * @return the text of UserAgent + */ + String getUserAgent(); + + /** + * Get UA Profile URL + * + * @return the URL of UA profile + */ + String getUAProfUrl(); +} diff --git a/src/android/support/v7/mms/Utils.java b/src/android/support/v7/mms/Utils.java new file mode 100644 index 0000000..cb55c2e --- /dev/null +++ b/src/android/support/v7/mms/Utils.java @@ -0,0 +1,180 @@ +/* + * 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 android.support.v7.mms; + +import android.content.Context; +import android.content.res.Configuration; +import android.os.Build; +import android.telephony.SmsManager; +import android.telephony.SubscriptionInfo; +import android.telephony.SubscriptionManager; +import android.telephony.TelephonyManager; +import android.text.TextUtils; +import android.util.Log; + +import java.net.MalformedURLException; +import java.net.URL; + +/** + * Utility methods + */ +class Utils { + /** + * Check if MMS API is available + * + * @return true if MMS API is available, false otherwise + */ + static boolean hasMmsApi() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP; + } + + /** + * Check if support multi-SIM + * + * @return true if MSIM is supported, false otherwise + */ + static boolean supportMSim() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.LOLLIPOP_MR1; + } + + /** + * Check if support APIs for getting UserAgent and UAProfUrl + * + * @return true if those APIs are supported, false otherwise + */ + static boolean hasUserAgentApi() { + return Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT; + } + + /** + * Get system SmsManager + * + * @param subId the subscription ID of the SmsManager + * @return the SmsManager for the input subId + */ + static SmsManager getSmsManager(final int subId) { + if (supportMSim()) { + return SmsManager.getSmsManagerForSubscriptionId(subId); + } else { + return SmsManager.getDefault(); + } + } + + /** + * Get the real subscription ID if the input is -1 + * + * @param subId input subscription ID + * @return the default SMS subscription ID if the input is -1, otherwise the original + */ + static int getEffectiveSubscriptionId(int subId) { + if (supportMSim()) { + if (subId == MmsManager.DEFAULT_SUB_ID) { + subId = SmsManager.getDefaultSmsSubscriptionId(); + } + } + if (subId < 0) { + subId = MmsManager.DEFAULT_SUB_ID; + } + return subId; + } + + /** + * Get MCC/MNC of an SIM subscription + * + * @param context the Context to use + * @param subId the SIM subId + * @return a non-empty array with exactly two elements, first is mcc and last is mnc. + */ + static int[] getMccMnc(final Context context, final int subId) { + final int[] mccMnc = new int[] { 0, 0 }; + if (Utils.supportMSim()) { + final SubscriptionManager subscriptionManager = SubscriptionManager.from(context); + final SubscriptionInfo subInfo = subscriptionManager.getActiveSubscriptionInfo(subId); + if (subInfo != null) { + mccMnc[0] = subInfo.getMcc(); + mccMnc[1] = subInfo.getMnc(); + } + } else { + final TelephonyManager telephonyManager = + (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE); + final String mccMncString = telephonyManager.getSimOperator(); + try { + mccMnc[0] = Integer.parseInt(mccMncString.substring(0, 3)); + mccMnc[1] = Integer.parseInt(mccMncString.substring(3)); + } catch (Exception e) { + Log.w(MmsService.TAG, "Invalid mcc/mnc from system " + mccMncString + ": " + e); + mccMnc[0] = 0; + mccMnc[1] = 0; + } + } + return mccMnc; + } + + /** + * Get a subscription's Context so we can load resources from it + * + * @param context the sub-independent Context + * @param subId the SIM's subId + * @return the sub-dependent Context + */ + static Context getSubDepContext(final Context context, final int subId) { + if (!supportMSim()) { + return context; + } + final int[] mccMnc = getMccMnc(context, subId); + final int mcc = mccMnc[0]; + final int mnc = mccMnc[1]; + if (mcc == 0 && mnc == 0) { + return context; + } + final Configuration subConfig = new Configuration(); + subConfig.mcc = mcc; + subConfig.mnc = mnc; + return context.createConfigurationContext(subConfig); + } + + /** + * Redact the URL for non-VERBOSE logging. Replace url with only the host part and the length + * of the input URL string. + * + * @param urlString + * @return + */ + static String redactUrlForNonVerbose(String urlString) { + if (Log.isLoggable(MmsService.TAG, Log.VERBOSE)) { + // Don't redact for VERBOSE level logging + return urlString; + } + if (TextUtils.isEmpty(urlString)) { + return urlString; + } + String protocol = "http"; + String host = ""; + try { + final URL url = new URL(urlString); + protocol = url.getProtocol(); + host = url.getHost(); + } catch (MalformedURLException e) { + // Ignore + } + // Print "http://host[length]" + final StringBuilder sb = new StringBuilder(); + sb.append(protocol).append("://").append(host) + .append("[").append(urlString.length()).append("]"); + return sb.toString(); + } +} diff --git a/src/android/support/v7/mms/pdu/AcknowledgeInd.java b/src/android/support/v7/mms/pdu/AcknowledgeInd.java new file mode 100644 index 0000000..10f9e35 --- /dev/null +++ b/src/android/support/v7/mms/pdu/AcknowledgeInd.java @@ -0,0 +1,87 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * M-Acknowledge.ind PDU. + */ +public class AcknowledgeInd extends GenericPdu { + /** + * Constructor, used when composing a M-Acknowledge.ind pdu. + * + * @param mmsVersion current viersion of mms + * @param transactionId the transaction-id value + * @throws InvalidHeaderValueException if parameters are invalid. + * NullPointerException if transactionId is null. + */ + public AcknowledgeInd(int mmsVersion, byte[] transactionId) + throws InvalidHeaderValueException { + super(); + + setMessageType(PduHeaders.MESSAGE_TYPE_ACKNOWLEDGE_IND); + setMmsVersion(mmsVersion); + setTransactionId(transactionId); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + AcknowledgeInd(PduHeaders headers) { + super(headers); + } + + /** + * Get X-Mms-Report-Allowed field value. + * + * @return the X-Mms-Report-Allowed value + */ + public int getReportAllowed() { + return mPduHeaders.getOctet(PduHeaders.REPORT_ALLOWED); + } + + /** + * Set X-Mms-Report-Allowed field value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setReportAllowed(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.REPORT_ALLOWED); + } + + /** + * Get X-Mms-Transaction-Id field value. + * + * @return the X-Mms-Report-Allowed value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id field value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } +} diff --git a/src/android/support/v7/mms/pdu/Base64.java b/src/android/support/v7/mms/pdu/Base64.java new file mode 100644 index 0000000..9f3418f --- /dev/null +++ b/src/android/support/v7/mms/pdu/Base64.java @@ -0,0 +1,167 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class Base64 { + /** + * Used to get the number of Quadruples. + */ + static final int FOURBYTE = 4; + + /** + * Byte used to pad output. + */ + static final byte PAD = (byte) '='; + + /** + * The base length. + */ + static final int BASELENGTH = 255; + + // Create arrays to hold the base64 characters + private static byte[] base64Alphabet = new byte[BASELENGTH]; + + // Populating the character arrays + static { + for (int i = 0; i < BASELENGTH; i++) { + base64Alphabet[i] = (byte) -1; + } + for (int i = 'Z'; i >= 'A'; i--) { + base64Alphabet[i] = (byte) (i - 'A'); + } + for (int i = 'z'; i >= 'a'; i--) { + base64Alphabet[i] = (byte) (i - 'a' + 26); + } + for (int i = '9'; i >= '0'; i--) { + base64Alphabet[i] = (byte) (i - '0' + 52); + } + + base64Alphabet['+'] = 62; + base64Alphabet['/'] = 63; + } + + /** + * Decodes Base64 data into octects + * + * @param base64Data Byte array containing Base64 data + * @return Array containing decoded data. + */ + public static byte[] decodeBase64(byte[] base64Data) { + // RFC 2045 requires that we discard ALL non-Base64 characters + base64Data = discardNonBase64(base64Data); + + // handle the edge case, so we don't have to worry about it later + if (base64Data.length == 0) { + return new byte[0]; + } + + int numberQuadruple = base64Data.length / FOURBYTE; + byte decodedData[] = null; + byte b1 = 0, b2 = 0, b3 = 0, b4 = 0, marker0 = 0, marker1 = 0; + + // Throw away anything not in base64Data + + int encodedIndex = 0; + int dataIndex = 0; + { + // this sizes the output array properly - rlw + int lastData = base64Data.length; + // ignore the '=' padding + while (base64Data[lastData - 1] == PAD) { + if (--lastData == 0) { + return new byte[0]; + } + } + decodedData = new byte[lastData - numberQuadruple]; + } + + for (int i = 0; i < numberQuadruple; i++) { + dataIndex = i * 4; + marker0 = base64Data[dataIndex + 2]; + marker1 = base64Data[dataIndex + 3]; + + b1 = base64Alphabet[base64Data[dataIndex]]; + b2 = base64Alphabet[base64Data[dataIndex + 1]]; + + if (marker0 != PAD && marker1 != PAD) { + //No PAD e.g 3cQl + b3 = base64Alphabet[marker0]; + b4 = base64Alphabet[marker1]; + + decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); + decodedData[encodedIndex + 1] = + (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); + decodedData[encodedIndex + 2] = (byte) (b3 << 6 | b4); + } else if (marker0 == PAD) { + //Two PAD e.g. 3c[Pad][Pad] + decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); + } else if (marker1 == PAD) { + //One PAD e.g. 3cQ[Pad] + b3 = base64Alphabet[marker0]; + + decodedData[encodedIndex] = (byte) (b1 << 2 | b2 >> 4); + decodedData[encodedIndex + 1] = + (byte) (((b2 & 0xf) << 4) | ((b3 >> 2) & 0xf)); + } + encodedIndex += 3; + } + return decodedData; + } + + /** + * Check octect wheter it is a base64 encoding. + * + * @param octect to be checked byte + * @return ture if it is base64 encoding, false otherwise. + */ + private static boolean isBase64(byte octect) { + if (octect == PAD) { + return true; + } else if (base64Alphabet[octect] == -1) { + return false; + } else { + return true; + } + } + + /** + * Discards any characters outside of the base64 alphabet, per + * the requirements on page 25 of RFC 2045 - "Any characters + * outside of the base64 alphabet are to be ignored in base64 + * encoded data." + * + * @param data The base-64 encoded data to groom + * @return The data, less non-base64 characters (see RFC 2045). + */ + static byte[] discardNonBase64(byte[] data) { + byte groomedData[] = new byte[data.length]; + int bytesCopied = 0; + + for (int i = 0; i < data.length; i++) { + if (isBase64(data[i])) { + groomedData[bytesCopied++] = data[i]; + } + } + + byte packedData[] = new byte[bytesCopied]; + + System.arraycopy(groomedData, 0, packedData, 0, bytesCopied); + + return packedData; + } +} diff --git a/src/android/support/v7/mms/pdu/CharacterSets.java b/src/android/support/v7/mms/pdu/CharacterSets.java new file mode 100644 index 0000000..8ce2a02 --- /dev/null +++ b/src/android/support/v7/mms/pdu/CharacterSets.java @@ -0,0 +1,172 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +import java.io.UnsupportedEncodingException; +import java.util.HashMap; + +public class CharacterSets { + /** + * IANA assigned MIB enum numbers. + * + * From wap-230-wsp-20010705-a.pdf + * Any-charset = <Octet 128> + * Equivalent to the special RFC2616 charset value "*" + */ + public static final int ANY_CHARSET = 0x00; + public static final int US_ASCII = 0x03; + public static final int ISO_8859_1 = 0x04; + public static final int ISO_8859_2 = 0x05; + public static final int ISO_8859_3 = 0x06; + public static final int ISO_8859_4 = 0x07; + public static final int ISO_8859_5 = 0x08; + public static final int ISO_8859_6 = 0x09; + public static final int ISO_8859_7 = 0x0A; + public static final int ISO_8859_8 = 0x0B; + public static final int ISO_8859_9 = 0x0C; + public static final int SHIFT_JIS = 0x11; + public static final int UTF_8 = 0x6A; + public static final int BIG5 = 0x07EA; + public static final int UCS2 = 0x03E8; + public static final int UTF_16 = 0x03F7; + + /** + * If the encoding of given data is unsupported, use UTF_8 to decode it. + */ + public static final int DEFAULT_CHARSET = UTF_8; + + /** + * Array of MIB enum numbers. + */ + private static final int[] MIBENUM_NUMBERS = { + ANY_CHARSET, + US_ASCII, + ISO_8859_1, + ISO_8859_2, + ISO_8859_3, + ISO_8859_4, + ISO_8859_5, + ISO_8859_6, + ISO_8859_7, + ISO_8859_8, + ISO_8859_9, + SHIFT_JIS, + UTF_8, + BIG5, + UCS2, + UTF_16, + }; + + /** + * The Well-known-charset Mime name. + */ + public static final String MIMENAME_ANY_CHARSET = "*"; + public static final String MIMENAME_US_ASCII = "us-ascii"; + public static final String MIMENAME_ISO_8859_1 = "iso-8859-1"; + public static final String MIMENAME_ISO_8859_2 = "iso-8859-2"; + public static final String MIMENAME_ISO_8859_3 = "iso-8859-3"; + public static final String MIMENAME_ISO_8859_4 = "iso-8859-4"; + public static final String MIMENAME_ISO_8859_5 = "iso-8859-5"; + public static final String MIMENAME_ISO_8859_6 = "iso-8859-6"; + public static final String MIMENAME_ISO_8859_7 = "iso-8859-7"; + public static final String MIMENAME_ISO_8859_8 = "iso-8859-8"; + public static final String MIMENAME_ISO_8859_9 = "iso-8859-9"; + public static final String MIMENAME_SHIFT_JIS = "shift_JIS"; + public static final String MIMENAME_UTF_8 = "utf-8"; + public static final String MIMENAME_BIG5 = "big5"; + public static final String MIMENAME_UCS2 = "iso-10646-ucs-2"; + public static final String MIMENAME_UTF_16 = "utf-16"; + + public static final String DEFAULT_CHARSET_NAME = MIMENAME_UTF_8; + + /** + * Array of the names of character sets. + */ + private static final String[] MIME_NAMES = { + MIMENAME_ANY_CHARSET, + MIMENAME_US_ASCII, + MIMENAME_ISO_8859_1, + MIMENAME_ISO_8859_2, + MIMENAME_ISO_8859_3, + MIMENAME_ISO_8859_4, + MIMENAME_ISO_8859_5, + MIMENAME_ISO_8859_6, + MIMENAME_ISO_8859_7, + MIMENAME_ISO_8859_8, + MIMENAME_ISO_8859_9, + MIMENAME_SHIFT_JIS, + MIMENAME_UTF_8, + MIMENAME_BIG5, + MIMENAME_UCS2, + MIMENAME_UTF_16, + }; + + private static final HashMap<Integer, String> MIBENUM_TO_NAME_MAP; + private static final HashMap<String, Integer> NAME_TO_MIBENUM_MAP; + + static { + // Create the HashMaps. + MIBENUM_TO_NAME_MAP = new HashMap<Integer, String>(); + NAME_TO_MIBENUM_MAP = new HashMap<String, Integer>(); + assert(MIBENUM_NUMBERS.length == MIME_NAMES.length); + int count = MIBENUM_NUMBERS.length - 1; + for(int i = 0; i <= count; i++) { + MIBENUM_TO_NAME_MAP.put(MIBENUM_NUMBERS[i], MIME_NAMES[i]); + NAME_TO_MIBENUM_MAP.put(MIME_NAMES[i], MIBENUM_NUMBERS[i]); + } + } + + private CharacterSets() {} // Non-instantiatable + + /** + * Map an MIBEnum number to the name of the charset which this number + * is assigned to by IANA. + * + * @param mibEnumValue An IANA assigned MIBEnum number. + * @return The name string of the charset. + * @throws UnsupportedEncodingException + */ + public static String getMimeName(int mibEnumValue) + throws UnsupportedEncodingException { + String name = MIBENUM_TO_NAME_MAP.get(mibEnumValue); + if (name == null) { + throw new UnsupportedEncodingException(); + } + return name; + } + + /** + * Map a well-known charset name to its assigned MIBEnum number. + * + * @param mimeName The charset name. + * @return The MIBEnum number assigned by IANA for this charset. + * @throws UnsupportedEncodingException + */ + public static int getMibEnumValue(String mimeName) + throws UnsupportedEncodingException { + if(null == mimeName) { + return -1; + } + + Integer mibEnumValue = NAME_TO_MIBENUM_MAP.get(mimeName); + if (mibEnumValue == null) { + throw new UnsupportedEncodingException(); + } + return mibEnumValue; + } +} diff --git a/src/android/support/v7/mms/pdu/ContentType.java b/src/android/support/v7/mms/pdu/ContentType.java new file mode 100644 index 0000000..7ba961d --- /dev/null +++ b/src/android/support/v7/mms/pdu/ContentType.java @@ -0,0 +1,230 @@ +/* + * Copyright (C) 2007-2008 Esmertec AG. + * Copyright (C) 2007-2008 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 android.support.v7.mms.pdu; + +import java.util.ArrayList; + +public class ContentType { + public static final String MMS_MESSAGE = "application/vnd.wap.mms-message"; + // The phony content type for generic PDUs (e.g. ReadOrig.ind, + // Notification.ind, Delivery.ind). + public static final String MMS_GENERIC = "application/vnd.wap.mms-generic"; + public static final String MULTIPART_MIXED = "application/vnd.wap.multipart.mixed"; + public static final String MULTIPART_RELATED = "application/vnd.wap.multipart.related"; + public static final String MULTIPART_ALTERNATIVE = "application/vnd.wap.multipart.alternative"; + + public static final String TEXT_PLAIN = "text/plain"; + public static final String TEXT_HTML = "text/html"; + public static final String TEXT_VCALENDAR = "text/x-vCalendar"; + public static final String TEXT_VCARD = "text/x-vCard"; + + public static final String IMAGE_UNSPECIFIED = "image/*"; + public static final String IMAGE_JPEG = "image/jpeg"; + public static final String IMAGE_JPG = "image/jpg"; + public static final String IMAGE_GIF = "image/gif"; + public static final String IMAGE_WBMP = "image/vnd.wap.wbmp"; + public static final String IMAGE_PNG = "image/png"; + public static final String IMAGE_X_MS_BMP = "image/x-ms-bmp"; + + public static final String AUDIO_UNSPECIFIED = "audio/*"; + public static final String AUDIO_AAC = "audio/aac"; + public static final String AUDIO_AMR = "audio/amr"; + public static final String AUDIO_IMELODY = "audio/imelody"; + public static final String AUDIO_MID = "audio/mid"; + public static final String AUDIO_MIDI = "audio/midi"; + public static final String AUDIO_MP3 = "audio/mp3"; + public static final String AUDIO_MPEG3 = "audio/mpeg3"; + public static final String AUDIO_MPEG = "audio/mpeg"; + public static final String AUDIO_MPG = "audio/mpg"; + public static final String AUDIO_MP4 = "audio/mp4"; + public static final String AUDIO_X_MID = "audio/x-mid"; + public static final String AUDIO_X_MIDI = "audio/x-midi"; + public static final String AUDIO_X_MP3 = "audio/x-mp3"; + public static final String AUDIO_X_MPEG3 = "audio/x-mpeg3"; + public static final String AUDIO_X_MPEG = "audio/x-mpeg"; + public static final String AUDIO_X_MPG = "audio/x-mpg"; + public static final String AUDIO_3GPP = "audio/3gpp"; + public static final String AUDIO_X_WAV = "audio/x-wav"; + public static final String AUDIO_OGG = "application/ogg"; + + public static final String VIDEO_UNSPECIFIED = "video/*"; + public static final String VIDEO_3GPP = "video/3gpp"; + public static final String VIDEO_3G2 = "video/3gpp2"; + public static final String VIDEO_H263 = "video/h263"; + public static final String VIDEO_MP4 = "video/mp4"; + + public static final String APP_SMIL = "application/smil"; + public static final String APP_WAP_XHTML = "application/vnd.wap.xhtml+xml"; + public static final String APP_XHTML = "application/xhtml+xml"; + + public static final String APP_DRM_CONTENT = "application/vnd.oma.drm.content"; + public static final String APP_DRM_MESSAGE = "application/vnd.oma.drm.message"; + + private static final ArrayList<String> sSupportedContentTypes = new ArrayList<String>(); + private static final ArrayList<String> sSupportedImageTypes = new ArrayList<String>(); + private static final ArrayList<String> sSupportedAudioTypes = new ArrayList<String>(); + private static final ArrayList<String> sSupportedVideoTypes = new ArrayList<String>(); + + static { + sSupportedContentTypes.add(TEXT_PLAIN); + sSupportedContentTypes.add(TEXT_HTML); + sSupportedContentTypes.add(TEXT_VCALENDAR); + sSupportedContentTypes.add(TEXT_VCARD); + + sSupportedContentTypes.add(IMAGE_JPEG); + sSupportedContentTypes.add(IMAGE_GIF); + sSupportedContentTypes.add(IMAGE_WBMP); + sSupportedContentTypes.add(IMAGE_PNG); + sSupportedContentTypes.add(IMAGE_JPG); + sSupportedContentTypes.add(IMAGE_X_MS_BMP); + //supportedContentTypes.add(IMAGE_SVG); not yet supported. + + sSupportedContentTypes.add(AUDIO_AAC); + sSupportedContentTypes.add(AUDIO_AMR); + sSupportedContentTypes.add(AUDIO_IMELODY); + sSupportedContentTypes.add(AUDIO_MID); + sSupportedContentTypes.add(AUDIO_MIDI); + sSupportedContentTypes.add(AUDIO_MP3); + sSupportedContentTypes.add(AUDIO_MP4); + sSupportedContentTypes.add(AUDIO_MPEG3); + sSupportedContentTypes.add(AUDIO_MPEG); + sSupportedContentTypes.add(AUDIO_MPG); + sSupportedContentTypes.add(AUDIO_X_MID); + sSupportedContentTypes.add(AUDIO_X_MIDI); + sSupportedContentTypes.add(AUDIO_X_MP3); + sSupportedContentTypes.add(AUDIO_X_MPEG3); + sSupportedContentTypes.add(AUDIO_X_MPEG); + sSupportedContentTypes.add(AUDIO_X_MPG); + sSupportedContentTypes.add(AUDIO_X_WAV); + sSupportedContentTypes.add(AUDIO_3GPP); + sSupportedContentTypes.add(AUDIO_OGG); + + sSupportedContentTypes.add(VIDEO_3GPP); + sSupportedContentTypes.add(VIDEO_3G2); + sSupportedContentTypes.add(VIDEO_H263); + sSupportedContentTypes.add(VIDEO_MP4); + + sSupportedContentTypes.add(APP_SMIL); + sSupportedContentTypes.add(APP_WAP_XHTML); + sSupportedContentTypes.add(APP_XHTML); + + sSupportedContentTypes.add(APP_DRM_CONTENT); + sSupportedContentTypes.add(APP_DRM_MESSAGE); + + // add supported image types + sSupportedImageTypes.add(IMAGE_JPEG); + sSupportedImageTypes.add(IMAGE_GIF); + sSupportedImageTypes.add(IMAGE_WBMP); + sSupportedImageTypes.add(IMAGE_PNG); + sSupportedImageTypes.add(IMAGE_JPG); + sSupportedImageTypes.add(IMAGE_X_MS_BMP); + + // add supported audio types + sSupportedAudioTypes.add(AUDIO_AAC); + sSupportedAudioTypes.add(AUDIO_AMR); + sSupportedAudioTypes.add(AUDIO_IMELODY); + sSupportedAudioTypes.add(AUDIO_MID); + sSupportedAudioTypes.add(AUDIO_MIDI); + sSupportedAudioTypes.add(AUDIO_MP3); + sSupportedAudioTypes.add(AUDIO_MPEG3); + sSupportedAudioTypes.add(AUDIO_MPEG); + sSupportedAudioTypes.add(AUDIO_MPG); + sSupportedAudioTypes.add(AUDIO_MP4); + sSupportedAudioTypes.add(AUDIO_X_MID); + sSupportedAudioTypes.add(AUDIO_X_MIDI); + sSupportedAudioTypes.add(AUDIO_X_MP3); + sSupportedAudioTypes.add(AUDIO_X_MPEG3); + sSupportedAudioTypes.add(AUDIO_X_MPEG); + sSupportedAudioTypes.add(AUDIO_X_MPG); + sSupportedAudioTypes.add(AUDIO_X_WAV); + sSupportedAudioTypes.add(AUDIO_3GPP); + sSupportedAudioTypes.add(AUDIO_OGG); + + // add supported video types + sSupportedVideoTypes.add(VIDEO_3GPP); + sSupportedVideoTypes.add(VIDEO_3G2); + sSupportedVideoTypes.add(VIDEO_H263); + sSupportedVideoTypes.add(VIDEO_MP4); + } + + // This class should never be instantiated. + private ContentType() { + } + + public static boolean isSupportedType(String contentType) { + return (null != contentType) && sSupportedContentTypes.contains(contentType); + } + + public static boolean isSupportedImageType(String contentType) { + return isImageType(contentType) && isSupportedType(contentType); + } + + public static boolean isSupportedAudioType(String contentType) { + return isAudioType(contentType) && isSupportedType(contentType); + } + + public static boolean isSupportedVideoType(String contentType) { + return isVideoType(contentType) && isSupportedType(contentType); + } + + public static boolean isTextType(String contentType) { + return (null != contentType) && contentType.startsWith("text/"); + } + + public static boolean isImageType(String contentType) { + return (null != contentType) && contentType.startsWith("image/"); + } + + public static boolean isAudioType(String contentType) { + return (null != contentType) && contentType.startsWith("audio/"); + } + + public static boolean isVideoType(String contentType) { + return (null != contentType) && contentType.startsWith("video/"); + } + + public static boolean isDrmType(String contentType) { + return (null != contentType) + && (contentType.equals(APP_DRM_CONTENT) + || contentType.equals(APP_DRM_MESSAGE)); + } + + public static boolean isUnspecified(String contentType) { + return (null != contentType) && contentType.endsWith("*"); + } + + @SuppressWarnings("unchecked") + public static ArrayList<String> getImageTypes() { + return (ArrayList<String>) sSupportedImageTypes.clone(); + } + + @SuppressWarnings("unchecked") + public static ArrayList<String> getAudioTypes() { + return (ArrayList<String>) sSupportedAudioTypes.clone(); + } + + @SuppressWarnings("unchecked") + public static ArrayList<String> getVideoTypes() { + return (ArrayList<String>) sSupportedVideoTypes.clone(); + } + + @SuppressWarnings("unchecked") + public static ArrayList<String> getSupportedTypes() { + return (ArrayList<String>) sSupportedContentTypes.clone(); + } +} diff --git a/src/android/support/v7/mms/pdu/DeliveryInd.java b/src/android/support/v7/mms/pdu/DeliveryInd.java new file mode 100644 index 0000000..d7d72d9 --- /dev/null +++ b/src/android/support/v7/mms/pdu/DeliveryInd.java @@ -0,0 +1,136 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * M-Delivery.Ind Pdu. + */ +public class DeliveryInd extends GenericPdu { + /** + * Empty constructor. + * Since the Pdu corresponding to this class is constructed + * by the Proxy-Relay server, this class is only instantiated + * by the Pdu Parser. + * + * @throws InvalidHeaderValueException if error occurs. + */ + public DeliveryInd() throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_DELIVERY_IND); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + DeliveryInd(PduHeaders headers) { + super(headers); + } + + /** + * Get Date value. + * + * @return the value + */ + public long getDate() { + return mPduHeaders.getLongInteger(PduHeaders.DATE); + } + + /** + * Set Date value. + * + * @param value the value + */ + public void setDate(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.DATE); + } + + /** + * Get Message-ID value. + * + * @return the value + */ + public byte[] getMessageId() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_ID); + } + + /** + * Set Message-ID value. + * + * @param value the value, should not be null + * @throws NullPointerException if the value is null. + */ + public void setMessageId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_ID); + } + + /** + * Get Status value. + * + * @return the value + */ + public int getStatus() { + return mPduHeaders.getOctet(PduHeaders.STATUS); + } + + /** + * Set Status value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.STATUS); + } + + /** + * Get To value. + * + * @return the value + */ + public EncodedStringValue[] getTo() { + return mPduHeaders.getEncodedStringValues(PduHeaders.TO); + } + + /** + * set To value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTo(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.TO); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + * + * public EncodedStringValue getStatusText() {return null;} + * public void setStatusText(EncodedStringValue value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/EncodedStringValue.java b/src/android/support/v7/mms/pdu/EncodedStringValue.java new file mode 100644 index 0000000..d8fcacf --- /dev/null +++ b/src/android/support/v7/mms/pdu/EncodedStringValue.java @@ -0,0 +1,283 @@ +/* + * Copyright (C) 2007-2008 Esmertec AG. + * Copyright (C) 2007-2008 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 android.support.v7.mms.pdu; + +import android.util.Log; + +import java.io.ByteArrayOutputStream; +import java.io.IOException; +import java.io.UnsupportedEncodingException; +import java.util.ArrayList; + +/** + * Encoded-string-value = Text-string | Value-length Char-set Text-string + */ +public class EncodedStringValue implements Cloneable { + private static final String TAG = "EncodedStringValue"; + private static final boolean DEBUG = false; + private static final boolean LOCAL_LOGV = false; + + /** + * The Char-set value. + */ + private int mCharacterSet; + + /** + * The Text-string value. + */ + private byte[] mData; + + /** + * Constructor. + * + * @param charset the Char-set value + * @param data the Text-string value + * @throws NullPointerException if Text-string value is null. + */ + public EncodedStringValue(int charset, byte[] data) { + // TODO: CharSet needs to be validated against MIBEnum. + if(null == data) { + throw new NullPointerException("EncodedStringValue: Text-string is null."); + } + + mCharacterSet = charset; + mData = new byte[data.length]; + System.arraycopy(data, 0, mData, 0, data.length); + } + + /** + * Constructor. + * + * @param data the Text-string value + * @throws NullPointerException if Text-string value is null. + */ + public EncodedStringValue(byte[] data) { + this(CharacterSets.DEFAULT_CHARSET, data); + } + + public EncodedStringValue(String data) { + try { + mData = data.getBytes(CharacterSets.DEFAULT_CHARSET_NAME); + mCharacterSet = CharacterSets.DEFAULT_CHARSET; + } catch (UnsupportedEncodingException e) { + Log.e(TAG, "Default encoding must be supported.", e); + } + } + + /** + * Get Char-set value. + * + * @return the value + */ + public int getCharacterSet() { + return mCharacterSet; + } + + /** + * Set Char-set value. + * + * @param charset the Char-set value + */ + public void setCharacterSet(int charset) { + // TODO: CharSet needs to be validated against MIBEnum. + mCharacterSet = charset; + } + + /** + * Get Text-string value. + * + * @return the value + */ + public byte[] getTextString() { + byte[] byteArray = new byte[mData.length]; + + System.arraycopy(mData, 0, byteArray, 0, mData.length); + return byteArray; + } + + /** + * Set Text-string value. + * + * @param textString the Text-string value + * @throws NullPointerException if Text-string value is null. + */ + public void setTextString(byte[] textString) { + if(null == textString) { + throw new NullPointerException("EncodedStringValue: Text-string is null."); + } + + mData = new byte[textString.length]; + System.arraycopy(textString, 0, mData, 0, textString.length); + } + + /** + * Convert this object to a {@link java.lang.String}. If the encoding of + * the EncodedStringValue is null or unsupported, it will be + * treated as iso-8859-1 encoding. + * + * @return The decoded String. + */ + public String getString() { + if (CharacterSets.ANY_CHARSET == mCharacterSet) { + return new String(mData); // system default encoding. + } else { + try { + String name = CharacterSets.getMimeName(mCharacterSet); + return new String(mData, name); + } catch (UnsupportedEncodingException e) { + if (LOCAL_LOGV) { + Log.v(TAG, e.getMessage(), e); + } + try { + return new String(mData, CharacterSets.MIMENAME_ISO_8859_1); + } catch (UnsupportedEncodingException _) { + return new String(mData); // system default encoding. + } + } + } + } + + /** + * Append to Text-string. + * + * @param textString the textString to append + * @throws NullPointerException if the text String is null + * or an IOException occured. + */ + public void appendTextString(byte[] textString) { + if(null == textString) { + throw new NullPointerException("Text-string is null."); + } + + if(null == mData) { + mData = new byte[textString.length]; + System.arraycopy(textString, 0, mData, 0, textString.length); + } else { + ByteArrayOutputStream newTextString = new ByteArrayOutputStream(); + try { + newTextString.write(mData); + newTextString.write(textString); + } catch (IOException e) { + e.printStackTrace(); + throw new NullPointerException( + "appendTextString: failed when write a new Text-string"); + } + + mData = newTextString.toByteArray(); + } + } + + /* + * (non-Javadoc) + * @see java.lang.Object#clone() + */ + @Override + public Object clone() throws CloneNotSupportedException { + super.clone(); + int len = mData.length; + byte[] dstBytes = new byte[len]; + System.arraycopy(mData, 0, dstBytes, 0, len); + + try { + return new EncodedStringValue(mCharacterSet, dstBytes); + } catch (Exception e) { + Log.e(TAG, "failed to clone an EncodedStringValue: " + this); + e.printStackTrace(); + throw new CloneNotSupportedException(e.getMessage()); + } + } + + /** + * Split this encoded string around matches of the given pattern. + * + * @param pattern the delimiting pattern + * @return the array of encoded strings computed by splitting this encoded + * string around matches of the given pattern + */ + public EncodedStringValue[] split(String pattern) { + String[] temp = getString().split(pattern); + EncodedStringValue[] ret = new EncodedStringValue[temp.length]; + for (int i = 0; i < ret.length; ++i) { + try { + ret[i] = new EncodedStringValue(mCharacterSet, + temp[i].getBytes()); + } catch (NullPointerException _) { + // Can't arrive here + return null; + } + } + return ret; + } + + /** + * Extract an EncodedStringValue[] from a given String. + */ + public static EncodedStringValue[] extract(String src) { + String[] values = src.split(";"); + + ArrayList<EncodedStringValue> list = new ArrayList<EncodedStringValue>(); + for (int i = 0; i < values.length; i++) { + if (values[i].length() > 0) { + list.add(new EncodedStringValue(values[i])); + } + } + + int len = list.size(); + if (len > 0) { + return list.toArray(new EncodedStringValue[len]); + } else { + return null; + } + } + + /** + * Concatenate an EncodedStringValue[] into a single String. + */ + public static String concat(EncodedStringValue[] addr) { + StringBuilder sb = new StringBuilder(); + int maxIndex = addr.length - 1; + for (int i = 0; i <= maxIndex; i++) { + sb.append(addr[i].getString()); + if (i < maxIndex) { + sb.append(";"); + } + } + + return sb.toString(); + } + + public static EncodedStringValue copy(EncodedStringValue value) { + if (value == null) { + return null; + } + + return new EncodedStringValue(value.mCharacterSet, value.mData); + } + + public static EncodedStringValue[] encodeStrings(String[] array) { + int count = array.length; + if (count > 0) { + EncodedStringValue[] encodedArray = new EncodedStringValue[count]; + for (int i = 0; i < count; i++) { + encodedArray[i] = new EncodedStringValue(array[i]); + } + return encodedArray; + } + return null; + } +} diff --git a/src/android/support/v7/mms/pdu/GenericPdu.java b/src/android/support/v7/mms/pdu/GenericPdu.java new file mode 100644 index 0000000..2f0d167 --- /dev/null +++ b/src/android/support/v7/mms/pdu/GenericPdu.java @@ -0,0 +1,111 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class GenericPdu { + /** + * The headers of pdu. + */ + PduHeaders mPduHeaders = null; + + /** + * Constructor. + */ + public GenericPdu() { + mPduHeaders = new PduHeaders(); + } + + /** + * Constructor. + * + * @param headers Headers for this PDU. + */ + GenericPdu(PduHeaders headers) { + mPduHeaders = headers; + } + + /** + * Get the headers of this PDU. + * + * @return A PduHeaders of this PDU. + */ + PduHeaders getPduHeaders() { + return mPduHeaders; + } + + /** + * Get X-Mms-Message-Type field value. + * + * @return the X-Mms-Report-Allowed value + */ + public int getMessageType() { + return mPduHeaders.getOctet(PduHeaders.MESSAGE_TYPE); + } + + /** + * Set X-Mms-Message-Type field value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if field's value is not Octet. + */ + public void setMessageType(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.MESSAGE_TYPE); + } + + /** + * Get X-Mms-MMS-Version field value. + * + * @return the X-Mms-MMS-Version value + */ + public int getMmsVersion() { + return mPduHeaders.getOctet(PduHeaders.MMS_VERSION); + } + + /** + * Set X-Mms-MMS-Version field value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if field's value is not Octet. + */ + public void setMmsVersion(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.MMS_VERSION); + } + + /** + * Get From value. + * From-value = Value-length + * (Address-present-token Encoded-string-value | Insert-address-token) + * + * @return the value + */ + public EncodedStringValue getFrom() { + return mPduHeaders.getEncodedStringValue(PduHeaders.FROM); + } + + /** + * Set From value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setFrom(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.FROM); + } +} diff --git a/src/android/support/v7/mms/pdu/InvalidHeaderValueException.java b/src/android/support/v7/mms/pdu/InvalidHeaderValueException.java new file mode 100644 index 0000000..4b1de02 --- /dev/null +++ b/src/android/support/v7/mms/pdu/InvalidHeaderValueException.java @@ -0,0 +1,41 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * Thrown when an invalid header value was set. + */ +public class InvalidHeaderValueException extends MmsException { + private static final long serialVersionUID = -2053384496042052262L; + + /** + * Constructs an InvalidHeaderValueException with no detailed message. + */ + public InvalidHeaderValueException() { + super(); + } + + /** + * Constructs an InvalidHeaderValueException with the specified detailed message. + * + * @param message the detailed message. + */ + public InvalidHeaderValueException(String message) { + super(message); + } +} diff --git a/src/android/support/v7/mms/pdu/MmsException.java b/src/android/support/v7/mms/pdu/MmsException.java new file mode 100644 index 0000000..1fd1a02 --- /dev/null +++ b/src/android/support/v7/mms/pdu/MmsException.java @@ -0,0 +1,60 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * A generic exception that is thrown by the Mms client. + */ +public class MmsException extends Exception { + private static final long serialVersionUID = -7323249827281485390L; + + /** + * Creates a new MmsException. + */ + public MmsException() { + super(); + } + + /** + * Creates a new MmsException with the specified detail message. + * + * @param message the detail message. + */ + public MmsException(String message) { + super(message); + } + + /** + * Creates a new MmsException with the specified cause. + * + * @param cause the cause. + */ + public MmsException(Throwable cause) { + super(cause); + } + + /** + * Creates a new MmsException with the specified detail message and cause. + * + * @param message the detail message. + * @param cause the cause. + */ + public MmsException(String message, Throwable cause) { + super(message, cause); + } +} diff --git a/src/android/support/v7/mms/pdu/MultimediaMessagePdu.java b/src/android/support/v7/mms/pdu/MultimediaMessagePdu.java new file mode 100644 index 0000000..12f3b6d --- /dev/null +++ b/src/android/support/v7/mms/pdu/MultimediaMessagePdu.java @@ -0,0 +1,148 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * Multimedia message PDU. + */ +public class MultimediaMessagePdu extends GenericPdu{ + /** + * The body. + */ + private PduBody mMessageBody; + + /** + * Constructor. + */ + public MultimediaMessagePdu() { + super(); + } + + /** + * Constructor. + * + * @param header the header of this PDU + * @param body the body of this PDU + */ + public MultimediaMessagePdu(PduHeaders header, PduBody body) { + super(header); + mMessageBody = body; + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + MultimediaMessagePdu(PduHeaders headers) { + super(headers); + } + + /** + * Get body of the PDU. + * + * @return the body + */ + public PduBody getBody() { + return mMessageBody; + } + + /** + * Set body of the PDU. + * + * @param body the body + */ + public void setBody(PduBody body) { + mMessageBody = body; + } + + /** + * Get subject. + * + * @return the value + */ + public EncodedStringValue getSubject() { + return mPduHeaders.getEncodedStringValue(PduHeaders.SUBJECT); + } + + /** + * Set subject. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setSubject(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.SUBJECT); + } + + /** + * Get To value. + * + * @return the value + */ + public EncodedStringValue[] getTo() { + return mPduHeaders.getEncodedStringValues(PduHeaders.TO); + } + + /** + * Add a "To" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void addTo(EncodedStringValue value) { + mPduHeaders.appendEncodedStringValue(value, PduHeaders.TO); + } + + /** + * Get X-Mms-Priority value. + * + * @return the value + */ + public int getPriority() { + return mPduHeaders.getOctet(PduHeaders.PRIORITY); + } + + /** + * Set X-Mms-Priority value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setPriority(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.PRIORITY); + } + + /** + * Get Date value. + * + * @return the value + */ + public long getDate() { + return mPduHeaders.getLongInteger(PduHeaders.DATE); + } + + /** + * Set Date value in seconds. + * + * @param value the value + */ + public void setDate(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.DATE); + } +} diff --git a/src/android/support/v7/mms/pdu/NotificationInd.java b/src/android/support/v7/mms/pdu/NotificationInd.java new file mode 100644 index 0000000..16aa23d --- /dev/null +++ b/src/android/support/v7/mms/pdu/NotificationInd.java @@ -0,0 +1,283 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * M-Notification.ind PDU. + */ +public class NotificationInd extends GenericPdu { + /** + * Empty constructor. + * Since the Pdu corresponding to this class is constructed + * by the Proxy-Relay server, this class is only instantiated + * by the Pdu Parser. + * + * @throws InvalidHeaderValueException if error occurs. + * RuntimeException if an undeclared error occurs. + */ + public NotificationInd() throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + NotificationInd(PduHeaders headers) { + super(headers); + } + + /** + * Get X-Mms-Content-Class Value. + * + * @return the value + */ + public int getContentClass() { + return mPduHeaders.getOctet(PduHeaders.CONTENT_CLASS); + } + + /** + * Set X-Mms-Content-Class Value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if an undeclared error occurs. + */ + public void setContentClass(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.CONTENT_CLASS); + } + + /** + * Get X-Mms-Content-Location value. + * When used in a PDU other than M-Mbox-Delete.conf and M-Delete.conf: + * Content-location-value = Uri-value + * + * @return the value + */ + public byte[] getContentLocation() { + return mPduHeaders.getTextString(PduHeaders.CONTENT_LOCATION); + } + + /** + * Set X-Mms-Content-Location value. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setContentLocation(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.CONTENT_LOCATION); + } + + /** + * Get X-Mms-Expiry value. + * + * Expiry-value = Value-length + * (Absolute-token Date-value | Relative-token Delta-seconds-value) + * + * @return the value + */ + public long getExpiry() { + return mPduHeaders.getLongInteger(PduHeaders.EXPIRY); + } + + /** + * Set X-Mms-Expiry value. + * + * @param value the value + * @throws RuntimeException if an undeclared error occurs. + */ + public void setExpiry(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.EXPIRY); + } + + /** + * Get From value. + * From-value = Value-length + * (Address-present-token Encoded-string-value | Insert-address-token) + * + * @return the value + */ + public EncodedStringValue getFrom() { + return mPduHeaders.getEncodedStringValue(PduHeaders.FROM); + } + + /** + * Set From value. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setFrom(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.FROM); + } + + /** + * Get X-Mms-Message-Class value. + * Message-class-value = Class-identifier | Token-text + * Class-identifier = Personal | Advertisement | Informational | Auto + * + * @return the value + */ + public byte[] getMessageClass() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_CLASS); + } + + /** + * Set X-Mms-Message-Class value. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setMessageClass(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_CLASS); + } + + /** + * Get X-Mms-Message-Size value. + * Message-size-value = Long-integer + * + * @return the value + */ + public long getMessageSize() { + return mPduHeaders.getLongInteger(PduHeaders.MESSAGE_SIZE); + } + + /** + * Set X-Mms-Message-Size value. + * + * @param value the value + * @throws RuntimeException if an undeclared error occurs. + */ + public void setMessageSize(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.MESSAGE_SIZE); + } + + /** + * Get subject. + * + * @return the value + */ + public EncodedStringValue getSubject() { + return mPduHeaders.getEncodedStringValue(PduHeaders.SUBJECT); + } + + /** + * Set subject. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setSubject(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.SUBJECT); + } + + /** + * Get X-Mms-Transaction-Id. + * + * @return the value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } + + /** + * Get X-Mms-Delivery-Report Value. + * + * @return the value + */ + public int getDeliveryReport() { + return mPduHeaders.getOctet(PduHeaders.DELIVERY_REPORT); + } + + /** + * Set X-Mms-Delivery-Report Value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if an undeclared error occurs. + */ + public void setDeliveryReport(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.DELIVERY_REPORT); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte getDrmContent() {return 0x00;} + * public void setDrmContent(byte value) {} + * + * public byte getDistributionIndicator() {return 0x00;} + * public void setDistributionIndicator(byte value) {} + * + * public ElementDescriptorValue getElementDescriptor() {return null;} + * public void getElementDescriptor(ElementDescriptorValue value) {} + * + * public byte getPriority() {return 0x00;} + * public void setPriority(byte value) {} + * + * public byte getRecommendedRetrievalMode() {return 0x00;} + * public void setRecommendedRetrievalMode(byte value) {} + * + * public byte getRecommendedRetrievalModeText() {return 0x00;} + * public void setRecommendedRetrievalModeText(byte value) {} + * + * public byte[] getReplaceId() {return 0x00;} + * public void setReplaceId(byte[] value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + * + * public byte getReplyCharging() {return 0x00;} + * public void setReplyCharging(byte value) {} + * + * public byte getReplyChargingDeadline() {return 0x00;} + * public void setReplyChargingDeadline(byte value) {} + * + * public byte[] getReplyChargingId() {return 0x00;} + * public void setReplyChargingId(byte[] value) {} + * + * public long getReplyChargingSize() {return 0;} + * public void setReplyChargingSize(long value) {} + * + * public byte getStored() {return 0x00;} + * public void setStored(byte value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/NotifyRespInd.java b/src/android/support/v7/mms/pdu/NotifyRespInd.java new file mode 100644 index 0000000..cb8e92b --- /dev/null +++ b/src/android/support/v7/mms/pdu/NotifyRespInd.java @@ -0,0 +1,112 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * M-NofifyResp.ind PDU. + */ +public class NotifyRespInd extends GenericPdu { + /** + * Constructor, used when composing a M-NotifyResp.ind pdu. + * + * @param mmsVersion current version of mms + * @param transactionId the transaction-id value + * @param status the status value + * @throws InvalidHeaderValueException if parameters are invalid. + * NullPointerException if transactionId is null. + * RuntimeException if an undeclared error occurs. + */ + public NotifyRespInd(int mmsVersion, + byte[] transactionId, + int status) throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_NOTIFYRESP_IND); + setMmsVersion(mmsVersion); + setTransactionId(transactionId); + setStatus(status); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + NotifyRespInd(PduHeaders headers) { + super(headers); + } + + /** + * Get X-Mms-Report-Allowed field value. + * + * @return the X-Mms-Report-Allowed value + */ + public int getReportAllowed() { + return mPduHeaders.getOctet(PduHeaders.REPORT_ALLOWED); + } + + /** + * Set X-Mms-Report-Allowed field value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if an undeclared error occurs. + */ + public void setReportAllowed(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.REPORT_ALLOWED); + } + + /** + * Set X-Mms-Status field value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + * RuntimeException if an undeclared error occurs. + */ + public void setStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.STATUS); + } + + /** + * GetX-Mms-Status field value. + * + * @return the X-Mms-Status value + */ + public int getStatus() { + return mPduHeaders.getOctet(PduHeaders.STATUS); + } + + /** + * Get X-Mms-Transaction-Id field value. + * + * @return the X-Mms-Report-Allowed value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id field value. + * + * @param value the value + * @throws NullPointerException if the value is null. + * RuntimeException if an undeclared error occurs. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } +} diff --git a/src/android/support/v7/mms/pdu/PduBody.java b/src/android/support/v7/mms/pdu/PduBody.java new file mode 100644 index 0000000..9d983fc --- /dev/null +++ b/src/android/support/v7/mms/pdu/PduBody.java @@ -0,0 +1,191 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +import java.util.HashMap; +import java.util.Map; +import java.util.Vector; + +public class PduBody { + private Vector<PduPart> mParts = null; + + private Map<String, PduPart> mPartMapByContentId = null; + private Map<String, PduPart> mPartMapByContentLocation = null; + private Map<String, PduPart> mPartMapByName = null; + private Map<String, PduPart> mPartMapByFileName = null; + + /** + * Constructor. + */ + public PduBody() { + mParts = new Vector<PduPart>(); + + mPartMapByContentId = new HashMap<String, PduPart>(); + mPartMapByContentLocation = new HashMap<String, PduPart>(); + mPartMapByName = new HashMap<String, PduPart>(); + mPartMapByFileName = new HashMap<String, PduPart>(); + } + + private void putPartToMaps(PduPart part) { + // Put part to mPartMapByContentId. + byte[] contentId = part.getContentId(); + if(null != contentId) { + mPartMapByContentId.put(new String(contentId), part); + } + + // Put part to mPartMapByContentLocation. + byte[] contentLocation = part.getContentLocation(); + if(null != contentLocation) { + String clc = new String(contentLocation); + mPartMapByContentLocation.put(clc, part); + } + + // Put part to mPartMapByName. + byte[] name = part.getName(); + if(null != name) { + String clc = new String(name); + mPartMapByName.put(clc, part); + } + + // Put part to mPartMapByFileName. + byte[] fileName = part.getFilename(); + if(null != fileName) { + String clc = new String(fileName); + mPartMapByFileName.put(clc, part); + } + } + + /** + * Appends the specified part to the end of this body. + * + * @param part part to be appended + * @return true when success, false when fail + * @throws NullPointerException when part is null + */ + public boolean addPart(PduPart part) { + if(null == part) { + throw new NullPointerException(); + } + + putPartToMaps(part); + return mParts.add(part); + } + + /** + * Inserts the specified part at the specified position. + * + * @param index index at which the specified part is to be inserted + * @param part part to be inserted + * @throws NullPointerException when part is null + */ + public void addPart(int index, PduPart part) { + if(null == part) { + throw new NullPointerException(); + } + + putPartToMaps(part); + mParts.add(index, part); + } + + /** + * Removes the part at the specified position. + * + * @param index index of the part to return + * @return part at the specified index + */ + public PduPart removePart(int index) { + return mParts.remove(index); + } + + /** + * Remove all of the parts. + */ + public void removeAll() { + mParts.clear(); + } + + /** + * Get the part at the specified position. + * + * @param index index of the part to return + * @return part at the specified index + */ + public PduPart getPart(int index) { + return mParts.get(index); + } + + /** + * Get the index of the specified part. + * + * @param part the part object + * @return index the index of the first occurrence of the part in this body + */ + public int getPartIndex(PduPart part) { + return mParts.indexOf(part); + } + + /** + * Get the number of parts. + * + * @return the number of parts + */ + public int getPartsNum() { + return mParts.size(); + } + + /** + * Get pdu part by content id. + * + * @param cid the value of content id. + * @return the pdu part. + */ + public PduPart getPartByContentId(String cid) { + return mPartMapByContentId.get(cid); + } + + /** + * Get pdu part by Content-Location. Content-Location of part is + * the same as filename and name(param of content-type). + * + * @param contentLocation the content location. + * @return the pdu part. + */ + public PduPart getPartByContentLocation(String contentLocation) { + return mPartMapByContentLocation.get(contentLocation); + } + + /** + * Get pdu part by name. + * + * @param name the value of filename. + * @return the pdu part. + */ + public PduPart getPartByName(String name) { + return mPartMapByName.get(name); + } + + /** + * Get pdu part by filename. + * + * @param filename the value of filename. + * @return the pdu part. + */ + public PduPart getPartByFileName(String filename) { + return mPartMapByFileName.get(filename); + } +} diff --git a/src/android/support/v7/mms/pdu/PduContentTypes.java b/src/android/support/v7/mms/pdu/PduContentTypes.java new file mode 100644 index 0000000..7cd0ecf --- /dev/null +++ b/src/android/support/v7/mms/pdu/PduContentTypes.java @@ -0,0 +1,110 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class PduContentTypes { + /** + * All content types. From: + * http://www.openmobilealliance.org/tech/omna/omna-wsp-content-type.htm + */ + static final String[] contentTypes = { + "*/*", /* 0x00 */ + "text/*", /* 0x01 */ + "text/html", /* 0x02 */ + "text/plain", /* 0x03 */ + "text/x-hdml", /* 0x04 */ + "text/x-ttml", /* 0x05 */ + "text/x-vCalendar", /* 0x06 */ + "text/x-vCard", /* 0x07 */ + "text/vnd.wap.wml", /* 0x08 */ + "text/vnd.wap.wmlscript", /* 0x09 */ + "text/vnd.wap.wta-event", /* 0x0A */ + "multipart/*", /* 0x0B */ + "multipart/mixed", /* 0x0C */ + "multipart/form-data", /* 0x0D */ + "multipart/byterantes", /* 0x0E */ + "multipart/alternative", /* 0x0F */ + "application/*", /* 0x10 */ + "application/java-vm", /* 0x11 */ + "application/x-www-form-urlencoded", /* 0x12 */ + "application/x-hdmlc", /* 0x13 */ + "application/vnd.wap.wmlc", /* 0x14 */ + "application/vnd.wap.wmlscriptc", /* 0x15 */ + "application/vnd.wap.wta-eventc", /* 0x16 */ + "application/vnd.wap.uaprof", /* 0x17 */ + "application/vnd.wap.wtls-ca-certificate", /* 0x18 */ + "application/vnd.wap.wtls-user-certificate", /* 0x19 */ + "application/x-x509-ca-cert", /* 0x1A */ + "application/x-x509-user-cert", /* 0x1B */ + "image/*", /* 0x1C */ + "image/gif", /* 0x1D */ + "image/jpeg", /* 0x1E */ + "image/tiff", /* 0x1F */ + "image/png", /* 0x20 */ + "image/vnd.wap.wbmp", /* 0x21 */ + "application/vnd.wap.multipart.*", /* 0x22 */ + "application/vnd.wap.multipart.mixed", /* 0x23 */ + "application/vnd.wap.multipart.form-data", /* 0x24 */ + "application/vnd.wap.multipart.byteranges", /* 0x25 */ + "application/vnd.wap.multipart.alternative", /* 0x26 */ + "application/xml", /* 0x27 */ + "text/xml", /* 0x28 */ + "application/vnd.wap.wbxml", /* 0x29 */ + "application/x-x968-cross-cert", /* 0x2A */ + "application/x-x968-ca-cert", /* 0x2B */ + "application/x-x968-user-cert", /* 0x2C */ + "text/vnd.wap.si", /* 0x2D */ + "application/vnd.wap.sic", /* 0x2E */ + "text/vnd.wap.sl", /* 0x2F */ + "application/vnd.wap.slc", /* 0x30 */ + "text/vnd.wap.co", /* 0x31 */ + "application/vnd.wap.coc", /* 0x32 */ + "application/vnd.wap.multipart.related", /* 0x33 */ + "application/vnd.wap.sia", /* 0x34 */ + "text/vnd.wap.connectivity-xml", /* 0x35 */ + "application/vnd.wap.connectivity-wbxml", /* 0x36 */ + "application/pkcs7-mime", /* 0x37 */ + "application/vnd.wap.hashed-certificate", /* 0x38 */ + "application/vnd.wap.signed-certificate", /* 0x39 */ + "application/vnd.wap.cert-response", /* 0x3A */ + "application/xhtml+xml", /* 0x3B */ + "application/wml+xml", /* 0x3C */ + "text/css", /* 0x3D */ + "application/vnd.wap.mms-message", /* 0x3E */ + "application/vnd.wap.rollover-certificate", /* 0x3F */ + "application/vnd.wap.locc+wbxml", /* 0x40 */ + "application/vnd.wap.loc+xml", /* 0x41 */ + "application/vnd.syncml.dm+wbxml", /* 0x42 */ + "application/vnd.syncml.dm+xml", /* 0x43 */ + "application/vnd.syncml.notification", /* 0x44 */ + "application/vnd.wap.xhtml+xml", /* 0x45 */ + "application/vnd.wv.csp.cir", /* 0x46 */ + "application/vnd.oma.dd+xml", /* 0x47 */ + "application/vnd.oma.drm.message", /* 0x48 */ + "application/vnd.oma.drm.content", /* 0x49 */ + "application/vnd.oma.drm.rights+xml", /* 0x4A */ + "application/vnd.oma.drm.rights+wbxml", /* 0x4B */ + "application/vnd.wv.csp+xml", /* 0x4C */ + "application/vnd.wv.csp+wbxml", /* 0x4D */ + "application/vnd.syncml.ds.notification", /* 0x4E */ + "audio/*", /* 0x4F */ + "video/*", /* 0x50 */ + "application/vnd.oma.dd2+xml", /* 0x51 */ + "application/mikey" /* 0x52 */ + }; +} diff --git a/src/android/support/v7/mms/pdu/PduHeaders.java b/src/android/support/v7/mms/pdu/PduHeaders.java new file mode 100644 index 0000000..0271e58 --- /dev/null +++ b/src/android/support/v7/mms/pdu/PduHeaders.java @@ -0,0 +1,719 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +import java.util.ArrayList; +import java.util.HashMap; + +public class PduHeaders { + /** + * All pdu header fields. + */ + public static final int BCC = 0x81; + public static final int CC = 0x82; + public static final int CONTENT_LOCATION = 0x83; + public static final int CONTENT_TYPE = 0x84; + public static final int DATE = 0x85; + public static final int DELIVERY_REPORT = 0x86; + public static final int DELIVERY_TIME = 0x87; + public static final int EXPIRY = 0x88; + public static final int FROM = 0x89; + public static final int MESSAGE_CLASS = 0x8A; + public static final int MESSAGE_ID = 0x8B; + public static final int MESSAGE_TYPE = 0x8C; + public static final int MMS_VERSION = 0x8D; + public static final int MESSAGE_SIZE = 0x8E; + public static final int PRIORITY = 0x8F; + + public static final int READ_REPLY = 0x90; + public static final int READ_REPORT = 0x90; + public static final int REPORT_ALLOWED = 0x91; + public static final int RESPONSE_STATUS = 0x92; + public static final int RESPONSE_TEXT = 0x93; + public static final int SENDER_VISIBILITY = 0x94; + public static final int STATUS = 0x95; + public static final int SUBJECT = 0x96; + public static final int TO = 0x97; + public static final int TRANSACTION_ID = 0x98; + public static final int RETRIEVE_STATUS = 0x99; + public static final int RETRIEVE_TEXT = 0x9A; + public static final int READ_STATUS = 0x9B; + public static final int REPLY_CHARGING = 0x9C; + public static final int REPLY_CHARGING_DEADLINE = 0x9D; + public static final int REPLY_CHARGING_ID = 0x9E; + public static final int REPLY_CHARGING_SIZE = 0x9F; + + public static final int PREVIOUSLY_SENT_BY = 0xA0; + public static final int PREVIOUSLY_SENT_DATE = 0xA1; + public static final int STORE = 0xA2; + public static final int MM_STATE = 0xA3; + public static final int MM_FLAGS = 0xA4; + public static final int STORE_STATUS = 0xA5; + public static final int STORE_STATUS_TEXT = 0xA6; + public static final int STORED = 0xA7; + public static final int ATTRIBUTES = 0xA8; + public static final int TOTALS = 0xA9; + public static final int MBOX_TOTALS = 0xAA; + public static final int QUOTAS = 0xAB; + public static final int MBOX_QUOTAS = 0xAC; + public static final int MESSAGE_COUNT = 0xAD; + public static final int CONTENT = 0xAE; + public static final int START = 0xAF; + + public static final int ADDITIONAL_HEADERS = 0xB0; + public static final int DISTRIBUTION_INDICATOR = 0xB1; + public static final int ELEMENT_DESCRIPTOR = 0xB2; + public static final int LIMIT = 0xB3; + public static final int RECOMMENDED_RETRIEVAL_MODE = 0xB4; + public static final int RECOMMENDED_RETRIEVAL_MODE_TEXT = 0xB5; + public static final int STATUS_TEXT = 0xB6; + public static final int APPLIC_ID = 0xB7; + public static final int REPLY_APPLIC_ID = 0xB8; + public static final int AUX_APPLIC_ID = 0xB9; + public static final int CONTENT_CLASS = 0xBA; + public static final int DRM_CONTENT = 0xBB; + public static final int ADAPTATION_ALLOWED = 0xBC; + public static final int REPLACE_ID = 0xBD; + public static final int CANCEL_ID = 0xBE; + public static final int CANCEL_STATUS = 0xBF; + + /** + * X-Mms-Message-Type field types. + */ + public static final int MESSAGE_TYPE_SEND_REQ = 0x80; + public static final int MESSAGE_TYPE_SEND_CONF = 0x81; + public static final int MESSAGE_TYPE_NOTIFICATION_IND = 0x82; + public static final int MESSAGE_TYPE_NOTIFYRESP_IND = 0x83; + public static final int MESSAGE_TYPE_RETRIEVE_CONF = 0x84; + public static final int MESSAGE_TYPE_ACKNOWLEDGE_IND = 0x85; + public static final int MESSAGE_TYPE_DELIVERY_IND = 0x86; + public static final int MESSAGE_TYPE_READ_REC_IND = 0x87; + public static final int MESSAGE_TYPE_READ_ORIG_IND = 0x88; + public static final int MESSAGE_TYPE_FORWARD_REQ = 0x89; + public static final int MESSAGE_TYPE_FORWARD_CONF = 0x8A; + public static final int MESSAGE_TYPE_MBOX_STORE_REQ = 0x8B; + public static final int MESSAGE_TYPE_MBOX_STORE_CONF = 0x8C; + public static final int MESSAGE_TYPE_MBOX_VIEW_REQ = 0x8D; + public static final int MESSAGE_TYPE_MBOX_VIEW_CONF = 0x8E; + public static final int MESSAGE_TYPE_MBOX_UPLOAD_REQ = 0x8F; + public static final int MESSAGE_TYPE_MBOX_UPLOAD_CONF = 0x90; + public static final int MESSAGE_TYPE_MBOX_DELETE_REQ = 0x91; + public static final int MESSAGE_TYPE_MBOX_DELETE_CONF = 0x92; + public static final int MESSAGE_TYPE_MBOX_DESCR = 0x93; + public static final int MESSAGE_TYPE_DELETE_REQ = 0x94; + public static final int MESSAGE_TYPE_DELETE_CONF = 0x95; + public static final int MESSAGE_TYPE_CANCEL_REQ = 0x96; + public static final int MESSAGE_TYPE_CANCEL_CONF = 0x97; + + /** + * X-Mms-Delivery-Report | + * X-Mms-Read-Report | + * X-Mms-Report-Allowed | + * X-Mms-Sender-Visibility | + * X-Mms-Store | + * X-Mms-Stored | + * X-Mms-Totals | + * X-Mms-Quotas | + * X-Mms-Distribution-Indicator | + * X-Mms-DRM-Content | + * X-Mms-Adaptation-Allowed | + * field types. + */ + public static final int VALUE_YES = 0x80; + public static final int VALUE_NO = 0x81; + + /** + * Delivery-Time | + * Expiry and Reply-Charging-Deadline | + * field type components. + */ + public static final int VALUE_ABSOLUTE_TOKEN = 0x80; + public static final int VALUE_RELATIVE_TOKEN = 0x81; + + /** + * X-Mms-MMS-Version field types. + */ + public static final int MMS_VERSION_1_3 = ((1 << 4) | 3); + public static final int MMS_VERSION_1_2 = ((1 << 4) | 2); + public static final int MMS_VERSION_1_1 = ((1 << 4) | 1); + public static final int MMS_VERSION_1_0 = ((1 << 4) | 0); + + // Current version is 1.2. + public static final int CURRENT_MMS_VERSION = MMS_VERSION_1_2; + + /** + * From field type components. + */ + public static final int FROM_ADDRESS_PRESENT_TOKEN = 0x80; + public static final int FROM_INSERT_ADDRESS_TOKEN = 0x81; + + public static final String FROM_ADDRESS_PRESENT_TOKEN_STR = "address-present-token"; + public static final String FROM_INSERT_ADDRESS_TOKEN_STR = "insert-address-token"; + + /** + * X-Mms-Status Field. + */ + public static final int STATUS_EXPIRED = 0x80; + public static final int STATUS_RETRIEVED = 0x81; + public static final int STATUS_REJECTED = 0x82; + public static final int STATUS_DEFERRED = 0x83; + public static final int STATUS_UNRECOGNIZED = 0x84; + public static final int STATUS_INDETERMINATE = 0x85; + public static final int STATUS_FORWARDED = 0x86; + public static final int STATUS_UNREACHABLE = 0x87; + + /** + * MM-Flags field type components. + */ + public static final int MM_FLAGS_ADD_TOKEN = 0x80; + public static final int MM_FLAGS_REMOVE_TOKEN = 0x81; + public static final int MM_FLAGS_FILTER_TOKEN = 0x82; + + /** + * X-Mms-Message-Class field types. + */ + public static final int MESSAGE_CLASS_PERSONAL = 0x80; + public static final int MESSAGE_CLASS_ADVERTISEMENT = 0x81; + public static final int MESSAGE_CLASS_INFORMATIONAL = 0x82; + public static final int MESSAGE_CLASS_AUTO = 0x83; + + public static final String MESSAGE_CLASS_PERSONAL_STR = "personal"; + public static final String MESSAGE_CLASS_ADVERTISEMENT_STR = "advertisement"; + public static final String MESSAGE_CLASS_INFORMATIONAL_STR = "informational"; + public static final String MESSAGE_CLASS_AUTO_STR = "auto"; + + /** + * X-Mms-Priority field types. + */ + public static final int PRIORITY_LOW = 0x80; + public static final int PRIORITY_NORMAL = 0x81; + public static final int PRIORITY_HIGH = 0x82; + + /** + * X-Mms-Response-Status field types. + */ + public static final int RESPONSE_STATUS_OK = 0x80; + public static final int RESPONSE_STATUS_ERROR_UNSPECIFIED = 0x81; + public static final int RESPONSE_STATUS_ERROR_SERVICE_DENIED = 0x82; + + public static final int RESPONSE_STATUS_ERROR_MESSAGE_FORMAT_CORRUPT = 0x83; + public static final int RESPONSE_STATUS_ERROR_SENDING_ADDRESS_UNRESOLVED = 0x84; + + public static final int RESPONSE_STATUS_ERROR_MESSAGE_NOT_FOUND = 0x85; + public static final int RESPONSE_STATUS_ERROR_NETWORK_PROBLEM = 0x86; + public static final int RESPONSE_STATUS_ERROR_CONTENT_NOT_ACCEPTED = 0x87; + public static final int RESPONSE_STATUS_ERROR_UNSUPPORTED_MESSAGE = 0x88; + public static final int RESPONSE_STATUS_ERROR_TRANSIENT_FAILURE = 0xC0; + + public static final int RESPONSE_STATUS_ERROR_TRANSIENT_SENDNG_ADDRESS_UNRESOLVED = 0xC1; + public static final int RESPONSE_STATUS_ERROR_TRANSIENT_MESSAGE_NOT_FOUND = 0xC2; + public static final int RESPONSE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM = 0xC3; + public static final int RESPONSE_STATUS_ERROR_TRANSIENT_PARTIAL_SUCCESS = 0xC4; + + public static final int RESPONSE_STATUS_ERROR_PERMANENT_FAILURE = 0xE0; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_SERVICE_DENIED = 0xE1; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_MESSAGE_FORMAT_CORRUPT = 0xE2; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_SENDING_ADDRESS_UNRESOLVED = 0xE3; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_MESSAGE_NOT_FOUND = 0xE4; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_CONTENT_NOT_ACCEPTED = 0xE5; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_REPLY_CHARGING_LIMITATIONS_NOT_MET = 0xE6; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_REPLY_CHARGING_REQUEST_NOT_ACCEPTED = 0xE6; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_REPLY_CHARGING_FORWARDING_DENIED = 0xE8; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_REPLY_CHARGING_NOT_SUPPORTED = 0xE9; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_ADDRESS_HIDING_NOT_SUPPORTED = 0xEA; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_LACK_OF_PREPAID = 0xEB; + public static final int RESPONSE_STATUS_ERROR_PERMANENT_END = 0xFF; + + /** + * X-Mms-Retrieve-Status field types. + */ + public static final int RETRIEVE_STATUS_OK = 0x80; + public static final int RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE = 0xC0; + public static final int RETRIEVE_STATUS_ERROR_TRANSIENT_MESSAGE_NOT_FOUND = 0xC1; + public static final int RETRIEVE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM = 0xC2; + public static final int RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE = 0xE0; + public static final int RETRIEVE_STATUS_ERROR_PERMANENT_SERVICE_DENIED = 0xE1; + public static final int RETRIEVE_STATUS_ERROR_PERMANENT_MESSAGE_NOT_FOUND = 0xE2; + public static final int RETRIEVE_STATUS_ERROR_PERMANENT_CONTENT_UNSUPPORTED = 0xE3; + public static final int RETRIEVE_STATUS_ERROR_END = 0xFF; + + /** + * X-Mms-Sender-Visibility field types. + */ + public static final int SENDER_VISIBILITY_HIDE = 0x80; + public static final int SENDER_VISIBILITY_SHOW = 0x81; + + /** + * X-Mms-Read-Status field types. + */ + public static final int READ_STATUS_READ = 0x80; + public static final int READ_STATUS__DELETED_WITHOUT_BEING_READ = 0x81; + + /** + * X-Mms-Cancel-Status field types. + */ + public static final int CANCEL_STATUS_REQUEST_SUCCESSFULLY_RECEIVED = 0x80; + public static final int CANCEL_STATUS_REQUEST_CORRUPTED = 0x81; + + /** + * X-Mms-Reply-Charging field types. + */ + public static final int REPLY_CHARGING_REQUESTED = 0x80; + public static final int REPLY_CHARGING_REQUESTED_TEXT_ONLY = 0x81; + public static final int REPLY_CHARGING_ACCEPTED = 0x82; + public static final int REPLY_CHARGING_ACCEPTED_TEXT_ONLY = 0x83; + + /** + * X-Mms-MM-State field types. + */ + public static final int MM_STATE_DRAFT = 0x80; + public static final int MM_STATE_SENT = 0x81; + public static final int MM_STATE_NEW = 0x82; + public static final int MM_STATE_RETRIEVED = 0x83; + public static final int MM_STATE_FORWARDED = 0x84; + + /** + * X-Mms-Recommended-Retrieval-Mode field types. + */ + public static final int RECOMMENDED_RETRIEVAL_MODE_MANUAL = 0x80; + + /** + * X-Mms-Content-Class field types. + */ + public static final int CONTENT_CLASS_TEXT = 0x80; + public static final int CONTENT_CLASS_IMAGE_BASIC = 0x81; + public static final int CONTENT_CLASS_IMAGE_RICH = 0x82; + public static final int CONTENT_CLASS_VIDEO_BASIC = 0x83; + public static final int CONTENT_CLASS_VIDEO_RICH = 0x84; + public static final int CONTENT_CLASS_MEGAPIXEL = 0x85; + public static final int CONTENT_CLASS_CONTENT_BASIC = 0x86; + public static final int CONTENT_CLASS_CONTENT_RICH = 0x87; + + /** + * X-Mms-Store-Status field types. + */ + public static final int STORE_STATUS_SUCCESS = 0x80; + public static final int STORE_STATUS_ERROR_TRANSIENT_FAILURE = 0xC0; + public static final int STORE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM = 0xC1; + public static final int STORE_STATUS_ERROR_PERMANENT_FAILURE = 0xE0; + public static final int STORE_STATUS_ERROR_PERMANENT_SERVICE_DENIED = 0xE1; + public static final int STORE_STATUS_ERROR_PERMANENT_MESSAGE_FORMAT_CORRUPT = 0xE2; + public static final int STORE_STATUS_ERROR_PERMANENT_MESSAGE_NOT_FOUND = 0xE3; + public static final int STORE_STATUS_ERROR_PERMANENT_MMBOX_FULL = 0xE4; + public static final int STORE_STATUS_ERROR_END = 0xFF; + + /** + * The map contains the value of all headers. + */ + private HashMap<Integer, Object> mHeaderMap = null; + + /** + * Constructor of PduHeaders. + */ + public PduHeaders() { + mHeaderMap = new HashMap<Integer, Object>(); + } + + /** + * Get octet value by header field. + * + * @param field the field + * @return the octet value of the pdu header + * with specified header field. Return 0 if + * the value is not set. + */ + protected int getOctet(int field) { + Integer octet = (Integer) mHeaderMap.get(field); + if (null == octet) { + return 0; + } + + return octet; + } + + /** + * Set octet value to pdu header by header field. + * + * @param value the value + * @param field the field + * @throws InvalidHeaderValueException if the value is invalid. + */ + protected void setOctet(int value, int field) + throws InvalidHeaderValueException{ + /** + * Check whether this field can be set for specific + * header and check validity of the field. + */ + switch (field) { + case REPORT_ALLOWED: + case ADAPTATION_ALLOWED: + case DELIVERY_REPORT: + case DRM_CONTENT: + case DISTRIBUTION_INDICATOR: + case QUOTAS: + case READ_REPORT: + case STORE: + case STORED: + case TOTALS: + case SENDER_VISIBILITY: + if ((VALUE_YES != value) && (VALUE_NO != value)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case READ_STATUS: + if ((READ_STATUS_READ != value) && + (READ_STATUS__DELETED_WITHOUT_BEING_READ != value)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case CANCEL_STATUS: + if ((CANCEL_STATUS_REQUEST_SUCCESSFULLY_RECEIVED != value) && + (CANCEL_STATUS_REQUEST_CORRUPTED != value)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case PRIORITY: + if ((value < PRIORITY_LOW) || (value > PRIORITY_HIGH)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case STATUS: + if ((value < STATUS_EXPIRED) || (value > STATUS_UNREACHABLE)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case REPLY_CHARGING: + if ((value < REPLY_CHARGING_REQUESTED) + || (value > REPLY_CHARGING_ACCEPTED_TEXT_ONLY)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case MM_STATE: + if ((value < MM_STATE_DRAFT) || (value > MM_STATE_FORWARDED)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case RECOMMENDED_RETRIEVAL_MODE: + if (RECOMMENDED_RETRIEVAL_MODE_MANUAL != value) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case CONTENT_CLASS: + if ((value < CONTENT_CLASS_TEXT) + || (value > CONTENT_CLASS_CONTENT_RICH)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + case RETRIEVE_STATUS: + // According to oma-ts-mms-enc-v1_3, section 7.3.50, we modify the invalid value. + if ((value > RETRIEVE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM) && + (value < RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE)) { + value = RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE; + } else if ((value > RETRIEVE_STATUS_ERROR_PERMANENT_CONTENT_UNSUPPORTED) && + (value <= RETRIEVE_STATUS_ERROR_END)) { + value = RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE; + } else if ((value < RETRIEVE_STATUS_OK) || + ((value > RETRIEVE_STATUS_OK) && + (value < RETRIEVE_STATUS_ERROR_TRANSIENT_FAILURE)) || + (value > RETRIEVE_STATUS_ERROR_END)) { + value = RETRIEVE_STATUS_ERROR_PERMANENT_FAILURE; + } + break; + case STORE_STATUS: + // According to oma-ts-mms-enc-v1_3, section 7.3.58, we modify the invalid value. + if ((value > STORE_STATUS_ERROR_TRANSIENT_NETWORK_PROBLEM) && + (value < STORE_STATUS_ERROR_PERMANENT_FAILURE)) { + value = STORE_STATUS_ERROR_TRANSIENT_FAILURE; + } else if ((value > STORE_STATUS_ERROR_PERMANENT_MMBOX_FULL) && + (value <= STORE_STATUS_ERROR_END)) { + value = STORE_STATUS_ERROR_PERMANENT_FAILURE; + } else if ((value < STORE_STATUS_SUCCESS) || + ((value > STORE_STATUS_SUCCESS) && + (value < STORE_STATUS_ERROR_TRANSIENT_FAILURE)) || + (value > STORE_STATUS_ERROR_END)) { + value = STORE_STATUS_ERROR_PERMANENT_FAILURE; + } + break; + case RESPONSE_STATUS: + // According to oma-ts-mms-enc-v1_3, section 7.3.48, we modify the invalid value. + if ((value > RESPONSE_STATUS_ERROR_TRANSIENT_PARTIAL_SUCCESS) && + (value < RESPONSE_STATUS_ERROR_PERMANENT_FAILURE)) { + value = RESPONSE_STATUS_ERROR_TRANSIENT_FAILURE; + } else if (((value > RESPONSE_STATUS_ERROR_PERMANENT_LACK_OF_PREPAID) && + (value <= RESPONSE_STATUS_ERROR_PERMANENT_END)) || + (value < RESPONSE_STATUS_OK) || + ((value > RESPONSE_STATUS_ERROR_UNSUPPORTED_MESSAGE) && + (value < RESPONSE_STATUS_ERROR_TRANSIENT_FAILURE)) || + (value > RESPONSE_STATUS_ERROR_PERMANENT_END)) { + value = RESPONSE_STATUS_ERROR_PERMANENT_FAILURE; + } + break; + case MMS_VERSION: + if ((value < MMS_VERSION_1_0)|| (value > MMS_VERSION_1_3)) { + value = CURRENT_MMS_VERSION; // Current version is the default value. + } + break; + case MESSAGE_TYPE: + if ((value < MESSAGE_TYPE_SEND_REQ) || (value > MESSAGE_TYPE_CANCEL_CONF)) { + // Invalid value. + throw new InvalidHeaderValueException("Invalid Octet value!"); + } + break; + default: + // This header value should not be Octect. + throw new RuntimeException("Invalid header field!"); + } + mHeaderMap.put(field, value); + } + + /** + * Get TextString value by header field. + * + * @param field the field + * @return the TextString value of the pdu header + * with specified header field + */ + protected byte[] getTextString(int field) { + return (byte[]) mHeaderMap.get(field); + } + + /** + * Set TextString value to pdu header by header field. + * + * @param value the value + * @param field the field + * @return the TextString value of the pdu header + * with specified header field + * @throws NullPointerException if the value is null. + */ + protected void setTextString(byte[] value, int field) { + /** + * Check whether this field can be set for specific + * header and check validity of the field. + */ + if (null == value) { + throw new NullPointerException(); + } + + switch (field) { + case TRANSACTION_ID: + case REPLY_CHARGING_ID: + case AUX_APPLIC_ID: + case APPLIC_ID: + case REPLY_APPLIC_ID: + case MESSAGE_ID: + case REPLACE_ID: + case CANCEL_ID: + case CONTENT_LOCATION: + case MESSAGE_CLASS: + case CONTENT_TYPE: + break; + default: + // This header value should not be Text-String. + throw new RuntimeException("Invalid header field!"); + } + mHeaderMap.put(field, value); + } + + /** + * Get EncodedStringValue value by header field. + * + * @param field the field + * @return the EncodedStringValue value of the pdu header + * with specified header field + */ + protected EncodedStringValue getEncodedStringValue(int field) { + return (EncodedStringValue) mHeaderMap.get(field); + } + + /** + * Get TO, CC or BCC header value. + * + * @param field the field + * @return the EncodeStringValue array of the pdu header + * with specified header field + */ + protected EncodedStringValue[] getEncodedStringValues(int field) { + ArrayList<EncodedStringValue> list = + (ArrayList<EncodedStringValue>) mHeaderMap.get(field); + if (null == list) { + return null; + } + EncodedStringValue[] values = new EncodedStringValue[list.size()]; + return list.toArray(values); + } + + /** + * Set EncodedStringValue value to pdu header by header field. + * + * @param value the value + * @param field the field + * @return the EncodedStringValue value of the pdu header + * with specified header field + * @throws NullPointerException if the value is null. + */ + protected void setEncodedStringValue(EncodedStringValue value, int field) { + /** + * Check whether this field can be set for specific + * header and check validity of the field. + */ + if (null == value) { + throw new NullPointerException(); + } + + switch (field) { + case SUBJECT: + case RECOMMENDED_RETRIEVAL_MODE_TEXT: + case RETRIEVE_TEXT: + case STATUS_TEXT: + case STORE_STATUS_TEXT: + case RESPONSE_TEXT: + case FROM: + case PREVIOUSLY_SENT_BY: + case MM_FLAGS: + break; + default: + // This header value should not be Encoded-String-Value. + throw new RuntimeException("Invalid header field!"); + } + + mHeaderMap.put(field, value); + } + + /** + * Set TO, CC or BCC header value. + * + * @param value the value + * @param field the field + * @return the EncodedStringValue value array of the pdu header + * with specified header field + * @throws NullPointerException if the value is null. + */ + protected void setEncodedStringValues(EncodedStringValue[] value, int field) { + /** + * Check whether this field can be set for specific + * header and check validity of the field. + */ + if (null == value) { + throw new NullPointerException(); + } + + switch (field) { + case BCC: + case CC: + case TO: + break; + default: + // This header value should not be Encoded-String-Value. + throw new RuntimeException("Invalid header field!"); + } + + ArrayList<EncodedStringValue> list = new ArrayList<EncodedStringValue>(); + for (int i = 0; i < value.length; i++) { + list.add(value[i]); + } + mHeaderMap.put(field, list); + } + + /** + * Append one EncodedStringValue to another. + * + * @param value the EncodedStringValue to append + * @param field the field + * @throws NullPointerException if the value is null. + */ + protected void appendEncodedStringValue(EncodedStringValue value, + int field) { + if (null == value) { + throw new NullPointerException(); + } + + switch (field) { + case BCC: + case CC: + case TO: + break; + default: + throw new RuntimeException("Invalid header field!"); + } + + ArrayList<EncodedStringValue> list = + (ArrayList<EncodedStringValue>) mHeaderMap.get(field); + if (null == list) { + list = new ArrayList<EncodedStringValue>(); + } + list.add(value); + mHeaderMap.put(field, list); + } + + /** + * Get LongInteger value by header field. + * + * @param field the field + * @return the LongInteger value of the pdu header + * with specified header field. if return -1, the + * field is not existed in pdu header. + */ + protected long getLongInteger(int field) { + Long longInteger = (Long) mHeaderMap.get(field); + if (null == longInteger) { + return -1; + } + + return longInteger.longValue(); + } + + /** + * Set LongInteger value to pdu header by header field. + * + * @param value the value + * @param field the field + */ + protected void setLongInteger(long value, int field) { + /** + * Check whether this field can be set for specific + * header and check validity of the field. + */ + switch (field) { + case DATE: + case REPLY_CHARGING_SIZE: + case MESSAGE_SIZE: + case MESSAGE_COUNT: + case START: + case LIMIT: + case DELIVERY_TIME: + case EXPIRY: + case REPLY_CHARGING_DEADLINE: + case PREVIOUSLY_SENT_DATE: + break; + default: + // This header value should not be LongInteger. + throw new RuntimeException("Invalid header field!"); + } + mHeaderMap.put(field, value); + } +} diff --git a/src/android/support/v7/mms/pdu/PduParser.java b/src/android/support/v7/mms/pdu/PduParser.java new file mode 100755 index 0000000..7d30df5 --- /dev/null +++ b/src/android/support/v7/mms/pdu/PduParser.java @@ -0,0 +1,2008 @@ +/* + * Copyright (C) 2007-2008 Esmertec AG. + * Copyright (C) 2007-2008 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 android.support.v7.mms.pdu; + +import android.util.Log; + +import java.io.ByteArrayInputStream; +import java.io.ByteArrayOutputStream; +import java.io.UnsupportedEncodingException; +import java.util.Arrays; +import java.util.HashMap; + +public class PduParser { + /** + * The next are WAP values defined in WSP specification. + */ + private static final int QUOTE = 127; + private static final int LENGTH_QUOTE = 31; + private static final int TEXT_MIN = 32; + private static final int TEXT_MAX = 127; + private static final int SHORT_INTEGER_MAX = 127; + private static final int SHORT_LENGTH_MAX = 30; + private static final int LONG_INTEGER_LENGTH_MAX = 8; + private static final int QUOTED_STRING_FLAG = 34; + private static final int END_STRING_FLAG = 0x00; + //The next two are used by the interface "parseWapString" to + //distinguish Text-String and Quoted-String. + private static final int TYPE_TEXT_STRING = 0; + private static final int TYPE_QUOTED_STRING = 1; + private static final int TYPE_TOKEN_STRING = 2; + + /** + * Specify the part position. + */ + private static final int THE_FIRST_PART = 0; + private static final int THE_LAST_PART = 1; + + /** + * The pdu data. + */ + private ByteArrayInputStream mPduDataStream = null; + + /** + * Store pdu headers + */ + private PduHeaders mHeaders = null; + + /** + * Store pdu parts. + */ + private PduBody mBody = null; + + /** + * Store the "type" parameter in "Content-Type" header field. + */ + private static byte[] mTypeParam = null; + + /** + * Store the "start" parameter in "Content-Type" header field. + */ + private static byte[] mStartParam = null; + + /** + * The log tag. + */ + private static final String LOG_TAG = "PduParser"; + private static final boolean DEBUG = false; + private static final boolean LOCAL_LOGV = false; + + /** + * Whether to parse content-disposition part header + */ + private final boolean mParseContentDisposition; + + /** + * Constructor. + * + * @param pduDataStream pdu data to be parsed + * @param parseContentDisposition whether to parse the Content-Disposition part header + */ + public PduParser(byte[] pduDataStream, boolean parseContentDisposition) { + mPduDataStream = new ByteArrayInputStream(pduDataStream); + mParseContentDisposition = parseContentDisposition; + } + + /** + * Parse the pdu. + * + * @return the pdu structure if parsing successfully. + * null if parsing error happened or mandatory fields are not set. + */ + public GenericPdu parse(){ + if (mPduDataStream == null) { + return null; + } + + /* parse headers */ + mHeaders = parseHeaders(mPduDataStream); + if (null == mHeaders) { + // Parse headers failed. + return null; + } + + /* get the message type */ + int messageType = mHeaders.getOctet(PduHeaders.MESSAGE_TYPE); + + /* check mandatory header fields */ + if (false == checkMandatoryHeader(mHeaders)) { + log("check mandatory headers failed!"); + return null; + } + + if ((PduHeaders.MESSAGE_TYPE_SEND_REQ == messageType) || + (PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF == messageType)) { + /* need to parse the parts */ + mBody = parseParts(mPduDataStream); + if (null == mBody) { + // Parse parts failed. + return null; + } + } + + switch (messageType) { + case PduHeaders.MESSAGE_TYPE_SEND_REQ: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_SEND_REQ"); + } + SendReq sendReq = new SendReq(mHeaders, mBody); + return sendReq; + case PduHeaders.MESSAGE_TYPE_SEND_CONF: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_SEND_CONF"); + } + SendConf sendConf = new SendConf(mHeaders); + return sendConf; + case PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_NOTIFICATION_IND"); + } + NotificationInd notificationInd = + new NotificationInd(mHeaders); + return notificationInd; + case PduHeaders.MESSAGE_TYPE_NOTIFYRESP_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_NOTIFYRESP_IND"); + } + NotifyRespInd notifyRespInd = + new NotifyRespInd(mHeaders); + return notifyRespInd; + case PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_RETRIEVE_CONF"); + } + RetrieveConf retrieveConf = + new RetrieveConf(mHeaders, mBody); + + byte[] contentType = retrieveConf.getContentType(); + if (null == contentType) { + return null; + } + String ctTypeStr = new String(contentType); + if (ctTypeStr.equals(ContentType.MULTIPART_MIXED) + || ctTypeStr.equals(ContentType.MULTIPART_RELATED) + || ctTypeStr.equals(ContentType.MULTIPART_ALTERNATIVE)) { + // The MMS content type must be "application/vnd.wap.multipart.mixed" + // or "application/vnd.wap.multipart.related" + // or "application/vnd.wap.multipart.alternative" + return retrieveConf; + } else if (ctTypeStr.equals(ContentType.MULTIPART_ALTERNATIVE)) { + // "application/vnd.wap.multipart.alternative" + // should take only the first part. + PduPart firstPart = mBody.getPart(0); + mBody.removeAll(); + mBody.addPart(0, firstPart); + return retrieveConf; + } + return null; + case PduHeaders.MESSAGE_TYPE_DELIVERY_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_DELIVERY_IND"); + } + DeliveryInd deliveryInd = + new DeliveryInd(mHeaders); + return deliveryInd; + case PduHeaders.MESSAGE_TYPE_ACKNOWLEDGE_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_ACKNOWLEDGE_IND"); + } + AcknowledgeInd acknowledgeInd = + new AcknowledgeInd(mHeaders); + return acknowledgeInd; + case PduHeaders.MESSAGE_TYPE_READ_ORIG_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_READ_ORIG_IND"); + } + ReadOrigInd readOrigInd = + new ReadOrigInd(mHeaders); + return readOrigInd; + case PduHeaders.MESSAGE_TYPE_READ_REC_IND: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parse: MESSAGE_TYPE_READ_REC_IND"); + } + ReadRecInd readRecInd = + new ReadRecInd(mHeaders); + return readRecInd; + default: + log("Parser doesn't support this message type in this version!"); + return null; + } + } + + /** + * Parse pdu headers. + * + * @param pduDataStream pdu data input stream + * @return headers in PduHeaders structure, null when parse fail + */ + protected PduHeaders parseHeaders(ByteArrayInputStream pduDataStream){ + if (pduDataStream == null) { + return null; + } + boolean keepParsing = true; + PduHeaders headers = new PduHeaders(); + + while (keepParsing && (pduDataStream.available() > 0)) { + pduDataStream.mark(1); + int headerField = extractByteValue(pduDataStream); + /* parse custom text header */ + if ((headerField >= TEXT_MIN) && (headerField <= TEXT_MAX)) { + pduDataStream.reset(); + byte [] bVal = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "TextHeader: " + new String(bVal)); + } + /* we should ignore it at the moment */ + continue; + } + switch (headerField) { + case PduHeaders.MESSAGE_TYPE: + { + int messageType = extractByteValue(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: messageType: " + messageType); + } + switch (messageType) { + // We don't support these kind of messages now. + case PduHeaders.MESSAGE_TYPE_FORWARD_REQ: + case PduHeaders.MESSAGE_TYPE_FORWARD_CONF: + case PduHeaders.MESSAGE_TYPE_MBOX_STORE_REQ: + case PduHeaders.MESSAGE_TYPE_MBOX_STORE_CONF: + case PduHeaders.MESSAGE_TYPE_MBOX_VIEW_REQ: + case PduHeaders.MESSAGE_TYPE_MBOX_VIEW_CONF: + case PduHeaders.MESSAGE_TYPE_MBOX_UPLOAD_REQ: + case PduHeaders.MESSAGE_TYPE_MBOX_UPLOAD_CONF: + case PduHeaders.MESSAGE_TYPE_MBOX_DELETE_REQ: + case PduHeaders.MESSAGE_TYPE_MBOX_DELETE_CONF: + case PduHeaders.MESSAGE_TYPE_MBOX_DESCR: + case PduHeaders.MESSAGE_TYPE_DELETE_REQ: + case PduHeaders.MESSAGE_TYPE_DELETE_CONF: + case PduHeaders.MESSAGE_TYPE_CANCEL_REQ: + case PduHeaders.MESSAGE_TYPE_CANCEL_CONF: + return null; + } + try { + headers.setOctet(messageType, headerField); + } catch(InvalidHeaderValueException e) { + log("Set invalid Octet value: " + messageType + + " into the header filed: " + headerField); + return null; + } catch(RuntimeException e) { + log(headerField + "is not Octet header field!"); + return null; + } + break; + } + /* Octect value */ + case PduHeaders.REPORT_ALLOWED: + case PduHeaders.ADAPTATION_ALLOWED: + case PduHeaders.DELIVERY_REPORT: + case PduHeaders.DRM_CONTENT: + case PduHeaders.DISTRIBUTION_INDICATOR: + case PduHeaders.QUOTAS: + case PduHeaders.READ_REPORT: + case PduHeaders.STORE: + case PduHeaders.STORED: + case PduHeaders.TOTALS: + case PduHeaders.SENDER_VISIBILITY: + case PduHeaders.READ_STATUS: + case PduHeaders.CANCEL_STATUS: + case PduHeaders.PRIORITY: + case PduHeaders.STATUS: + case PduHeaders.REPLY_CHARGING: + case PduHeaders.MM_STATE: + case PduHeaders.RECOMMENDED_RETRIEVAL_MODE: + case PduHeaders.CONTENT_CLASS: + case PduHeaders.RETRIEVE_STATUS: + case PduHeaders.STORE_STATUS: + /** + * The following field has a different value when + * used in the M-Mbox-Delete.conf and M-Delete.conf PDU. + * For now we ignore this fact, since we do not support these PDUs + */ + case PduHeaders.RESPONSE_STATUS: + { + int value = extractByteValue(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: byte: " + headerField + " value: " + + value); + } + + try { + headers.setOctet(value, headerField); + } catch(InvalidHeaderValueException e) { + log("Set invalid Octet value: " + value + + " into the header filed: " + headerField); + return null; + } catch(RuntimeException e) { + log(headerField + "is not Octet header field!"); + return null; + } + break; + } + + /* Long-Integer */ + case PduHeaders.DATE: + case PduHeaders.REPLY_CHARGING_SIZE: + case PduHeaders.MESSAGE_SIZE: + { + try { + long value = parseLongInteger(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: longint: " + headerField + " value: " + + value); + } + headers.setLongInteger(value, headerField); + } catch(RuntimeException e) { + log(headerField + "is not Long-Integer header field!"); + return null; + } + break; + } + + /* Integer-Value */ + case PduHeaders.MESSAGE_COUNT: + case PduHeaders.START: + case PduHeaders.LIMIT: + { + try { + long value = parseIntegerValue(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: int: " + headerField + " value: " + + value); + } + headers.setLongInteger(value, headerField); + } catch(RuntimeException e) { + log(headerField + "is not Long-Integer header field!"); + return null; + } + break; + } + + /* Text-String */ + case PduHeaders.TRANSACTION_ID: + case PduHeaders.REPLY_CHARGING_ID: + case PduHeaders.AUX_APPLIC_ID: + case PduHeaders.APPLIC_ID: + case PduHeaders.REPLY_APPLIC_ID: + /** + * The next three header fields are email addresses + * as defined in RFC2822, + * not including the characters "<" and ">" + */ + case PduHeaders.MESSAGE_ID: + case PduHeaders.REPLACE_ID: + case PduHeaders.CANCEL_ID: + /** + * The following field has a different value when + * used in the M-Mbox-Delete.conf and M-Delete.conf PDU. + * For now we ignore this fact, since we do not support these PDUs + */ + case PduHeaders.CONTENT_LOCATION: + { + byte[] value = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if (null != value) { + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: string: " + headerField + " value: " + + new String(value)); + } + headers.setTextString(value, headerField); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Text-String header field!"); + return null; + } + } + break; + } + + /* Encoded-string-value */ + case PduHeaders.SUBJECT: + case PduHeaders.RECOMMENDED_RETRIEVAL_MODE_TEXT: + case PduHeaders.RETRIEVE_TEXT: + case PduHeaders.STATUS_TEXT: + case PduHeaders.STORE_STATUS_TEXT: + /* the next one is not support + * M-Mbox-Delete.conf and M-Delete.conf now */ + case PduHeaders.RESPONSE_TEXT: + { + EncodedStringValue value = + parseEncodedStringValue(pduDataStream); + if (null != value) { + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: encoded string: " + headerField + + " value: " + value.getString()); + } + headers.setEncodedStringValue(value, headerField); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch (RuntimeException e) { + log(headerField + "is not Encoded-String-Value header field!"); + return null; + } + } + break; + } + + /* Addressing model */ + case PduHeaders.BCC: + case PduHeaders.CC: + case PduHeaders.TO: + { + EncodedStringValue value = + parseEncodedStringValue(pduDataStream); + if (null != value) { + byte[] address = value.getTextString(); + if (null != address) { + String str = new String(address); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: (to/cc/bcc) address: " + headerField + + " value: " + str); + } + int endIndex = str.indexOf("/"); + if (endIndex > 0) { + str = str.substring(0, endIndex); + } + try { + value.setTextString(str.getBytes()); + } catch(NullPointerException e) { + log("null pointer error!"); + return null; + } + } + + try { + headers.appendEncodedStringValue(value, headerField); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Encoded-String-Value header field!"); + return null; + } + } + break; + } + + /* Value-length + * (Absolute-token Date-value | Relative-token Delta-seconds-value) */ + case PduHeaders.DELIVERY_TIME: + case PduHeaders.EXPIRY: + case PduHeaders.REPLY_CHARGING_DEADLINE: + { + /* parse Value-length */ + parseValueLength(pduDataStream); + + /* Absolute-token or Relative-token */ + int token = extractByteValue(pduDataStream); + + /* Date-value or Delta-seconds-value */ + long timeValue; + try { + timeValue = parseLongInteger(pduDataStream); + } catch(RuntimeException e) { + log(headerField + "is not Long-Integer header field!"); + return null; + } + if (PduHeaders.VALUE_RELATIVE_TOKEN == token) { + /* need to convert the Delta-seconds-value + * into Date-value */ + timeValue = System.currentTimeMillis()/1000 + timeValue; + } + + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: time value: " + headerField + + " value: " + timeValue); + } + headers.setLongInteger(timeValue, headerField); + } catch(RuntimeException e) { + log(headerField + "is not Long-Integer header field!"); + return null; + } + break; + } + + case PduHeaders.FROM: { + /* From-value = + * Value-length + * (Address-present-token Encoded-string-value | Insert-address-token) + */ + EncodedStringValue from = null; + parseValueLength(pduDataStream); /* parse value-length */ + + /* Address-present-token or Insert-address-token */ + int fromToken = extractByteValue(pduDataStream); + + /* Address-present-token or Insert-address-token */ + if (PduHeaders.FROM_ADDRESS_PRESENT_TOKEN == fromToken) { + /* Encoded-string-value */ + from = parseEncodedStringValue(pduDataStream); + if (null != from) { + byte[] address = from.getTextString(); + if (null != address) { + String str = new String(address); + int endIndex = str.indexOf("/"); + if (endIndex > 0) { + str = str.substring(0, endIndex); + } + try { + from.setTextString(str.getBytes()); + } catch(NullPointerException e) { + log("null pointer error!"); + return null; + } + } + } + } else { + try { + from = new EncodedStringValue( + PduHeaders.FROM_INSERT_ADDRESS_TOKEN_STR.getBytes()); + } catch(NullPointerException e) { + log(headerField + "is not Encoded-String-Value header field!"); + return null; + } + } + + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: from address: " + headerField + + " value: " + from.getString()); + } + headers.setEncodedStringValue(from, PduHeaders.FROM); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Encoded-String-Value header field!"); + return null; + } + break; + } + + case PduHeaders.MESSAGE_CLASS: { + /* Message-class-value = Class-identifier | Token-text */ + pduDataStream.mark(1); + int messageClass = extractByteValue(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: MESSAGE_CLASS: " + headerField + + " value: " + messageClass); + } + + if (messageClass >= PduHeaders.MESSAGE_CLASS_PERSONAL) { + /* Class-identifier */ + try { + if (PduHeaders.MESSAGE_CLASS_PERSONAL == messageClass) { + headers.setTextString( + PduHeaders.MESSAGE_CLASS_PERSONAL_STR.getBytes(), + PduHeaders.MESSAGE_CLASS); + } else if (PduHeaders.MESSAGE_CLASS_ADVERTISEMENT == messageClass) { + headers.setTextString( + PduHeaders.MESSAGE_CLASS_ADVERTISEMENT_STR.getBytes(), + PduHeaders.MESSAGE_CLASS); + } else if (PduHeaders.MESSAGE_CLASS_INFORMATIONAL == messageClass) { + headers.setTextString( + PduHeaders.MESSAGE_CLASS_INFORMATIONAL_STR.getBytes(), + PduHeaders.MESSAGE_CLASS); + } else if (PduHeaders.MESSAGE_CLASS_AUTO == messageClass) { + headers.setTextString( + PduHeaders.MESSAGE_CLASS_AUTO_STR.getBytes(), + PduHeaders.MESSAGE_CLASS); + } + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Text-String header field!"); + return null; + } + } else { + /* Token-text */ + pduDataStream.reset(); + byte[] messageClassString = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if (null != messageClassString) { + try { + headers.setTextString(messageClassString, PduHeaders.MESSAGE_CLASS); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Text-String header field!"); + return null; + } + } + } + break; + } + + case PduHeaders.MMS_VERSION: { + int version = parseShortInteger(pduDataStream); + + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: MMS_VERSION: " + headerField + + " value: " + version); + } + headers.setOctet(version, PduHeaders.MMS_VERSION); + } catch(InvalidHeaderValueException e) { + log("Set invalid Octet value: " + version + + " into the header filed: " + headerField); + return null; + } catch(RuntimeException e) { + log(headerField + "is not Octet header field!"); + return null; + } + break; + } + + case PduHeaders.PREVIOUSLY_SENT_BY: { + /* Previously-sent-by-value = + * Value-length Forwarded-count-value Encoded-string-value */ + /* parse value-length */ + parseValueLength(pduDataStream); + + /* parse Forwarded-count-value */ + try { + parseIntegerValue(pduDataStream); + } catch(RuntimeException e) { + log(headerField + " is not Integer-Value"); + return null; + } + + /* parse Encoded-string-value */ + EncodedStringValue previouslySentBy = + parseEncodedStringValue(pduDataStream); + if (null != previouslySentBy) { + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: PREVIOUSLY_SENT_BY: " + headerField + + " value: " + previouslySentBy.getString()); + } + headers.setEncodedStringValue(previouslySentBy, + PduHeaders.PREVIOUSLY_SENT_BY); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Encoded-String-Value header field!"); + return null; + } + } + break; + } + + case PduHeaders.PREVIOUSLY_SENT_DATE: { + /* Previously-sent-date-value = + * Value-length Forwarded-count-value Date-value */ + /* parse value-length */ + parseValueLength(pduDataStream); + + /* parse Forwarded-count-value */ + try { + parseIntegerValue(pduDataStream); + } catch(RuntimeException e) { + log(headerField + " is not Integer-Value"); + return null; + } + + /* Date-value */ + try { + long perviouslySentDate = parseLongInteger(pduDataStream); + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: PREVIOUSLY_SENT_DATE: " + headerField + + " value: " + perviouslySentDate); + } + headers.setLongInteger(perviouslySentDate, + PduHeaders.PREVIOUSLY_SENT_DATE); + } catch(RuntimeException e) { + log(headerField + "is not Long-Integer header field!"); + return null; + } + break; + } + + case PduHeaders.MM_FLAGS: { + /* MM-flags-value = + * Value-length + * ( Add-token | Remove-token | Filter-token ) + * Encoded-string-value + */ + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: MM_FLAGS: " + headerField + + " NOT REALLY SUPPORTED"); + } + + /* parse Value-length */ + parseValueLength(pduDataStream); + + /* Add-token | Remove-token | Filter-token */ + extractByteValue(pduDataStream); + + /* Encoded-string-value */ + parseEncodedStringValue(pduDataStream); + + /* not store this header filed in "headers", + * because now PduHeaders doesn't support it */ + break; + } + + /* Value-length + * (Message-total-token | Size-total-token) Integer-Value */ + case PduHeaders.MBOX_TOTALS: + case PduHeaders.MBOX_QUOTAS: + { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: MBOX_TOTALS: " + headerField); + } + /* Value-length */ + parseValueLength(pduDataStream); + + /* Message-total-token | Size-total-token */ + extractByteValue(pduDataStream); + + /*Integer-Value*/ + try { + parseIntegerValue(pduDataStream); + } catch(RuntimeException e) { + log(headerField + " is not Integer-Value"); + return null; + } + + /* not store these headers filed in "headers", + because now PduHeaders doesn't support them */ + break; + } + + case PduHeaders.ELEMENT_DESCRIPTOR: { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: ELEMENT_DESCRIPTOR: " + headerField); + } + parseContentType(pduDataStream, null); + + /* not store this header filed in "headers", + because now PduHeaders doesn't support it */ + break; + } + + case PduHeaders.CONTENT_TYPE: { + HashMap<Integer, Object> map = + new HashMap<Integer, Object>(); + byte[] contentType = + parseContentType(pduDataStream, map); + + if (null != contentType) { + try { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: CONTENT_TYPE: " + headerField + + Arrays.toString(contentType)); + } + headers.setTextString(contentType, PduHeaders.CONTENT_TYPE); + } catch(NullPointerException e) { + log("null pointer error!"); + } catch(RuntimeException e) { + log(headerField + "is not Text-String header field!"); + return null; + } + } + + /* get start parameter */ + mStartParam = (byte[]) map.get(PduPart.P_START); + + /* get charset parameter */ + mTypeParam= (byte[]) map.get(PduPart.P_TYPE); + + keepParsing = false; + break; + } + + case PduHeaders.CONTENT: + case PduHeaders.ADDITIONAL_HEADERS: + case PduHeaders.ATTRIBUTES: + default: { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "parseHeaders: Unknown header: " + headerField); + } + log("Unknown header"); + } + } + } + + return headers; + } + + /** + * Parse pdu parts. + * + * @param pduDataStream pdu data input stream + * @return parts in PduBody structure + */ + protected PduBody parseParts(ByteArrayInputStream pduDataStream) { + if (pduDataStream == null) { + return null; + } + + int count = parseUnsignedInt(pduDataStream); // get the number of parts + PduBody body = new PduBody(); + + for (int i = 0 ; i < count ; i++) { + int headerLength = parseUnsignedInt(pduDataStream); + int dataLength = parseUnsignedInt(pduDataStream); + PduPart part = new PduPart(); + int startPos = pduDataStream.available(); + if (startPos <= 0) { + // Invalid part. + return null; + } + + /* parse part's content-type */ + HashMap<Integer, Object> map = new HashMap<Integer, Object>(); + byte[] contentType = parseContentType(pduDataStream, map); + if (null != contentType) { + part.setContentType(contentType); + } else { + part.setContentType((PduContentTypes.contentTypes[0]).getBytes()); //"*/*" + } + + /* get name parameter */ + byte[] name = (byte[]) map.get(PduPart.P_NAME); + if (null != name) { + part.setName(name); + } + + /* get charset parameter */ + Integer charset = (Integer) map.get(PduPart.P_CHARSET); + if (null != charset) { + part.setCharset(charset); + } + + /* parse part's headers */ + int endPos = pduDataStream.available(); + int partHeaderLen = headerLength - (startPos - endPos); + if (partHeaderLen > 0) { + if (false == parsePartHeaders(pduDataStream, part, partHeaderLen)) { + // Parse part header faild. + return null; + } + } else if (partHeaderLen < 0) { + // Invalid length of content-type. + return null; + } + + /* FIXME: check content-id, name, filename and content location, + * if not set anyone of them, generate a default content-location + */ + if ((null == part.getContentLocation()) + && (null == part.getName()) + && (null == part.getFilename()) + && (null == part.getContentId())) { + part.setContentLocation(Long.toOctalString( + System.currentTimeMillis()).getBytes()); + } + + /* get part's data */ + if (dataLength > 0) { + byte[] partData = new byte[dataLength]; + String partContentType = new String(part.getContentType()); + pduDataStream.read(partData, 0, dataLength); + if (partContentType.equalsIgnoreCase(ContentType.MULTIPART_ALTERNATIVE)) { + // parse "multipart/vnd.wap.multipart.alternative". + PduBody childBody = parseParts(new ByteArrayInputStream(partData)); + // take the first part of children. + part = childBody.getPart(0); + } else { + // Check Content-Transfer-Encoding. + byte[] partDataEncoding = part.getContentTransferEncoding(); + if (null != partDataEncoding) { + String encoding = new String(partDataEncoding); + if (encoding.equalsIgnoreCase(PduPart.P_BASE64)) { + // Decode "base64" into "binary". + partData = Base64.decodeBase64(partData); + } else if (encoding.equalsIgnoreCase(PduPart.P_QUOTED_PRINTABLE)) { + // Decode "quoted-printable" into "binary". + partData = QuotedPrintable.decodeQuotedPrintable(partData); + } else { + // "binary" is the default encoding. + } + } + if (null == partData) { + log("Decode part data error!"); + return null; + } + part.setData(partData); + } + } + + /* add this part to body */ + if (THE_FIRST_PART == checkPartPosition(part)) { + /* this is the first part */ + body.addPart(0, part); + } else { + /* add the part to the end */ + body.addPart(part); + } + } + + return body; + } + + /** + * Log status. + * + * @param text log information + */ + private static void log(String text) { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, text); + } + } + + /** + * Parse unsigned integer. + * + * @param pduDataStream pdu data input stream + * @return the integer, -1 when failed + */ + protected static int parseUnsignedInt(ByteArrayInputStream pduDataStream) { + /** + * From wap-230-wsp-20010705-a.pdf + * The maximum size of a uintvar is 32 bits. + * So it will be encoded in no more than 5 octets. + */ + assert(null != pduDataStream); + int result = 0; + int temp = pduDataStream.read(); + if (temp == -1) { + return temp; + } + + while((temp & 0x80) != 0) { + result = result << 7; + result |= temp & 0x7F; + temp = pduDataStream.read(); + if (temp == -1) { + return temp; + } + } + + result = result << 7; + result |= temp & 0x7F; + + return result; + } + + /** + * Parse value length. + * + * @param pduDataStream pdu data input stream + * @return the integer + */ + protected static int parseValueLength(ByteArrayInputStream pduDataStream) { + /** + * From wap-230-wsp-20010705-a.pdf + * Value-length = Short-length | (Length-quote Length) + * Short-length = <Any octet 0-30> + * Length-quote = <Octet 31> + * Length = Uintvar-integer + * Uintvar-integer = 1*5 OCTET + */ + assert(null != pduDataStream); + int temp = pduDataStream.read(); + assert(-1 != temp); + int first = temp & 0xFF; + + if (first <= SHORT_LENGTH_MAX) { + return first; + } else if (first == LENGTH_QUOTE) { + return parseUnsignedInt(pduDataStream); + } + + throw new RuntimeException("Value length > LENGTH_QUOTE!"); + } + + /** + * Parse encoded string value. + * + * @param pduDataStream pdu data input stream + * @return the EncodedStringValue + */ + protected static EncodedStringValue parseEncodedStringValue(ByteArrayInputStream pduDataStream){ + /** + * From OMA-TS-MMS-ENC-V1_3-20050927-C.pdf + * Encoded-string-value = Text-string | Value-length Char-set Text-string + */ + assert(null != pduDataStream); + pduDataStream.mark(1); + EncodedStringValue returnValue = null; + int charset = 0; + int temp = pduDataStream.read(); + assert(-1 != temp); + int first = temp & 0xFF; + if (first == 0) { + return new EncodedStringValue(""); + } + + pduDataStream.reset(); + if (first < TEXT_MIN) { + parseValueLength(pduDataStream); + + charset = parseShortInteger(pduDataStream); //get the "Charset" + } + + byte[] textString = parseWapString(pduDataStream, TYPE_TEXT_STRING); + + try { + if (0 != charset) { + returnValue = new EncodedStringValue(charset, textString); + } else { + returnValue = new EncodedStringValue(textString); + } + } catch(Exception e) { + return null; + } + + return returnValue; + } + + /** + * Parse Text-String or Quoted-String. + * + * @param pduDataStream pdu data input stream + * @param stringType TYPE_TEXT_STRING or TYPE_QUOTED_STRING + * @return the string without End-of-string in byte array + */ + protected static byte[] parseWapString(ByteArrayInputStream pduDataStream, + int stringType) { + assert(null != pduDataStream); + /** + * From wap-230-wsp-20010705-a.pdf + * Text-string = [Quote] *TEXT End-of-string + * If the first character in the TEXT is in the range of 128-255, + * a Quote character must precede it. + * Otherwise the Quote character must be omitted. + * The Quote is not part of the contents. + * Quote = <Octet 127> + * End-of-string = <Octet 0> + * + * Quoted-string = <Octet 34> *TEXT End-of-string + * + * Token-text = Token End-of-string + */ + + // Mark supposed beginning of Text-string + // We will have to mark again if first char is QUOTE or QUOTED_STRING_FLAG + pduDataStream.mark(1); + + // Check first char + int temp = pduDataStream.read(); + assert(-1 != temp); + if ((TYPE_QUOTED_STRING == stringType) && + (QUOTED_STRING_FLAG == temp)) { + // Mark again if QUOTED_STRING_FLAG and ignore it + pduDataStream.mark(1); + } else if ((TYPE_TEXT_STRING == stringType) && + (QUOTE == temp)) { + // Mark again if QUOTE and ignore it + pduDataStream.mark(1); + } else { + // Otherwise go back to origin + pduDataStream.reset(); + } + + // We are now definitely at the beginning of string + /** + * Return *TOKEN or *TEXT (Text-String without QUOTE, + * Quoted-String without QUOTED_STRING_FLAG and without End-of-string) + */ + return getWapString(pduDataStream, stringType); + } + + /** + * Check TOKEN data defined in RFC2616. + * @param ch checking data + * @return true when ch is TOKEN, false when ch is not TOKEN + */ + protected static boolean isTokenCharacter(int ch) { + /** + * Token = 1*<any CHAR except CTLs or separators> + * separators = "("(40) | ")"(41) | "<"(60) | ">"(62) | "@"(64) + * | ","(44) | ";"(59) | ":"(58) | "\"(92) | <">(34) + * | "/"(47) | "["(91) | "]"(93) | "?"(63) | "="(61) + * | "{"(123) | "}"(125) | SP(32) | HT(9) + * CHAR = <any US-ASCII character (octets 0 - 127)> + * CTL = <any US-ASCII control character + * (octets 0 - 31) and DEL (127)> + * SP = <US-ASCII SP, space (32)> + * HT = <US-ASCII HT, horizontal-tab (9)> + */ + if((ch < 33) || (ch > 126)) { + return false; + } + + switch(ch) { + case '"': /* '"' */ + case '(': /* '(' */ + case ')': /* ')' */ + case ',': /* ',' */ + case '/': /* '/' */ + case ':': /* ':' */ + case ';': /* ';' */ + case '<': /* '<' */ + case '=': /* '=' */ + case '>': /* '>' */ + case '?': /* '?' */ + case '@': /* '@' */ + case '[': /* '[' */ + case '\\': /* '\' */ + case ']': /* ']' */ + case '{': /* '{' */ + case '}': /* '}' */ + return false; + } + + return true; + } + + /** + * Check TEXT data defined in RFC2616. + * @param ch checking data + * @return true when ch is TEXT, false when ch is not TEXT + */ + protected static boolean isText(int ch) { + /** + * TEXT = <any OCTET except CTLs, + * but including LWS> + * CTL = <any US-ASCII control character + * (octets 0 - 31) and DEL (127)> + * LWS = [CRLF] 1*( SP | HT ) + * CRLF = CR LF + * CR = <US-ASCII CR, carriage return (13)> + * LF = <US-ASCII LF, linefeed (10)> + */ + if(((ch >= 32) && (ch <= 126)) || ((ch >= 128) && (ch <= 255))) { + return true; + } + + switch(ch) { + case '\t': /* '\t' */ + case '\n': /* '\n' */ + case '\r': /* '\r' */ + return true; + } + + return false; + } + + protected static byte[] getWapString(ByteArrayInputStream pduDataStream, + int stringType) { + assert(null != pduDataStream); + ByteArrayOutputStream out = new ByteArrayOutputStream(); + int temp = pduDataStream.read(); + assert(-1 != temp); + while((-1 != temp) && ('\0' != temp)) { + // check each of the character + if (stringType == TYPE_TOKEN_STRING) { + if (isTokenCharacter(temp)) { + out.write(temp); + } + } else { + if (isText(temp)) { + out.write(temp); + } + } + + temp = pduDataStream.read(); + assert(-1 != temp); + } + + if (out.size() > 0) { + return out.toByteArray(); + } + + return null; + } + + /** + * Extract a byte value from the input stream. + * + * @param pduDataStream pdu data input stream + * @return the byte + */ + protected static int extractByteValue(ByteArrayInputStream pduDataStream) { + assert(null != pduDataStream); + int temp = pduDataStream.read(); + assert(-1 != temp); + return temp & 0xFF; + } + + /** + * Parse Short-Integer. + * + * @param pduDataStream pdu data input stream + * @return the byte + */ + protected static int parseShortInteger(ByteArrayInputStream pduDataStream) { + /** + * From wap-230-wsp-20010705-a.pdf + * Short-integer = OCTET + * Integers in range 0-127 shall be encoded as a one + * octet value with the most significant bit set to one (1xxx xxxx) + * and with the value in the remaining least significant bits. + */ + assert(null != pduDataStream); + int temp = pduDataStream.read(); + assert(-1 != temp); + return temp & 0x7F; + } + + /** + * Parse Long-Integer. + * + * @param pduDataStream pdu data input stream + * @return long integer + */ + protected static long parseLongInteger(ByteArrayInputStream pduDataStream) { + /** + * From wap-230-wsp-20010705-a.pdf + * Long-integer = Short-length Multi-octet-integer + * The Short-length indicates the length of the Multi-octet-integer + * Multi-octet-integer = 1*30 OCTET + * The content octets shall be an unsigned integer value + * with the most significant octet encoded first (big-endian representation). + * The minimum number of octets must be used to encode the value. + * Short-length = <Any octet 0-30> + */ + assert(null != pduDataStream); + int temp = pduDataStream.read(); + assert(-1 != temp); + int count = temp & 0xFF; + + if (count > LONG_INTEGER_LENGTH_MAX) { + throw new RuntimeException("Octet count greater than 8 and I can't represent that!"); + } + + long result = 0; + + for (int i = 0 ; i < count ; i++) { + temp = pduDataStream.read(); + assert(-1 != temp); + result <<= 8; + result += (temp & 0xFF); + } + + return result; + } + + /** + * Parse Integer-Value. + * + * @param pduDataStream pdu data input stream + * @return long integer + */ + protected static long parseIntegerValue(ByteArrayInputStream pduDataStream) { + /** + * From wap-230-wsp-20010705-a.pdf + * Integer-Value = Short-integer | Long-integer + */ + assert(null != pduDataStream); + pduDataStream.mark(1); + int temp = pduDataStream.read(); + assert(-1 != temp); + pduDataStream.reset(); + if (temp > SHORT_INTEGER_MAX) { + return parseShortInteger(pduDataStream); + } else { + return parseLongInteger(pduDataStream); + } + } + + /** + * To skip length of the wap value. + * + * @param pduDataStream pdu data input stream + * @param length area size + * @return the values in this area + */ + protected static int skipWapValue(ByteArrayInputStream pduDataStream, int length) { + assert(null != pduDataStream); + byte[] area = new byte[length]; + int readLen = pduDataStream.read(area, 0, length); + if (readLen < length) { //The actually read length is lower than the length + return -1; + } else { + return readLen; + } + } + + /** + * Parse content type parameters. For now we just support + * four parameters used in mms: "type", "start", "name", "charset". + * + * @param pduDataStream pdu data input stream + * @param map to store parameters of Content-Type field + * @param length length of all the parameters + */ + protected static void parseContentTypeParams(ByteArrayInputStream pduDataStream, + HashMap<Integer, Object> map, Integer length) { + /** + * From wap-230-wsp-20010705-a.pdf + * Parameter = Typed-parameter | Untyped-parameter + * Typed-parameter = Well-known-parameter-token Typed-value + * the actual expected type of the value is implied by the well-known parameter + * Well-known-parameter-token = Integer-value + * the code values used for parameters are specified in the Assigned Numbers appendix + * Typed-value = Compact-value | Text-value + * In addition to the expected type, there may be no value. + * If the value cannot be encoded using the expected type, it shall be encoded as text. + * Compact-value = Integer-value | + * Date-value | Delta-seconds-value | Q-value | Version-value | + * Uri-value + * Untyped-parameter = Token-text Untyped-value + * the type of the value is unknown, but it shall be encoded as an integer, + * if that is possible. + * Untyped-value = Integer-value | Text-value + */ + assert(null != pduDataStream); + assert(length > 0); + + int startPos = pduDataStream.available(); + int tempPos = 0; + int lastLen = length; + while(0 < lastLen) { + int param = pduDataStream.read(); + assert(-1 != param); + lastLen--; + + switch (param) { + /** + * From rfc2387, chapter 3.1 + * The type parameter must be specified and its value is the MIME media + * type of the "root" body part. It permits a MIME user agent to + * determine the content-type without reference to the enclosed body + * part. If the value of the type parameter and the root body part's + * content-type differ then the User Agent's behavior is undefined. + * + * From wap-230-wsp-20010705-a.pdf + * type = Constrained-encoding + * Constrained-encoding = Extension-Media | Short-integer + * Extension-media = *TEXT End-of-string + */ + case PduPart.P_TYPE: + case PduPart.P_CT_MR_TYPE: + pduDataStream.mark(1); + int first = extractByteValue(pduDataStream); + pduDataStream.reset(); + if (first > TEXT_MAX) { + // Short-integer (well-known type) + int index = parseShortInteger(pduDataStream); + + if (index < PduContentTypes.contentTypes.length) { + byte[] type = (PduContentTypes.contentTypes[index]).getBytes(); + map.put(PduPart.P_TYPE, type); + } else { + //not support this type, ignore it. + } + } else { + // Text-String (extension-media) + byte[] type = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if ((null != type) && (null != map)) { + map.put(PduPart.P_TYPE, type); + } + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + + /** + * From oma-ts-mms-conf-v1_3.pdf, chapter 10.2.3. + * Start Parameter Referring to Presentation + * + * From rfc2387, chapter 3.2 + * The start parameter, if given, is the content-ID of the compound + * object's "root". If not present the "root" is the first body part in + * the Multipart/Related entity. The "root" is the element the + * applications processes first. + * + * From wap-230-wsp-20010705-a.pdf + * start = Text-String + */ + case PduPart.P_START: + case PduPart.P_DEP_START: + byte[] start = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if ((null != start) && (null != map)) { + map.put(PduPart.P_START, start); + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + + /** + * From oma-ts-mms-conf-v1_3.pdf + * In creation, the character set SHALL be either us-ascii + * (IANA MIBenum 3) or utf-8 (IANA MIBenum 106)[Unicode]. + * In retrieval, both us-ascii and utf-8 SHALL be supported. + * + * From wap-230-wsp-20010705-a.pdf + * charset = Well-known-charset|Text-String + * Well-known-charset = Any-charset | Integer-value + * Both are encoded using values from Character Set + * Assignments table in Assigned Numbers + * Any-charset = <Octet 128> + * Equivalent to the special RFC2616 charset value "*" + */ + case PduPart.P_CHARSET: + pduDataStream.mark(1); + int firstValue = extractByteValue(pduDataStream); + pduDataStream.reset(); + //Check first char + if (((firstValue > TEXT_MIN) && (firstValue < TEXT_MAX)) || + (END_STRING_FLAG == firstValue)) { + //Text-String (extension-charset) + byte[] charsetStr = parseWapString(pduDataStream, TYPE_TEXT_STRING); + try { + int charsetInt = CharacterSets.getMibEnumValue( + new String(charsetStr)); + map.put(PduPart.P_CHARSET, charsetInt); + } catch (UnsupportedEncodingException e) { + // Not a well-known charset, use "*". + Log.e(LOG_TAG, Arrays.toString(charsetStr), e); + map.put(PduPart.P_CHARSET, CharacterSets.ANY_CHARSET); + } + } else { + //Well-known-charset + int charset = (int) parseIntegerValue(pduDataStream); + if (map != null) { + map.put(PduPart.P_CHARSET, charset); + } + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + + /** + * From oma-ts-mms-conf-v1_3.pdf + * A name for multipart object SHALL be encoded using name-parameter + * for Content-Type header in WSP multipart headers. + * + * From wap-230-wsp-20010705-a.pdf + * name = Text-String + */ + case PduPart.P_DEP_NAME: + case PduPart.P_NAME: + byte[] name = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if ((null != name) && (null != map)) { + map.put(PduPart.P_NAME, name); + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + default: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "Not supported Content-Type parameter"); + } + if (-1 == skipWapValue(pduDataStream, lastLen)) { + Log.e(LOG_TAG, "Corrupt Content-Type"); + } else { + lastLen = 0; + } + break; + } + } + + if (0 != lastLen) { + Log.e(LOG_TAG, "Corrupt Content-Type"); + } + } + + /** + * Parse content type. + * + * @param pduDataStream pdu data input stream + * @param map to store parameters in Content-Type header field + * @return Content-Type value + */ + protected static byte[] parseContentType(ByteArrayInputStream pduDataStream, + HashMap<Integer, Object> map) { + /** + * From wap-230-wsp-20010705-a.pdf + * Content-type-value = Constrained-media | Content-general-form + * Content-general-form = Value-length Media-type + * Media-type = (Well-known-media | Extension-Media) *(Parameter) + */ + assert(null != pduDataStream); + + byte[] contentType = null; + pduDataStream.mark(1); + int temp = pduDataStream.read(); + assert(-1 != temp); + pduDataStream.reset(); + + int cur = (temp & 0xFF); + + if (cur < TEXT_MIN) { + int length = parseValueLength(pduDataStream); + int startPos = pduDataStream.available(); + pduDataStream.mark(1); + temp = pduDataStream.read(); + assert(-1 != temp); + pduDataStream.reset(); + int first = (temp & 0xFF); + + if ((first >= TEXT_MIN) && (first <= TEXT_MAX)) { + contentType = parseWapString(pduDataStream, TYPE_TEXT_STRING); + } else if (first > TEXT_MAX) { + int index = parseShortInteger(pduDataStream); + + if (index < PduContentTypes.contentTypes.length) { //well-known type + contentType = (PduContentTypes.contentTypes[index]).getBytes(); + } else { + pduDataStream.reset(); + contentType = parseWapString(pduDataStream, TYPE_TEXT_STRING); + } + } else { + Log.e(LOG_TAG, "Corrupt content-type"); + return (PduContentTypes.contentTypes[0]).getBytes(); //"*/*" + } + + int endPos = pduDataStream.available(); + int parameterLen = length - (startPos - endPos); + if (parameterLen > 0) {//have parameters + parseContentTypeParams(pduDataStream, map, parameterLen); + } + + if (parameterLen < 0) { + Log.e(LOG_TAG, "Corrupt MMS message"); + return (PduContentTypes.contentTypes[0]).getBytes(); //"*/*" + } + } else if (cur <= TEXT_MAX) { + contentType = parseWapString(pduDataStream, TYPE_TEXT_STRING); + } else { + contentType = + (PduContentTypes.contentTypes[parseShortInteger(pduDataStream)]).getBytes(); + } + + return contentType; + } + + /** + * Parse part's headers. + * + * @param pduDataStream pdu data input stream + * @param part to store the header informations of the part + * @param length length of the headers + * @return true if parse successfully, false otherwise + */ + protected boolean parsePartHeaders(ByteArrayInputStream pduDataStream, + PduPart part, int length) { + assert(null != pduDataStream); + assert(null != part); + assert(length > 0); + + /** + * From oma-ts-mms-conf-v1_3.pdf, chapter 10.2. + * A name for multipart object SHALL be encoded using name-parameter + * for Content-Type header in WSP multipart headers. + * In decoding, name-parameter of Content-Type SHALL be used if available. + * If name-parameter of Content-Type is not available, + * filename parameter of Content-Disposition header SHALL be used if available. + * If neither name-parameter of Content-Type header nor filename parameter + * of Content-Disposition header is available, + * Content-Location header SHALL be used if available. + * + * Within SMIL part the reference to the media object parts SHALL use + * either Content-ID or Content-Location mechanism [RFC2557] + * and the corresponding WSP part headers in media object parts + * contain the corresponding definitions. + */ + int startPos = pduDataStream.available(); + int tempPos = 0; + int lastLen = length; + while(0 < lastLen) { + int header = pduDataStream.read(); + assert(-1 != header); + lastLen--; + + if (header > TEXT_MAX) { + // Number assigned headers. + switch (header) { + case PduPart.P_CONTENT_LOCATION: + /** + * From wap-230-wsp-20010705-a.pdf, chapter 8.4.2.21 + * Content-location-value = Uri-value + */ + byte[] contentLocation = parseWapString(pduDataStream, TYPE_TEXT_STRING); + if (null != contentLocation) { + part.setContentLocation(contentLocation); + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + case PduPart.P_CONTENT_ID: + /** + * From wap-230-wsp-20010705-a.pdf, chapter 8.4.2.21 + * Content-ID-value = Quoted-string + */ + byte[] contentId = parseWapString(pduDataStream, TYPE_QUOTED_STRING); + if (null != contentId) { + part.setContentId(contentId); + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + break; + case PduPart.P_DEP_CONTENT_DISPOSITION: + case PduPart.P_CONTENT_DISPOSITION: + /** + * From wap-230-wsp-20010705-a.pdf, chapter 8.4.2.21 + * Content-disposition-value = Value-length Disposition *(Parameter) + * Disposition = Form-data | Attachment | Inline | Token-text + * Form-data = <Octet 128> + * Attachment = <Octet 129> + * Inline = <Octet 130> + */ + + /* + * some carrier mmsc servers do not support content_disposition + * field correctly + */ + if (mParseContentDisposition) { + int len = parseValueLength(pduDataStream); + pduDataStream.mark(1); + int thisStartPos = pduDataStream.available(); + int thisEndPos = 0; + int value = pduDataStream.read(); + + if (value == PduPart.P_DISPOSITION_FROM_DATA ) { + part.setContentDisposition(PduPart.DISPOSITION_FROM_DATA); + } else if (value == PduPart.P_DISPOSITION_ATTACHMENT) { + part.setContentDisposition(PduPart.DISPOSITION_ATTACHMENT); + } else if (value == PduPart.P_DISPOSITION_INLINE) { + part.setContentDisposition(PduPart.DISPOSITION_INLINE); + } else { + pduDataStream.reset(); + /* Token-text */ + part.setContentDisposition(parseWapString(pduDataStream + , TYPE_TEXT_STRING)); + } + + /* get filename parameter and skip other parameters */ + thisEndPos = pduDataStream.available(); + if (thisStartPos - thisEndPos < len) { + value = pduDataStream.read(); + if (value == PduPart.P_FILENAME) { //filename is text-string + part.setFilename(parseWapString(pduDataStream + , TYPE_TEXT_STRING)); + } + + /* skip other parameters */ + thisEndPos = pduDataStream.available(); + if (thisStartPos - thisEndPos < len) { + int last = len - (thisStartPos - thisEndPos); + byte[] temp = new byte[last]; + pduDataStream.read(temp, 0, last); + } + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + } + break; + default: + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "Not supported Part headers: " + header); + } + if (-1 == skipWapValue(pduDataStream, lastLen)) { + Log.e(LOG_TAG, "Corrupt Part headers"); + return false; + } + lastLen = 0; + break; + } + } else if ((header >= TEXT_MIN) && (header <= TEXT_MAX)) { + // Not assigned header. + byte[] tempHeader = parseWapString(pduDataStream, TYPE_TEXT_STRING); + byte[] tempValue = parseWapString(pduDataStream, TYPE_TEXT_STRING); + + // Check the header whether it is "Content-Transfer-Encoding". + if (true == + PduPart.CONTENT_TRANSFER_ENCODING.equalsIgnoreCase(new String(tempHeader))) { + part.setContentTransferEncoding(tempValue); + } + + tempPos = pduDataStream.available(); + lastLen = length - (startPos - tempPos); + } else { + if (LOCAL_LOGV) { + Log.v(LOG_TAG, "Not supported Part headers: " + header); + } + // Skip all headers of this part. + if (-1 == skipWapValue(pduDataStream, lastLen)) { + Log.e(LOG_TAG, "Corrupt Part headers"); + return false; + } + lastLen = 0; + } + } + + if (0 != lastLen) { + Log.e(LOG_TAG, "Corrupt Part headers"); + return false; + } + + return true; + } + + /** + * Check the position of a specified part. + * + * @param part the part to be checked + * @return part position, THE_FIRST_PART when it's the + * first one, THE_LAST_PART when it's the last one. + */ + private static int checkPartPosition(PduPart part) { + assert(null != part); + if ((null == mTypeParam) && + (null == mStartParam)) { + return THE_LAST_PART; + } + + /* check part's content-id */ + if (null != mStartParam) { + byte[] contentId = part.getContentId(); + if (null != contentId) { + if (true == Arrays.equals(mStartParam, contentId)) { + return THE_FIRST_PART; + } + } + // This is not the first part, so append to end (keeping the original order) + // Check b/19607294 for details of this change + return THE_LAST_PART; + } + + /* check part's content-type */ + if (null != mTypeParam) { + byte[] contentType = part.getContentType(); + if (null != contentType) { + if (true == Arrays.equals(mTypeParam, contentType)) { + return THE_FIRST_PART; + } + } + } + + return THE_LAST_PART; + } + + /** + * Check mandatory headers of a pdu. + * + * @param headers pdu headers + * @return true if the pdu has all of the mandatory headers, false otherwise. + */ + protected static boolean checkMandatoryHeader(PduHeaders headers) { + if (null == headers) { + return false; + } + + /* get message type */ + int messageType = headers.getOctet(PduHeaders.MESSAGE_TYPE); + + /* check Mms-Version field */ + int mmsVersion = headers.getOctet(PduHeaders.MMS_VERSION); + if (0 == mmsVersion) { + // Every message should have Mms-Version field. + return false; + } + + /* check mandatory header fields */ + switch (messageType) { + case PduHeaders.MESSAGE_TYPE_SEND_REQ: + // Content-Type field. + byte[] srContentType = headers.getTextString(PduHeaders.CONTENT_TYPE); + if (null == srContentType) { + return false; + } + + // From field. + EncodedStringValue srFrom = headers.getEncodedStringValue(PduHeaders.FROM); + if (null == srFrom) { + return false; + } + + // Transaction-Id field. + byte[] srTransactionId = headers.getTextString(PduHeaders.TRANSACTION_ID); + if (null == srTransactionId) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_SEND_CONF: + // Response-Status field. + int scResponseStatus = headers.getOctet(PduHeaders.RESPONSE_STATUS); + if (0 == scResponseStatus) { + return false; + } + + // Transaction-Id field. + byte[] scTransactionId = headers.getTextString(PduHeaders.TRANSACTION_ID); + if (null == scTransactionId) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND: + // Content-Location field. + byte[] niContentLocation = headers.getTextString(PduHeaders.CONTENT_LOCATION); + if (null == niContentLocation) { + return false; + } + + // Expiry field. + long niExpiry = headers.getLongInteger(PduHeaders.EXPIRY); + if (-1 == niExpiry) { + return false; + } + + // Message-Class field. + byte[] niMessageClass = headers.getTextString(PduHeaders.MESSAGE_CLASS); + if (null == niMessageClass) { + return false; + } + + // Message-Size field. + long niMessageSize = headers.getLongInteger(PduHeaders.MESSAGE_SIZE); + if (-1 == niMessageSize) { + return false; + } + + // Transaction-Id field. + byte[] niTransactionId = headers.getTextString(PduHeaders.TRANSACTION_ID); + if (null == niTransactionId) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_NOTIFYRESP_IND: + // Status field. + int nriStatus = headers.getOctet(PduHeaders.STATUS); + if (0 == nriStatus) { + return false; + } + + // Transaction-Id field. + byte[] nriTransactionId = headers.getTextString(PduHeaders.TRANSACTION_ID); + if (null == nriTransactionId) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF: + // Content-Type field. + byte[] rcContentType = headers.getTextString(PduHeaders.CONTENT_TYPE); + if (null == rcContentType) { + return false; + } + + // Date field. + long rcDate = headers.getLongInteger(PduHeaders.DATE); + if (-1 == rcDate) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_DELIVERY_IND: + // Date field. + long diDate = headers.getLongInteger(PduHeaders.DATE); + if (-1 == diDate) { + return false; + } + + // Message-Id field. + byte[] diMessageId = headers.getTextString(PduHeaders.MESSAGE_ID); + if (null == diMessageId) { + return false; + } + + // Status field. + int diStatus = headers.getOctet(PduHeaders.STATUS); + if (0 == diStatus) { + return false; + } + + // To field. + EncodedStringValue[] diTo = headers.getEncodedStringValues(PduHeaders.TO); + if (null == diTo) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_ACKNOWLEDGE_IND: + // Transaction-Id field. + byte[] aiTransactionId = headers.getTextString(PduHeaders.TRANSACTION_ID); + if (null == aiTransactionId) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_READ_ORIG_IND: + // Date field. + long roDate = headers.getLongInteger(PduHeaders.DATE); + if (-1 == roDate) { + return false; + } + + // From field. + EncodedStringValue roFrom = headers.getEncodedStringValue(PduHeaders.FROM); + if (null == roFrom) { + return false; + } + + // Message-Id field. + byte[] roMessageId = headers.getTextString(PduHeaders.MESSAGE_ID); + if (null == roMessageId) { + return false; + } + + // Read-Status field. + int roReadStatus = headers.getOctet(PduHeaders.READ_STATUS); + if (0 == roReadStatus) { + return false; + } + + // To field. + EncodedStringValue[] roTo = headers.getEncodedStringValues(PduHeaders.TO); + if (null == roTo) { + return false; + } + + break; + case PduHeaders.MESSAGE_TYPE_READ_REC_IND: + // From field. + EncodedStringValue rrFrom = headers.getEncodedStringValue(PduHeaders.FROM); + if (null == rrFrom) { + return false; + } + + // Message-Id field. + byte[] rrMessageId = headers.getTextString(PduHeaders.MESSAGE_ID); + if (null == rrMessageId) { + return false; + } + + // Read-Status field. + int rrReadStatus = headers.getOctet(PduHeaders.READ_STATUS); + if (0 == rrReadStatus) { + return false; + } + + // To field. + EncodedStringValue[] rrTo = headers.getEncodedStringValues(PduHeaders.TO); + if (null == rrTo) { + return false; + } + + break; + default: + // Parser doesn't support this message type in this version. + return false; + } + + return true; + } +} diff --git a/src/android/support/v7/mms/pdu/PduPart.java b/src/android/support/v7/mms/pdu/PduPart.java new file mode 100644 index 0000000..ec8e1a2 --- /dev/null +++ b/src/android/support/v7/mms/pdu/PduPart.java @@ -0,0 +1,414 @@ +/* + * Copyright (C) 2007-2008 Esmertec AG. + * Copyright (C) 2007-2008 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 android.support.v7.mms.pdu; + +import android.net.Uri; + +import java.util.HashMap; +import java.util.Map; + +/** + * The pdu part. + */ +public class PduPart { + /** + * Well-Known Parameters. + */ + public static final int P_Q = 0x80; + public static final int P_CHARSET = 0x81; + public static final int P_LEVEL = 0x82; + public static final int P_TYPE = 0x83; + public static final int P_DEP_NAME = 0x85; + public static final int P_DEP_FILENAME = 0x86; + public static final int P_DIFFERENCES = 0x87; + public static final int P_PADDING = 0x88; + // This value of "TYPE" s used with Content-Type: multipart/related + public static final int P_CT_MR_TYPE = 0x89; + public static final int P_DEP_START = 0x8A; + public static final int P_DEP_START_INFO = 0x8B; + public static final int P_DEP_COMMENT = 0x8C; + public static final int P_DEP_DOMAIN = 0x8D; + public static final int P_MAX_AGE = 0x8E; + public static final int P_DEP_PATH = 0x8F; + public static final int P_SECURE = 0x90; + public static final int P_SEC = 0x91; + public static final int P_MAC = 0x92; + public static final int P_CREATION_DATE = 0x93; + public static final int P_MODIFICATION_DATE = 0x94; + public static final int P_READ_DATE = 0x95; + public static final int P_SIZE = 0x96; + public static final int P_NAME = 0x97; + public static final int P_FILENAME = 0x98; + public static final int P_START = 0x99; + public static final int P_START_INFO = 0x9A; + public static final int P_COMMENT = 0x9B; + public static final int P_DOMAIN = 0x9C; + public static final int P_PATH = 0x9D; + + /** + * Header field names. + */ + public static final int P_CONTENT_TYPE = 0x91; + public static final int P_CONTENT_LOCATION = 0x8E; + public static final int P_CONTENT_ID = 0xC0; + public static final int P_DEP_CONTENT_DISPOSITION = 0xAE; + public static final int P_CONTENT_DISPOSITION = 0xC5; + // The next header is unassigned header, use reserved header(0x48) value. + public static final int P_CONTENT_TRANSFER_ENCODING = 0xC8; + + /** + * Content=Transfer-Encoding string. + */ + public static final String CONTENT_TRANSFER_ENCODING = + "Content-Transfer-Encoding"; + + /** + * Value of Content-Transfer-Encoding. + */ + public static final String P_BINARY = "binary"; + public static final String P_7BIT = "7bit"; + public static final String P_8BIT = "8bit"; + public static final String P_BASE64 = "base64"; + public static final String P_QUOTED_PRINTABLE = "quoted-printable"; + + /** + * Value of disposition can be set to PduPart when the value is octet in + * the PDU. + * "from-data" instead of Form-data<Octet 128>. + * "attachment" instead of Attachment<Octet 129>. + * "inline" instead of Inline<Octet 130>. + */ + static final byte[] DISPOSITION_FROM_DATA = "from-data".getBytes(); + static final byte[] DISPOSITION_ATTACHMENT = "attachment".getBytes(); + static final byte[] DISPOSITION_INLINE = "inline".getBytes(); + + /** + * Content-Disposition value. + */ + public static final int P_DISPOSITION_FROM_DATA = 0x80; + public static final int P_DISPOSITION_ATTACHMENT = 0x81; + public static final int P_DISPOSITION_INLINE = 0x82; + + /** + * Header of part. + */ + private Map<Integer, Object> mPartHeader = null; + + /** + * Data uri. + */ + private Uri mUri = null; + + /** + * Part data. + */ + private byte[] mPartData = null; + + private static final String TAG = "PduPart"; + + /** + * Empty Constructor. + */ + public PduPart() { + mPartHeader = new HashMap<Integer, Object>(); + } + + /** + * Set part data. The data are stored as byte array. + * + * @param data the data + */ + public void setData(byte[] data) { + if(data == null) { + return; + } + + mPartData = new byte[data.length]; + System.arraycopy(data, 0, mPartData, 0, data.length); + } + + /** + * @return A copy of the part data or null if the data wasn't set or + * the data is stored as Uri. + * @see #getDataUri + */ + public byte[] getData() { + if(mPartData == null) { + return null; + } + + byte[] byteArray = new byte[mPartData.length]; + System.arraycopy(mPartData, 0, byteArray, 0, mPartData.length); + return byteArray; + } + + /** + * @return The length of the data, if this object have data, else 0. + */ + public int getDataLength() { + if(mPartData != null){ + return mPartData.length; + } else { + return 0; + } + } + + + /** + * Set data uri. The data are stored as Uri. + * + * @param uri the uri + */ + public void setDataUri(Uri uri) { + mUri = uri; + } + + /** + * @return The Uri of the part data or null if the data wasn't set or + * the data is stored as byte array. + * @see #getData + */ + public Uri getDataUri() { + return mUri; + } + + /** + * Set Content-id value + * + * @param contentId the content-id value + * @throws NullPointerException if the value is null. + */ + public void setContentId(byte[] contentId) { + if((contentId == null) || (contentId.length == 0)) { + throw new IllegalArgumentException( + "Content-Id may not be null or empty."); + } + + if ((contentId.length > 1) + && ((char) contentId[0] == '<') + && ((char) contentId[contentId.length - 1] == '>')) { + mPartHeader.put(P_CONTENT_ID, contentId); + return; + } + + // Insert beginning '<' and trailing '>' for Content-Id. + byte[] buffer = new byte[contentId.length + 2]; + buffer[0] = (byte) (0xff & '<'); + buffer[buffer.length - 1] = (byte) (0xff & '>'); + System.arraycopy(contentId, 0, buffer, 1, contentId.length); + mPartHeader.put(P_CONTENT_ID, buffer); + } + + /** + * Get Content-id value. + * + * @return the value + */ + public byte[] getContentId() { + return (byte[]) mPartHeader.get(P_CONTENT_ID); + } + + /** + * Set Char-set value. + * + * @param charset the value + */ + public void setCharset(int charset) { + mPartHeader.put(P_CHARSET, charset); + } + + /** + * Get Char-set value + * + * @return the charset value. Return 0 if charset was not set. + */ + public int getCharset() { + Integer charset = (Integer) mPartHeader.get(P_CHARSET); + if(charset == null) { + return 0; + } else { + return charset.intValue(); + } + } + + /** + * Set Content-Location value. + * + * @param contentLocation the value + * @throws NullPointerException if the value is null. + */ + public void setContentLocation(byte[] contentLocation) { + if(contentLocation == null) { + throw new NullPointerException("null content-location"); + } + + mPartHeader.put(P_CONTENT_LOCATION, contentLocation); + } + + /** + * Get Content-Location value. + * + * @return the value + * return PduPart.disposition[0] instead of <Octet 128> (Form-data). + * return PduPart.disposition[1] instead of <Octet 129> (Attachment). + * return PduPart.disposition[2] instead of <Octet 130> (Inline). + */ + public byte[] getContentLocation() { + return (byte[]) mPartHeader.get(P_CONTENT_LOCATION); + } + + /** + * Set Content-Disposition value. + * Use PduPart.disposition[0] instead of <Octet 128> (Form-data). + * Use PduPart.disposition[1] instead of <Octet 129> (Attachment). + * Use PduPart.disposition[2] instead of <Octet 130> (Inline). + * + * @param contentDisposition the value + * @throws NullPointerException if the value is null. + */ + public void setContentDisposition(byte[] contentDisposition) { + if(contentDisposition == null) { + throw new NullPointerException("null content-disposition"); + } + + mPartHeader.put(P_CONTENT_DISPOSITION, contentDisposition); + } + + /** + * Get Content-Disposition value. + * + * @return the value + */ + public byte[] getContentDisposition() { + return (byte[]) mPartHeader.get(P_CONTENT_DISPOSITION); + } + + /** + * Set Content-Type value. + * + * @param contentType the content type + * @throws NullPointerException if the value is null. + */ + public void setContentType(byte[] contentType) { + if(contentType == null) { + throw new NullPointerException("null content-type"); + } + + mPartHeader.put(P_CONTENT_TYPE, contentType); + } + + /** + * Get Content-Type value of part. + * + * @return the value + */ + public byte[] getContentType() { + return (byte[]) mPartHeader.get(P_CONTENT_TYPE); + } + + /** + * Set Content-Transfer-Encoding value + * + * @param contentTransferEncoding the Content-Transfer-Encoding value + * @throws NullPointerException if the value is null. + */ + public void setContentTransferEncoding(byte[] contentTransferEncoding) { + if(contentTransferEncoding == null) { + throw new NullPointerException("null content-transfer-encoding"); + } + + mPartHeader.put(P_CONTENT_TRANSFER_ENCODING, contentTransferEncoding); + } + + /** + * Get Content-Transfer-Encoding value. + * + * @return the value + */ + public byte[] getContentTransferEncoding() { + return (byte[]) mPartHeader.get(P_CONTENT_TRANSFER_ENCODING); + } + + /** + * Set Content-type parameter: name. + * + * @param name the name value + * @throws NullPointerException if the value is null. + */ + public void setName(byte[] name) { + if(null == name) { + throw new NullPointerException("null content-id"); + } + + mPartHeader.put(P_NAME, name); + } + + /** + * Get content-type parameter: name. + * + * @return the name + */ + public byte[] getName() { + return (byte[]) mPartHeader.get(P_NAME); + } + + /** + * Get Content-disposition parameter: filename + * + * @param fileName the filename value + * @throws NullPointerException if the value is null. + */ + public void setFilename(byte[] fileName) { + if(null == fileName) { + throw new NullPointerException("null content-id"); + } + + mPartHeader.put(P_FILENAME, fileName); + } + + /** + * Set Content-disposition parameter: filename + * + * @return the filename + */ + public byte[] getFilename() { + return (byte[]) mPartHeader.get(P_FILENAME); + } + + public String generateLocation() { + // Assumption: At least one of the content-location / name / filename + // or content-id should be set. This is guaranteed by the PduParser + // for incoming messages and by MM composer for outgoing messages. + byte[] location = (byte[]) mPartHeader.get(P_NAME); + if(null == location) { + location = (byte[]) mPartHeader.get(P_FILENAME); + + if (null == location) { + location = (byte[]) mPartHeader.get(P_CONTENT_LOCATION); + } + } + + if (null == location) { + byte[] contentId = (byte[]) mPartHeader.get(P_CONTENT_ID); + return "cid:" + new String(contentId); + } else { + return new String(location); + } + } +} + diff --git a/src/android/support/v7/mms/pdu/QuotedPrintable.java b/src/android/support/v7/mms/pdu/QuotedPrintable.java new file mode 100644 index 0000000..ea0abc5 --- /dev/null +++ b/src/android/support/v7/mms/pdu/QuotedPrintable.java @@ -0,0 +1,68 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +import java.io.ByteArrayOutputStream; + +public class QuotedPrintable { + private static byte ESCAPE_CHAR = '='; + + /** + * Decodes an array quoted-printable characters into an array of original bytes. + * Escaped characters are converted back to their original representation. + * + * <p> + * This function implements a subset of + * quoted-printable encoding specification (rule #1 and rule #2) + * as defined in RFC 1521. + * </p> + * + * @param bytes array of quoted-printable characters + * @return array of original bytes, + * null if quoted-printable decoding is unsuccessful. + */ + public static final byte[] decodeQuotedPrintable(byte[] bytes) { + if (bytes == null) { + return null; + } + ByteArrayOutputStream buffer = new ByteArrayOutputStream(); + for (int i = 0; i < bytes.length; i++) { + int b = bytes[i]; + if (b == ESCAPE_CHAR) { + try { + if('\r' == (char)bytes[i + 1] && + '\n' == (char)bytes[i + 2]) { + i += 2; + continue; + } + int u = Character.digit((char) bytes[++i], 16); + int l = Character.digit((char) bytes[++i], 16); + if (u == -1 || l == -1) { + return null; + } + buffer.write((char) ((u << 4) + l)); + } catch (ArrayIndexOutOfBoundsException e) { + return null; + } + } else { + buffer.write(b); + } + } + return buffer.toByteArray(); + } +} diff --git a/src/android/support/v7/mms/pdu/ReadOrigInd.java b/src/android/support/v7/mms/pdu/ReadOrigInd.java new file mode 100644 index 0000000..500a59d --- /dev/null +++ b/src/android/support/v7/mms/pdu/ReadOrigInd.java @@ -0,0 +1,151 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class ReadOrigInd extends GenericPdu { + /** + * Empty constructor. + * Since the Pdu corresponding to this class is constructed + * by the Proxy-Relay server, this class is only instantiated + * by the Pdu Parser. + * + * @throws InvalidHeaderValueException if error occurs. + */ + public ReadOrigInd() throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_READ_ORIG_IND); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + ReadOrigInd(PduHeaders headers) { + super(headers); + } + + /** + * Get Date value. + * + * @return the value + */ + public long getDate() { + return mPduHeaders.getLongInteger(PduHeaders.DATE); + } + + /** + * Set Date value. + * + * @param value the value + */ + public void setDate(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.DATE); + } + + /** + * Get From value. + * From-value = Value-length + * (Address-present-token Encoded-string-value | Insert-address-token) + * + * @return the value + */ + public EncodedStringValue getFrom() { + return mPduHeaders.getEncodedStringValue(PduHeaders.FROM); + } + + /** + * Set From value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setFrom(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.FROM); + } + + /** + * Get Message-ID value. + * + * @return the value + */ + public byte[] getMessageId() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_ID); + } + + /** + * Set Message-ID value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_ID); + } + + /** + * Get X-MMS-Read-status value. + * + * @return the value + */ + public int getReadStatus() { + return mPduHeaders.getOctet(PduHeaders.READ_STATUS); + } + + /** + * Set X-MMS-Read-status value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setReadStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.READ_STATUS); + } + + /** + * Get To value. + * + * @return the value + */ + public EncodedStringValue[] getTo() { + return mPduHeaders.getEncodedStringValues(PduHeaders.TO); + } + + /** + * Set To value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTo(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.TO); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/ReadRecInd.java b/src/android/support/v7/mms/pdu/ReadRecInd.java new file mode 100644 index 0000000..9683d00 --- /dev/null +++ b/src/android/support/v7/mms/pdu/ReadRecInd.java @@ -0,0 +1,142 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class ReadRecInd extends GenericPdu { + /** + * Constructor, used when composing a M-ReadRec.ind pdu. + * + * @param from the from value + * @param messageId the message ID value + * @param mmsVersion current viersion of mms + * @param readStatus the read status value + * @param to the to value + * @throws InvalidHeaderValueException if parameters are invalid. + * NullPointerException if messageId or to is null. + */ + public ReadRecInd(EncodedStringValue from, + byte[] messageId, + int mmsVersion, + int readStatus, + EncodedStringValue[] to) throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_READ_REC_IND); + setFrom(from); + setMessageId(messageId); + setMmsVersion(mmsVersion); + setTo(to); + setReadStatus(readStatus); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + ReadRecInd(PduHeaders headers) { + super(headers); + } + + /** + * Get Date value. + * + * @return the value + */ + public long getDate() { + return mPduHeaders.getLongInteger(PduHeaders.DATE); + } + + /** + * Set Date value. + * + * @param value the value + */ + public void setDate(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.DATE); + } + + /** + * Get Message-ID value. + * + * @return the value + */ + public byte[] getMessageId() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_ID); + } + + /** + * Set Message-ID value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_ID); + } + + /** + * Get To value. + * + * @return the value + */ + public EncodedStringValue[] getTo() { + return mPduHeaders.getEncodedStringValues(PduHeaders.TO); + } + + /** + * Set To value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTo(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.TO); + } + + /** + * Get X-MMS-Read-status value. + * + * @return the value + */ + public int getReadStatus() { + return mPduHeaders.getOctet(PduHeaders.READ_STATUS); + } + + /** + * Set X-MMS-Read-status value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setReadStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.READ_STATUS); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/RetrieveConf.java b/src/android/support/v7/mms/pdu/RetrieveConf.java new file mode 100644 index 0000000..752ca04 --- /dev/null +++ b/src/android/support/v7/mms/pdu/RetrieveConf.java @@ -0,0 +1,298 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +/** + * M-Retrive.conf Pdu. + */ +public class RetrieveConf extends MultimediaMessagePdu { + /** + * Empty constructor. + * Since the Pdu corresponding to this class is constructed + * by the Proxy-Relay server, this class is only instantiated + * by the Pdu Parser. + * + * @throws InvalidHeaderValueException if error occurs. + */ + public RetrieveConf() throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + RetrieveConf(PduHeaders headers) { + super(headers); + } + + /** + * Constructor with given headers and body + * + * @param headers Headers for this PDU. + * @param body Body of this PDu. + */ + RetrieveConf(PduHeaders headers, PduBody body) { + super(headers, body); + } + + /** + * Get CC value. + * + * @return the value + */ + public EncodedStringValue[] getCc() { + return mPduHeaders.getEncodedStringValues(PduHeaders.CC); + } + + /** + * Add a "CC" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void addCc(EncodedStringValue value) { + mPduHeaders.appendEncodedStringValue(value, PduHeaders.CC); + } + + /** + * Get Content-type value. + * + * @return the value + */ + public byte[] getContentType() { + return mPduHeaders.getTextString(PduHeaders.CONTENT_TYPE); + } + + /** + * Set Content-type value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setContentType(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.CONTENT_TYPE); + } + + /** + * Get X-Mms-Delivery-Report value. + * + * @return the value + */ + public int getDeliveryReport() { + return mPduHeaders.getOctet(PduHeaders.DELIVERY_REPORT); + } + + /** + * Set X-Mms-Delivery-Report value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setDeliveryReport(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.DELIVERY_REPORT); + } + + /** + * Get From value. + * From-value = Value-length + * (Address-present-token Encoded-string-value | Insert-address-token) + * + * @return the value + */ + public EncodedStringValue getFrom() { + return mPduHeaders.getEncodedStringValue(PduHeaders.FROM); + } + + /** + * Set From value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setFrom(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.FROM); + } + + /** + * Get X-Mms-Message-Class value. + * Message-class-value = Class-identifier | Token-text + * Class-identifier = Personal | Advertisement | Informational | Auto + * + * @return the value + */ + public byte[] getMessageClass() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_CLASS); + } + + /** + * Set X-Mms-Message-Class value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageClass(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_CLASS); + } + + /** + * Get Message-ID value. + * + * @return the value + */ + public byte[] getMessageId() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_ID); + } + + /** + * Set Message-ID value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_ID); + } + + /** + * Get X-Mms-Read-Report value. + * + * @return the value + */ + public int getReadReport() { + return mPduHeaders.getOctet(PduHeaders.READ_REPORT); + } + + /** + * Set X-Mms-Read-Report value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setReadReport(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.READ_REPORT); + } + + /** + * Get X-Mms-Retrieve-Status value. + * + * @return the value + */ + public int getRetrieveStatus() { + return mPduHeaders.getOctet(PduHeaders.RETRIEVE_STATUS); + } + + /** + * Set X-Mms-Retrieve-Status value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setRetrieveStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.RETRIEVE_STATUS); + } + + /** + * Get X-Mms-Retrieve-Text value. + * + * @return the value + */ + public EncodedStringValue getRetrieveText() { + return mPduHeaders.getEncodedStringValue(PduHeaders.RETRIEVE_TEXT); + } + + /** + * Set X-Mms-Retrieve-Text value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setRetrieveText(EncodedStringValue value) { + mPduHeaders.setEncodedStringValue(value, PduHeaders.RETRIEVE_TEXT); + } + + /** + * Get X-Mms-Transaction-Id. + * + * @return the value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte getContentClass() {return 0x00;} + * public void setApplicId(byte value) {} + * + * public byte getDrmContent() {return 0x00;} + * public void setDrmContent(byte value) {} + * + * public byte getDistributionIndicator() {return 0x00;} + * public void setDistributionIndicator(byte value) {} + * + * public PreviouslySentByValue getPreviouslySentBy() {return null;} + * public void setPreviouslySentBy(PreviouslySentByValue value) {} + * + * public PreviouslySentDateValue getPreviouslySentDate() {} + * public void setPreviouslySentDate(PreviouslySentDateValue value) {} + * + * public MmFlagsValue getMmFlags() {return null;} + * public void setMmFlags(MmFlagsValue value) {} + * + * public MmStateValue getMmState() {return null;} + * public void getMmState(MmStateValue value) {} + * + * public byte[] getReplaceId() {return 0x00;} + * public void setReplaceId(byte[] value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + * + * public byte getReplyCharging() {return 0x00;} + * public void setReplyCharging(byte value) {} + * + * public byte getReplyChargingDeadline() {return 0x00;} + * public void setReplyChargingDeadline(byte value) {} + * + * public byte[] getReplyChargingId() {return 0x00;} + * public void setReplyChargingId(byte[] value) {} + * + * public long getReplyChargingSize() {return 0;} + * public void setReplyChargingSize(long value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/SendConf.java b/src/android/support/v7/mms/pdu/SendConf.java new file mode 100644 index 0000000..5486398 --- /dev/null +++ b/src/android/support/v7/mms/pdu/SendConf.java @@ -0,0 +1,115 @@ +/* + * Copyright (C) 2007 Esmertec AG. + * Copyright (C) 2007 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 android.support.v7.mms.pdu; + +public class SendConf extends GenericPdu { + /** + * Empty constructor. + * Since the Pdu corresponding to this class is constructed + * by the Proxy-Relay server, this class is only instantiated + * by the Pdu Parser. + * + * @throws InvalidHeaderValueException if error occurs. + */ + public SendConf() throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_SEND_CONF); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + SendConf(PduHeaders headers) { + super(headers); + } + + /** + * Get Message-ID value. + * + * @return the value + */ + public byte[] getMessageId() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_ID); + } + + /** + * Set Message-ID value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_ID); + } + + /** + * Get X-Mms-Response-Status. + * + * @return the value + */ + public int getResponseStatus() { + return mPduHeaders.getOctet(PduHeaders.RESPONSE_STATUS); + } + + /** + * Set X-Mms-Response-Status. + * + * @param value the values + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setResponseStatus(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.RESPONSE_STATUS); + } + + /** + * Get X-Mms-Transaction-Id field value. + * + * @return the X-Mms-Report-Allowed value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id field value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } + + /* + * Optional, not supported header fields: + * + * public byte[] getContentLocation() {return null;} + * public void setContentLocation(byte[] value) {} + * + * public EncodedStringValue getResponseText() {return null;} + * public void setResponseText(EncodedStringValue value) {} + * + * public byte getStoreStatus() {return 0x00;} + * public void setStoreStatus(byte value) {} + * + * public byte[] getStoreStatusText() {return null;} + * public void setStoreStatusText(byte[] value) {} + */ +} diff --git a/src/android/support/v7/mms/pdu/SendReq.java b/src/android/support/v7/mms/pdu/SendReq.java new file mode 100644 index 0000000..0b78cc3 --- /dev/null +++ b/src/android/support/v7/mms/pdu/SendReq.java @@ -0,0 +1,343 @@ +/* + * Copyright (C) 2007-2008 Esmertec AG. + * Copyright (C) 2007-2008 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 android.support.v7.mms.pdu; + +import android.util.Log; + +public class SendReq extends MultimediaMessagePdu { + private static final String TAG = "SendReq"; + + public SendReq() { + super(); + + try { + setMessageType(PduHeaders.MESSAGE_TYPE_SEND_REQ); + setMmsVersion(PduHeaders.CURRENT_MMS_VERSION); + // FIXME: Content-type must be decided according to whether + // SMIL part present. + setContentType("application/vnd.wap.multipart.related".getBytes()); + setFrom(new EncodedStringValue(PduHeaders.FROM_INSERT_ADDRESS_TOKEN_STR.getBytes())); + setTransactionId(generateTransactionId()); + } catch (InvalidHeaderValueException e) { + // Impossible to reach here since all headers we set above are valid. + Log.e(TAG, "Unexpected InvalidHeaderValueException.", e); + throw new RuntimeException(e); + } + } + + private byte[] generateTransactionId() { + String transactionId = "T" + Long.toHexString(System.currentTimeMillis()); + return transactionId.getBytes(); + } + + /** + * Constructor, used when composing a M-Send.req pdu. + * + * @param contentType the content type value + * @param from the from value + * @param mmsVersion current viersion of mms + * @param transactionId the transaction-id value + * @throws InvalidHeaderValueException if parameters are invalid. + * NullPointerException if contentType, form or transactionId is null. + */ + public SendReq(byte[] contentType, + EncodedStringValue from, + int mmsVersion, + byte[] transactionId) throws InvalidHeaderValueException { + super(); + setMessageType(PduHeaders.MESSAGE_TYPE_SEND_REQ); + setContentType(contentType); + setFrom(from); + setMmsVersion(mmsVersion); + setTransactionId(transactionId); + } + + /** + * Constructor with given headers. + * + * @param headers Headers for this PDU. + */ + SendReq(PduHeaders headers) { + super(headers); + } + + /** + * Constructor with given headers and body + * + * @param headers Headers for this PDU. + * @param body Body of this PDu. + */ + SendReq(PduHeaders headers, PduBody body) { + super(headers, body); + } + + /** + * Get Bcc value. + * + * @return the value + */ + public EncodedStringValue[] getBcc() { + return mPduHeaders.getEncodedStringValues(PduHeaders.BCC); + } + + /** + * Add a "BCC" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void addBcc(EncodedStringValue value) { + mPduHeaders.appendEncodedStringValue(value, PduHeaders.BCC); + } + + /** + * Set "BCC" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setBcc(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.BCC); + } + + /** + * Get CC value. + * + * @return the value + */ + public EncodedStringValue[] getCc() { + return mPduHeaders.getEncodedStringValues(PduHeaders.CC); + } + + /** + * Add a "CC" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void addCc(EncodedStringValue value) { + mPduHeaders.appendEncodedStringValue(value, PduHeaders.CC); + } + + /** + * Set "CC" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setCc(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.CC); + } + + /** + * Get Content-type value. + * + * @return the value + */ + public byte[] getContentType() { + return mPduHeaders.getTextString(PduHeaders.CONTENT_TYPE); + } + + /** + * Set Content-type value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setContentType(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.CONTENT_TYPE); + } + + /** + * Get X-Mms-Delivery-Report value. + * + * @return the value + */ + public int getDeliveryReport() { + return mPduHeaders.getOctet(PduHeaders.DELIVERY_REPORT); + } + + /** + * Set X-Mms-Delivery-Report value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setDeliveryReport(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.DELIVERY_REPORT); + } + + /** + * Get X-Mms-Expiry value. + * + * Expiry-value = Value-length + * (Absolute-token Date-value | Relative-token Delta-seconds-value) + * + * @return the value + */ + public long getExpiry() { + return mPduHeaders.getLongInteger(PduHeaders.EXPIRY); + } + + /** + * Set X-Mms-Expiry value. + * + * @param value the value + */ + public void setExpiry(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.EXPIRY); + } + + /** + * Get X-Mms-MessageSize value. + * + * Expiry-value = size of message + * + * @return the value + */ + public long getMessageSize() { + return mPduHeaders.getLongInteger(PduHeaders.MESSAGE_SIZE); + } + + /** + * Set X-Mms-MessageSize value. + * + * @param value the value + */ + public void setMessageSize(long value) { + mPduHeaders.setLongInteger(value, PduHeaders.MESSAGE_SIZE); + } + + /** + * Get X-Mms-Message-Class value. + * Message-class-value = Class-identifier | Token-text + * Class-identifier = Personal | Advertisement | Informational | Auto + * + * @return the value + */ + public byte[] getMessageClass() { + return mPduHeaders.getTextString(PduHeaders.MESSAGE_CLASS); + } + + /** + * Set X-Mms-Message-Class value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setMessageClass(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.MESSAGE_CLASS); + } + + /** + * Get X-Mms-Read-Report value. + * + * @return the value + */ + public int getReadReport() { + return mPduHeaders.getOctet(PduHeaders.READ_REPORT); + } + + /** + * Set X-Mms-Read-Report value. + * + * @param value the value + * @throws InvalidHeaderValueException if the value is invalid. + */ + public void setReadReport(int value) throws InvalidHeaderValueException { + mPduHeaders.setOctet(value, PduHeaders.READ_REPORT); + } + + /** + * Set "To" value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTo(EncodedStringValue[] value) { + mPduHeaders.setEncodedStringValues(value, PduHeaders.TO); + } + + /** + * Get X-Mms-Transaction-Id field value. + * + * @return the X-Mms-Report-Allowed value + */ + public byte[] getTransactionId() { + return mPduHeaders.getTextString(PduHeaders.TRANSACTION_ID); + } + + /** + * Set X-Mms-Transaction-Id field value. + * + * @param value the value + * @throws NullPointerException if the value is null. + */ + public void setTransactionId(byte[] value) { + mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID); + } + + /* + * Optional, not supported header fields: + * + * public byte getAdaptationAllowed() {return 0}; + * public void setAdaptationAllowed(btye value) {}; + * + * public byte[] getApplicId() {return null;} + * public void setApplicId(byte[] value) {} + * + * public byte[] getAuxApplicId() {return null;} + * public void getAuxApplicId(byte[] value) {} + * + * public byte getContentClass() {return 0x00;} + * public void setApplicId(byte value) {} + * + * public long getDeliveryTime() {return 0}; + * public void setDeliveryTime(long value) {}; + * + * public byte getDrmContent() {return 0x00;} + * public void setDrmContent(byte value) {} + * + * public MmFlagsValue getMmFlags() {return null;} + * public void setMmFlags(MmFlagsValue value) {} + * + * public MmStateValue getMmState() {return null;} + * public void getMmState(MmStateValue value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + * + * public byte getReplyCharging() {return 0x00;} + * public void setReplyCharging(byte value) {} + * + * public byte getReplyChargingDeadline() {return 0x00;} + * public void setReplyChargingDeadline(byte value) {} + * + * public byte[] getReplyChargingId() {return 0x00;} + * public void setReplyChargingId(byte[] value) {} + * + * public long getReplyChargingSize() {return 0;} + * public void setReplyChargingSize(long value) {} + * + * public byte[] getReplyApplicId() {return 0x00;} + * public void setReplyApplicId(byte[] value) {} + * + * public byte getStore() {return 0x00;} + * public void setStore(byte value) {} + */ +} |