filab/packages_apps_Messaging
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity

Revert "Initial checkin of AOSP Messaging app."

Browse Source 
This reverts commit 461a34b466.

Change-Id: Iac4ca77eeaa94989e91dead49a7959c905bd3078
This commit is contained in:
Mike Dodd
2015-08-12 18:48:39 +00:00
parent 461a34b466
commit ef8c7abbcf
1645 changed files with 0 additions and 186271 deletions
Download Patch File Download Diff File Expand all files Collapse all files

39
src/android/support/v7/mms/ApnException.java
View File

@@ -1,39 +0,0 @@
/*
* 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);
}
}

63
src/android/support/v7/mms/ApnSettingsLoader.java
View File

@@ -1,63 +0,0 @@
/*
* 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);
}

73
src/android/support/v7/mms/ApnsXmlParser.java
View File

@@ -1,73 +0,0 @@
/*
* 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;
}
}

198
src/android/support/v7/mms/CarrierConfigValuesLoader.java
View File

@@ -1,198 +0,0 @@
/*
* 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;
}

68
src/android/support/v7/mms/CarrierConfigXmlParser.java
View File

@@ -1,68 +0,0 @@
/*
* 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;
}
}

497
src/android/support/v7/mms/DefaultApnSettingsLoader.java
View File

@@ -1,497 +0,0 @@
/*
* 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;
}
}

126
src/android/support/v7/mms/DefaultCarrierConfigValuesLoader.java
View File

@@ -1,126 +0,0 @@
/*
* 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();
}
}
}
}

88
src/android/support/v7/mms/DefaultUserAgentInfoLoader.java
View File

@@ -1,88 +0,0 @@
/*
* 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;
}
}
}

132
src/android/support/v7/mms/DownloadRequest.java
View File

@@ -1,132 +0,0 @@
/*
* 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);
}
}

523
src/android/support/v7/mms/MmsHttpClient.java
View File

@@ -1,523 +0,0 @@
/*
* 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;
}
}

50
src/android/support/v7/mms/MmsHttpException.java
View File

@@ -1,50 +0,0 @@
/*
* 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;
}
}

256
src/android/support/v7/mms/MmsManager.java
View File

@@ -1,256 +0,0 @@
/*
* 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);
}
}
}
}
}

39
src/android/support/v7/mms/MmsNetworkException.java
View File

@@ -1,39 +0,0 @@
/*
* 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);
}
}

382
src/android/support/v7/mms/MmsNetworkManager.java
View File

@@ -1,382 +0,0 @@
/*
* 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;
}
}

391
src/android/support/v7/mms/MmsRequest.java
View File

@@ -1,391 +0,0 @@
/*
* 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);
}
}

465
src/android/support/v7/mms/MmsService.java
View File

@@ -1,465 +0,0 @@
/*
* 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;
}
}

143
src/android/support/v7/mms/MmsXmlResourceParser.java
View File

@@ -1,143 +0,0 @@
/*
* 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);
}
}

54
src/android/support/v7/mms/PhoneNumberHelper.java
View File

@@ -1,54 +0,0 @@
/*
* 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;
}
}

163
src/android/support/v7/mms/SendRequest.java
View File

@@ -1,163 +0,0 @@
/*
* 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);
}
}

40
src/android/support/v7/mms/UserAgentInfoLoader.java
View File

@@ -1,40 +0,0 @@
/*
* 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();
}

180
src/android/support/v7/mms/Utils.java
View File

@@ -1,180 +0,0 @@
/*
* 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();
}
}

87
src/android/support/v7/mms/pdu/AcknowledgeInd.java
View File

@@ -1,87 +0,0 @@
/*
* 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);
}
}

167
src/android/support/v7/mms/pdu/Base64.java
View File

@@ -1,167 +0,0 @@
/*
* 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;
}
}

172
src/android/support/v7/mms/pdu/CharacterSets.java
View File

@@ -1,172 +0,0 @@
/*
* 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;
}
}

230
src/android/support/v7/mms/pdu/ContentType.java
View File

@@ -1,230 +0,0 @@
/*
* 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();
}
}

136
src/android/support/v7/mms/pdu/DeliveryInd.java
View File

@@ -1,136 +0,0 @@
/*
* 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) {}
*/
}

283
src/android/support/v7/mms/pdu/EncodedStringValue.java
View File

@@ -1,283 +0,0 @@
/*
* 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;
}
}

111
src/android/support/v7/mms/pdu/GenericPdu.java
View File

@@ -1,111 +0,0 @@
/*
* 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);
}
}

41
src/android/support/v7/mms/pdu/InvalidHeaderValueException.java
View File

@@ -1,41 +0,0 @@
/*
* 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);
}
}

60
src/android/support/v7/mms/pdu/MmsException.java
View File

@@ -1,60 +0,0 @@
/*
* 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);
}
}

148
src/android/support/v7/mms/pdu/MultimediaMessagePdu.java
View File

@@ -1,148 +0,0 @@
/*
* 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);
}
}

283
src/android/support/v7/mms/pdu/NotificationInd.java
View File

@@ -1,283 +0,0 @@
/*
* 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) {}
*/
}

112
src/android/support/v7/mms/pdu/NotifyRespInd.java
View File

@@ -1,112 +0,0 @@
/*
* 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);
}
}

191
src/android/support/v7/mms/pdu/PduBody.java
View File

@@ -1,191 +0,0 @@
/*
* 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);
}
}

110
src/android/support/v7/mms/pdu/PduContentTypes.java
View File

@@ -1,110 +0,0 @@
/*
* 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 */
};
}

719
src/android/support/v7/mms/pdu/PduHeaders.java
View File

@@ -1,719 +0,0 @@
/*
* 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);
}
}

2008
src/android/support/v7/mms/pdu/PduParser.java
View File

File diff suppressed because it is too large Load Diff

414
src/android/support/v7/mms/pdu/PduPart.java
View File

@@ -1,414 +0,0 @@
/*
* 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);
}
}
}

68
src/android/support/v7/mms/pdu/QuotedPrintable.java
View File

@@ -1,68 +0,0 @@
/*
* 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();
}
}

151
src/android/support/v7/mms/pdu/ReadOrigInd.java
View File

@@ -1,151 +0,0 @@
/*
* 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) {}
*/
}

142
src/android/support/v7/mms/pdu/ReadRecInd.java
View File

@@ -1,142 +0,0 @@
/*
* 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) {}
*/
}

298
src/android/support/v7/mms/pdu/RetrieveConf.java
View File

@@ -1,298 +0,0 @@
/*
* 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) {}
*/
}

115
src/android/support/v7/mms/pdu/SendConf.java
View File

@@ -1,115 +0,0 @@
/*
* 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) {}
*/
}

343
src/android/support/v7/mms/pdu/SendReq.java
View File

@@ -1,343 +0,0 @@
/*
* 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) {}
*/
}