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
src/com/android/messaging/mmslib/Downloads.java
-807
View File
@@ -1,807 +0,0 @@
/*
* Copyright (C) 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 com.android.messaging.mmslib;
import android.app.DownloadManager;
import android.content.Context;
import android.net.Uri;
import android.provider.BaseColumns;
/**
* The Download Manager
*
* @pending
*/
public final class Downloads {
private Downloads() {}
/**
* Implementation details
*
* Exposes constants used to interact with the download manager's
* content provider.
* The constants URI ... STATUS are the names of columns in the downloads table.
*
* @hide
*/
public static final class Impl implements BaseColumns {
private Impl() {}
/**
* The permission to access the download manager
*/
public static final String PERMISSION_ACCESS = "android.permission.ACCESS_DOWNLOAD_MANAGER";
/**
* The permission to access the download manager's advanced functions
*/
public static final String PERMISSION_ACCESS_ADVANCED =
"android.permission.ACCESS_DOWNLOAD_MANAGER_ADVANCED";
/**
* The permission to access the all the downloads in the manager.
*/
public static final String PERMISSION_ACCESS_ALL =
"android.permission.ACCESS_ALL_DOWNLOADS";
/**
* The permission to directly access the download manager's cache
* directory
*/
public static final String PERMISSION_CACHE = "android.permission.ACCESS_CACHE_FILESYSTEM";
/**
* The permission to send broadcasts on download completion
*/
public static final String PERMISSION_SEND_INTENTS =
"android.permission.SEND_DOWNLOAD_COMPLETED_INTENTS";
/**
* The permission to download files to the cache partition that won't be automatically
* purged when space is needed.
*/
public static final String PERMISSION_CACHE_NON_PURGEABLE =
"android.permission.DOWNLOAD_CACHE_NON_PURGEABLE";
/**
* The permission to download files without any system notification being shown.
*/
public static final String PERMISSION_NO_NOTIFICATION =
"android.permission.DOWNLOAD_WITHOUT_NOTIFICATION";
/**
* The content:// URI to access downloads owned by the caller's UID.
*/
public static final Uri CONTENT_URI =
Uri.parse("content://downloads/my_downloads");
/**
* The content URI for accessing all downloads across all UIDs (requires the
* ACCESS_ALL_DOWNLOADS permission).
*/
public static final Uri ALL_DOWNLOADS_CONTENT_URI =
Uri.parse("content://downloads/all_downloads");
/** URI segment to access a publicly accessible downloaded file */
public static final String PUBLICLY_ACCESSIBLE_DOWNLOADS_URI_SEGMENT = "public_downloads";
/**
* The content URI for accessing publicly accessible downloads (i.e., it requires no
* permissions to access this downloaded file)
*/
public static final Uri PUBLICLY_ACCESSIBLE_DOWNLOADS_URI =
Uri.parse("content://downloads/" + PUBLICLY_ACCESSIBLE_DOWNLOADS_URI_SEGMENT);
/**
* Broadcast Action: this is sent by the download manager to the app
* that had initiated a download when that download completes. The
* download's content: uri is specified in the intent's data.
*/
public static final String ACTION_DOWNLOAD_COMPLETED =
"android.intent.action.DOWNLOAD_COMPLETED";
/**
* Broadcast Action: this is sent by the download manager to the app
* that had initiated a download when the user selects the notification
* associated with that download. The download's content: uri is specified
* in the intent's data if the click is associated with a single download,
* or Downloads.CONTENT_URI if the notification is associated with
* multiple downloads.
* Note: this is not currently sent for downloads that have completed
* successfully.
*/
public static final String ACTION_NOTIFICATION_CLICKED =
"android.intent.action.DOWNLOAD_NOTIFICATION_CLICKED";
/**
* The name of the column containing the URI of the data being downloaded.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_URI = "uri";
/**
* The name of the column containing application-specific data.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read/Write</P>
*/
public static final String COLUMN_APP_DATA = "entity";
/**
* The name of the column containing the flags that indicates whether
* the initiating application is capable of verifying the integrity of
* the downloaded file. When this flag is set, the download manager
* performs downloads and reports success even in some situations where
* it can't guarantee that the download has completed (e.g. when doing
* a byte-range request without an ETag, or when it can't determine
* whether a download fully completed).
* <P>Type: BOOLEAN</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_NO_INTEGRITY = "no_integrity";
/**
* The name of the column containing the filename that the initiating
* application recommends. When possible, the download manager will attempt
* to use this filename, or a variation, as the actual name for the file.
* <P>Type: TEXT</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_FILE_NAME_HINT = "hint";
/**
* The name of the column containing the filename where the downloaded data
* was actually stored.
* <P>Type: TEXT</P>
* <P>Owner can Read</P>
*/
public static final String _DATA = "_data";
/**
* The name of the column containing the MIME type of the downloaded data.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_MIME_TYPE = "mimetype";
/**
* The name of the column containing the flag that controls the destination
* of the download. See the DESTINATION_* constants for a list of legal values.
* <P>Type: INTEGER</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_DESTINATION = "destination";
/**
* The name of the column containing the flags that controls whether the
* download is displayed by the UI. See the VISIBILITY_* constants for
* a list of legal values.
* <P>Type: INTEGER</P>
* <P>Owner can Init/Read/Write</P>
*/
public static final String COLUMN_VISIBILITY = "visibility";
/**
* The name of the column containing the current control state of the download.
* Applications can write to this to control (pause/resume) the download.
* the CONTROL_* constants for a list of legal values.
* <P>Type: INTEGER</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_CONTROL = "control";
/**
* The name of the column containing the current status of the download.
* Applications can read this to follow the progress of each download. See
* the STATUS_* constants for a list of legal values.
* <P>Type: INTEGER</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_STATUS = "status";
/**
* The name of the column containing the date at which some interesting
* status changed in the download. Stored as a System.currentTimeMillis()
* value.
* <P>Type: BIGINT</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_LAST_MODIFICATION = "lastmod";
/**
* The name of the column containing the package name of the application
* that initiating the download. The download manager will send
* notifications to a component in this package when the download completes.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_NOTIFICATION_PACKAGE = "notificationpackage";
/**
* The name of the column containing the component name of the class that
* will receive notifications associated with the download. The
* package/class combination is passed to
* Intent.setClassName(String,String).
* <P>Type: TEXT</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_NOTIFICATION_CLASS = "notificationclass";
/**
* If extras are specified when requesting a download they will be provided in the intent
* that is sent to the specified class and package when a download has finished.
* <P>Type: TEXT</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_NOTIFICATION_EXTRAS = "notificationextras";
/**
* The name of the column contain the values of the cookie to be used for
* the download. This is used directly as the value for the Cookie: HTTP
* header that gets sent with the request.
* <P>Type: TEXT</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_COOKIE_DATA = "cookiedata";
/**
* The name of the column containing the user agent that the initiating
* application wants the download manager to use for this download.
* <P>Type: TEXT</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_USER_AGENT = "useragent";
/**
* The name of the column containing the referer (sic) that the initiating
* application wants the download manager to use for this download.
* <P>Type: TEXT</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_REFERER = "referer";
/**
* The name of the column containing the total size of the file being
* downloaded.
* <P>Type: INTEGER</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_TOTAL_BYTES = "total_bytes";
/**
* The name of the column containing the size of the part of the file that
* has been downloaded so far.
* <P>Type: INTEGER</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_CURRENT_BYTES = "current_bytes";
/**
* The name of the column where the initiating application can provide the
* UID of another application that is allowed to access this download. If
* multiple applications share the same UID, all those applications will be
* allowed to access this download. This column can be updated after the
* download is initiated. This requires the permission
* android.permission.ACCESS_DOWNLOAD_MANAGER_ADVANCED.
* <P>Type: INTEGER</P>
* <P>Owner can Init</P>
*/
public static final String COLUMN_OTHER_UID = "otheruid";
/**
* The name of the column where the initiating application can provided the
* title of this download. The title will be displayed ito the user in the
* list of downloads.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read/Write</P>
*/
public static final String COLUMN_TITLE = "title";
/**
* The name of the column where the initiating application can provide the
* description of this download. The description will be displayed to the
* user in the list of downloads.
* <P>Type: TEXT</P>
* <P>Owner can Init/Read/Write</P>
*/
public static final String COLUMN_DESCRIPTION = "description";
/**
* The name of the column indicating whether the download was requesting through the public
* API. This controls some differences in behavior.
* <P>Type: BOOLEAN</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_IS_PUBLIC_API = "is_public_api";
/**
* The name of the column holding a bitmask of allowed network types. This is only used for
* public API downloads.
* <P>Type: INTEGER</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_ALLOWED_NETWORK_TYPES = "allowed_network_types";
/**
* The name of the column indicating whether roaming connections can be used. This is only
* used for public API downloads.
* <P>Type: BOOLEAN</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_ALLOW_ROAMING = "allow_roaming";
/**
* The name of the column indicating whether metered connections can be used. This is only
* used for public API downloads.
* <P>Type: BOOLEAN</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_ALLOW_METERED = "allow_metered";
/**
* Whether or not this download should be displayed in the system's Downloads UI. Defaults
* to true.
* <P>Type: INTEGER</P>
* <P>Owner can Init/Read</P>
*/
public static final String COLUMN_IS_VISIBLE_IN_DOWNLOADS_UI = "is_visible_in_downloads_ui";
/**
* If true, the user has confirmed that this download can proceed over the mobile network
* even though it exceeds the recommended maximum size.
* <P>Type: BOOLEAN</P>
*/
public static final String COLUMN_BYPASS_RECOMMENDED_SIZE_LIMIT =
"bypass_recommended_size_limit";
/**
* Set to true if this download is deleted. It is completely removed from the database
* when MediaProvider database also deletes the metadata asociated with this downloaded
* file.
* <P>Type: BOOLEAN</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_DELETED = "deleted";
/**
* The URI to the corresponding entry in MediaProvider for this downloaded entry. It is
* used to delete the entries from MediaProvider database when it is deleted from the
* downloaded list.
* <P>Type: TEXT</P>
* <P>Owner can Read</P>
*/
public static final String COLUMN_MEDIAPROVIDER_URI = "mediaprovider_uri";
/**
* The column that is used to remember whether the media scanner was invoked.
* It can take the values: null or 0(not scanned), 1(scanned), 2 (not scannable).
* <P>Type: TEXT</P>
*/
public static final String COLUMN_MEDIA_SCANNED = "scanned";
/**
* The column with errorMsg for a failed downloaded.
* Used only for debugging purposes.
* <P>Type: TEXT</P>
*/
public static final String COLUMN_ERROR_MSG = "errorMsg";
/**
* This column stores the source of the last update to this row.
* This column is only for internal use.
* Valid values are indicated by LAST_UPDATESRC_* constants.
* <P>Type: INT</P>
*/
public static final String COLUMN_LAST_UPDATESRC = "lastUpdateSrc";
/** The column that is used to count retries */
public static final String COLUMN_FAILED_CONNECTIONS = "numfailed";
/**
* default value for {@link #COLUMN_LAST_UPDATESRC}.
* This value is used when this column's value is not relevant.
*/
public static final int LAST_UPDATESRC_NOT_RELEVANT = 0;
/**
* One of the values taken by {@link #COLUMN_LAST_UPDATESRC}.
* This value is used when the update is NOT to be relayed to the DownloadService
* (and thus spare DownloadService from scanning the database when this change occurs)
*/
public static final int LAST_UPDATESRC_DONT_NOTIFY_DOWNLOADSVC = 1;
/*
* Lists the destinations that an application can specify for a download.
*/
/**
* This download will be saved to the external storage. This is the
* default behavior, and should be used for any file that the user
* can freely access, copy, delete. Even with that destination,
* unencrypted DRM files are saved in secure internal storage.
* Downloads to the external destination only write files for which
* there is a registered handler. The resulting files are accessible
* by filename to all applications.
*/
public static final int DESTINATION_EXTERNAL = 0;
/**
* This download will be saved to the download manager's private
* partition. This is the behavior used by applications that want to
* download private files that are used and deleted soon after they
* get downloaded. All file types are allowed, and only the initiating
* application can access the file (indirectly through a content
* provider). This requires the
* android.permission.ACCESS_DOWNLOAD_MANAGER_ADVANCED permission.
*/
public static final int DESTINATION_CACHE_PARTITION = 1;
/**
* This download will be saved to the download manager's private
* partition and will be purged as necessary to make space. This is
* for private files (similar to CACHE_PARTITION) that aren't deleted
* immediately after they are used, and are kept around by the download
* manager as long as space is available.
*/
public static final int DESTINATION_CACHE_PARTITION_PURGEABLE = 2;
/**
* This download will be saved to the download manager's private
* partition, as with DESTINATION_CACHE_PARTITION, but the download
* will not proceed if the user is on a roaming data connection.
*/
public static final int DESTINATION_CACHE_PARTITION_NOROAMING = 3;
/**
* This download will be saved to the location given by the file URI in
* {@link #COLUMN_FILE_NAME_HINT}.
*/
public static final int DESTINATION_FILE_URI = 4;
/**
* This download will be saved to the system cache ("/cache")
* partition. This option is only used by system apps and so it requires
* android.permission.ACCESS_CACHE_FILESYSTEM permission.
*/
public static final int DESTINATION_SYSTEMCACHE_PARTITION = 5;
/**
* This download was completed by the caller (i.e., NOT downloadmanager)
* and caller wants to have this download displayed in Downloads App.
*/
public static final int DESTINATION_NON_DOWNLOADMANAGER_DOWNLOAD = 6;
/**
* This download is allowed to run.
*/
public static final int CONTROL_RUN = 0;
/**
* This download must pause at the first opportunity.
*/
public static final int CONTROL_PAUSED = 1;
/*
* Lists the states that the download manager can set on a download
* to notify applications of the download progress.
* The codes follow the HTTP families:<br>
* 1xx: informational<br>
* 2xx: success<br>
* 3xx: redirects (not used by the download manager)<br>
* 4xx: client errors<br>
* 5xx: server errors
*/
/**
* Returns whether the status is informational (i.e. 1xx).
*/
public static boolean isStatusInformational(int status) {
return (status >= 100 && status < 200);
}
/**
* Returns whether the status is a success (i.e. 2xx).
*/
public static boolean isStatusSuccess(int status) {
return (status >= 200 && status < 300);
}
/**
* Returns whether the status is an error (i.e. 4xx or 5xx).
*/
public static boolean isStatusError(int status) {
return (status >= 400 && status < 600);
}
/**
* Returns whether the status is a client error (i.e. 4xx).
*/
public static boolean isStatusClientError(int status) {
return (status >= 400 && status < 500);
}
/**
* Returns whether the status is a server error (i.e. 5xx).
*/
public static boolean isStatusServerError(int status) {
return (status >= 500 && status < 600);
}
/**
* this method determines if a notification should be displayed for a
* given {@link #COLUMN_VISIBILITY} value
* @param visibility the value of {@link #COLUMN_VISIBILITY}.
* @return true if the notification should be displayed. false otherwise.
*/
public static boolean isNotificationToBeDisplayed(int visibility) {
return visibility == DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED ||
visibility == DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_ONLY_COMPLETION;
}
/**
* Returns whether the download has completed (either with success or
* error).
*/
public static boolean isStatusCompleted(int status) {
return (status >= 200 && status < 300) || (status >= 400 && status < 600);
}
/**
* This download hasn't stated yet
*/
public static final int STATUS_PENDING = 190;
/**
* This download has started
*/
public static final int STATUS_RUNNING = 192;
/**
* This download has been paused by the owning app.
*/
public static final int STATUS_PAUSED_BY_APP = 193;
/**
* This download encountered some network error and is waiting before retrying the request.
*/
public static final int STATUS_WAITING_TO_RETRY = 194;
/**
* This download is waiting for network connectivity to proceed.
*/
public static final int STATUS_WAITING_FOR_NETWORK = 195;
/**
* This download exceeded a size limit for mobile networks and is waiting for a Wi-Fi
* connection to proceed.
*/
public static final int STATUS_QUEUED_FOR_WIFI = 196;
/**
* This download couldn't be completed due to insufficient storage
* space. Typically, this is because the SD card is full.
*/
public static final int STATUS_INSUFFICIENT_SPACE_ERROR = 198;
/**
* This download couldn't be completed because no external storage
* device was found. Typically, this is because the SD card is not
* mounted.
*/
public static final int STATUS_DEVICE_NOT_FOUND_ERROR = 199;
/**
* This download has successfully completed.
* Warning: there might be other status values that indicate success
* in the future.
* Use isSucccess() to capture the entire category.
*/
public static final int STATUS_SUCCESS = 200;
/**
* This request couldn't be parsed. This is also used when processing
* requests with unknown/unsupported URI schemes.
*/
public static final int STATUS_BAD_REQUEST = 400;
/**
* This download can't be performed because the content type cannot be
* handled.
*/
public static final int STATUS_NOT_ACCEPTABLE = 406;
/**
* This download cannot be performed because the length cannot be
* determined accurately. This is the code for the HTTP error "Length
* Required", which is typically used when making requests that require
* a content length but don't have one, and it is also used in the
* client when a response is received whose length cannot be determined
* accurately (therefore making it impossible to know when a download
* completes).
*/
public static final int STATUS_LENGTH_REQUIRED = 411;
/**
* This download was interrupted and cannot be resumed.
* This is the code for the HTTP error "Precondition Failed", and it is
* also used in situations where the client doesn't have an ETag at all.
*/
public static final int STATUS_PRECONDITION_FAILED = 412;
/**
* The lowest-valued error status that is not an actual HTTP status code.
*/
public static final int MIN_ARTIFICIAL_ERROR_STATUS = 488;
/**
* The requested destination file already exists.
*/
public static final int STATUS_FILE_ALREADY_EXISTS_ERROR = 488;
/**
* Some possibly transient error occurred, but we can't resume the download.
*/
public static final int STATUS_CANNOT_RESUME = 489;
/**
* This download was canceled
*/
public static final int STATUS_CANCELED = 490;
/**
* This download has completed with an error.
* Warning: there will be other status values that indicate errors in
* the future. Use isStatusError() to capture the entire category.
*/
public static final int STATUS_UNKNOWN_ERROR = 491;
/**
* This download couldn't be completed because of a storage issue.
* Typically, that's because the filesystem is missing or full.
* Use the more specific {@link #STATUS_INSUFFICIENT_SPACE_ERROR}
* and {@link #STATUS_DEVICE_NOT_FOUND_ERROR} when appropriate.
*/
public static final int STATUS_FILE_ERROR = 492;
/**
* This download couldn't be completed because of an HTTP
* redirect response that the download manager couldn't
* handle.
*/
public static final int STATUS_UNHANDLED_REDIRECT = 493;
/**
* This download couldn't be completed because of an
* unspecified unhandled HTTP code.
*/
public static final int STATUS_UNHANDLED_HTTP_CODE = 494;
/**
* This download couldn't be completed because of an
* error receiving or processing data at the HTTP level.
*/
public static final int STATUS_HTTP_DATA_ERROR = 495;
/**
* This download couldn't be completed because of an
* HttpException while setting up the request.
*/
public static final int STATUS_HTTP_EXCEPTION = 496;
/**
* This download couldn't be completed because there were
* too many redirects.
*/
public static final int STATUS_TOO_MANY_REDIRECTS = 497;
/**
* This download has failed because requesting application has been
* blocked by {@link NetworkPolicyManager}.
*
* @hide
* @deprecated since behavior now uses
* {@link #STATUS_WAITING_FOR_NETWORK}
*/
@Deprecated
public static final int STATUS_BLOCKED = 498;
/** {@hide} */
public static String statusToString(int status) {
switch (status) {
case STATUS_PENDING: return "PENDING";
case STATUS_RUNNING: return "RUNNING";
case STATUS_PAUSED_BY_APP: return "PAUSED_BY_APP";
case STATUS_WAITING_TO_RETRY: return "WAITING_TO_RETRY";
case STATUS_WAITING_FOR_NETWORK: return "WAITING_FOR_NETWORK";
case STATUS_QUEUED_FOR_WIFI: return "QUEUED_FOR_WIFI";
case STATUS_INSUFFICIENT_SPACE_ERROR: return "INSUFFICIENT_SPACE_ERROR";
case STATUS_DEVICE_NOT_FOUND_ERROR: return "DEVICE_NOT_FOUND_ERROR";
case STATUS_SUCCESS: return "SUCCESS";
case STATUS_BAD_REQUEST: return "BAD_REQUEST";
case STATUS_NOT_ACCEPTABLE: return "NOT_ACCEPTABLE";
case STATUS_LENGTH_REQUIRED: return "LENGTH_REQUIRED";
case STATUS_PRECONDITION_FAILED: return "PRECONDITION_FAILED";
case STATUS_FILE_ALREADY_EXISTS_ERROR: return "FILE_ALREADY_EXISTS_ERROR";
case STATUS_CANNOT_RESUME: return "CANNOT_RESUME";
case STATUS_CANCELED: return "CANCELED";
case STATUS_UNKNOWN_ERROR: return "UNKNOWN_ERROR";
case STATUS_FILE_ERROR: return "FILE_ERROR";
case STATUS_UNHANDLED_REDIRECT: return "UNHANDLED_REDIRECT";
case STATUS_UNHANDLED_HTTP_CODE: return "UNHANDLED_HTTP_CODE";
case STATUS_HTTP_DATA_ERROR: return "HTTP_DATA_ERROR";
case STATUS_HTTP_EXCEPTION: return "HTTP_EXCEPTION";
case STATUS_TOO_MANY_REDIRECTS: return "TOO_MANY_REDIRECTS";
case STATUS_BLOCKED: return "BLOCKED";
default: return Integer.toString(status);
}
}
/**
* This download is visible but only shows in the notifications
* while it's in progress.
*/
public static final int VISIBILITY_VISIBLE = DownloadManager.Request.VISIBILITY_VISIBLE;
/**
* This download is visible and shows in the notifications while
* in progress and after completion.
*/
public static final int VISIBILITY_VISIBLE_NOTIFY_COMPLETED =
DownloadManager.Request.VISIBILITY_VISIBLE_NOTIFY_COMPLETED;
/**
* This download doesn't show in the UI or in the notifications.
*/
public static final int VISIBILITY_HIDDEN = DownloadManager.Request.VISIBILITY_HIDDEN;
/**
* Constants related to HTTP request headers associated with each download.
*/
public static class RequestHeaders {
public static final String HEADERS_DB_TABLE = "request_headers";
public static final String COLUMN_DOWNLOAD_ID = "download_id";
public static final String COLUMN_HEADER = "header";
public static final String COLUMN_VALUE = "value";
/**
* Path segment to add to a download URI to retrieve request headers
*/
public static final String URI_SEGMENT = "headers";
/**
* Prefix for ContentValues keys that contain HTTP header lines, to be passed to
* DownloadProvider.insert().
*/
public static final String INSERT_KEY_PREFIX = "http_header_";
}
}
/**
* Query where clause for general querying.
*/
private static final String QUERY_WHERE_CLAUSE = Impl.COLUMN_NOTIFICATION_PACKAGE + "=? AND "
+ Impl.COLUMN_NOTIFICATION_CLASS + "=?";
/**
* Delete all the downloads for a package/class pair.
*/
public static final void removeAllDownloadsByPackage(
Context context, String notificationPackage, String notificationClass) {
context.getContentResolver().delete(Impl.CONTENT_URI, QUERY_WHERE_CLAUSE,
new String[] { notificationPackage, notificationClass });
}
}
src/com/android/messaging/mmslib/InvalidHeaderValueException.java
-41
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 com.android.messaging.mmslib;
/**
* 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);
}
}
src/com/android/messaging/mmslib/MmsException.java
-60
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 com.android.messaging.mmslib;
/**
* 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);
}
}
src/com/android/messaging/mmslib/SqliteWrapper.java
-88
View File
@@ -1,88 +0,0 @@
/*
* Copyright (C) 2008 Esmertec AG.
* Copyright (C) 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 com.android.messaging.mmslib;
import android.content.ContentResolver;
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteException;
import android.net.Uri;
import com.android.messaging.util.LogUtil;
// Wrapper around content resolver methods to catch exceptions
public final class SqliteWrapper {
private static final String TAG = LogUtil.BUGLE_TAG;
private SqliteWrapper() {
// Forbidden being instantiated.
}
public static Cursor query(Context context, ContentResolver resolver, Uri uri,
String[] projection, String selection, String[] selectionArgs, String sortOrder) {
try {
return resolver.query(uri, projection, selection, selectionArgs, sortOrder);
} catch (SQLiteException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when query", e);
return null;
} catch (IllegalArgumentException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when query", e);
return null;
}
}
public static int update(Context context, ContentResolver resolver, Uri uri,
ContentValues values, String where, String[] selectionArgs) {
try {
return resolver.update(uri, values, where, selectionArgs);
} catch (SQLiteException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when update", e);
return -1;
} catch (IllegalArgumentException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when update", e);
return -1;
}
}
public static int delete(Context context, ContentResolver resolver, Uri uri,
String where, String[] selectionArgs) {
try {
return resolver.delete(uri, where, selectionArgs);
} catch (SQLiteException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when delete", e);
return -1;
} catch (IllegalArgumentException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when delete", e);
return -1;
}
}
public static Uri insert(Context context, ContentResolver resolver,
Uri uri, ContentValues values) {
try {
return resolver.insert(uri, values);
} catch (SQLiteException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when insert", e);
return null;
} catch (IllegalArgumentException e) {
LogUtil.e(TAG, "SqliteWrapper: catch an exception when insert", e);
return null;
}
}
}
src/com/android/messaging/mmslib/pdu/AcknowledgeInd.java
-89
View File
@@ -1,89 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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.
* @throws 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);
}
}
src/com/android/messaging/mmslib/pdu/Base64.java
-167
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 com.android.messaging.mmslib.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;
}
}
src/com/android/messaging/mmslib/pdu/CharacterSets.java
-452
View File
@@ -1,452 +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 com.android.messaging.mmslib.pdu;
import android.support.v4.util.SimpleArrayMap;
import android.util.SparseArray;
import java.io.UnsupportedEncodingException;
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 "*"
*
* Link to all the charsets: http://www.iana.org/assignments/character-sets/character-sets.xhtml
* Use Charset.availableCharsets() to see if a potential charset is supported in java:
* private void dumpCharsets() {
* logvv("dumpCharsets");
* SortedMap<String, Charset> charsets = Charset.availableCharsets();
* for (Entry<String, Charset> entry : charsets.entrySet()) {
* String key = entry.getKey();
* Charset value = entry.getValue();
* logvv("charset key: " + key + " value: " + value);
* }
* }
*
* As of March 21, 2014, here is the list from dumpCharsets:
* Adobe-Standard-Encoding value: java.nio.charset.CharsetICU[Adobe-Standard-Encoding]
* Big5 value: java.nio.charset.CharsetICU[Big5]
* Big5-HKSCS value: java.nio.charset.CharsetICU[Big5-HKSCS]
* BOCU-1 value: java.nio.charset.CharsetICU[BOCU-1]
* CESU-8 value: java.nio.charset.CharsetICU[CESU-8]
* cp1363 value: java.nio.charset.CharsetICU[cp1363]
* cp851 value: java.nio.charset.CharsetICU[cp851]
* cp864 value: java.nio.charset.CharsetICU[cp864]
* EUC-JP value: java.nio.charset.CharsetICU[EUC-JP]
* EUC-KR value: java.nio.charset.CharsetICU[EUC-KR]
* GB18030 value: java.nio.charset.CharsetICU[GB18030]
* GBK value: java.nio.charset.CharsetICU[GBK]
* hp-roman8 value: java.nio.charset.CharsetICU[hp-roman8]
* HZ-GB-2312 value: java.nio.charset.CharsetICU[HZ-GB-2312]
* IBM-Thai value: java.nio.charset.CharsetICU[IBM-Thai]
* IBM00858 value: java.nio.charset.CharsetICU[IBM00858]
* IBM01140 value: java.nio.charset.CharsetICU[IBM01140]
* IBM01141 value: java.nio.charset.CharsetICU[IBM01141]
* IBM01142 value: java.nio.charset.CharsetICU[IBM01142]
* IBM01143 value: java.nio.charset.CharsetICU[IBM01143]
* IBM01144 value: java.nio.charset.CharsetICU[IBM01144]
* IBM01145 value: java.nio.charset.CharsetICU[IBM01145]
* IBM01146 value: java.nio.charset.CharsetICU[IBM01146]
* IBM01147 value: java.nio.charset.CharsetICU[IBM01147]
* IBM01148 value: java.nio.charset.CharsetICU[IBM01148]
* IBM01149 value: java.nio.charset.CharsetICU[IBM01149]
* IBM037 value: java.nio.charset.CharsetICU[IBM037]
* IBM1026 value: java.nio.charset.CharsetICU[IBM1026]
* IBM1047 value: java.nio.charset.CharsetICU[IBM1047]
* IBM273 value: java.nio.charset.CharsetICU[IBM273]
* IBM277 value: java.nio.charset.CharsetICU[IBM277]
* IBM278 value: java.nio.charset.CharsetICU[IBM278]
* IBM280 value: java.nio.charset.CharsetICU[IBM280]
* IBM284 value: java.nio.charset.CharsetICU[IBM284]
* IBM285 value: java.nio.charset.CharsetICU[IBM285]
* IBM290 value: java.nio.charset.CharsetICU[IBM290]
* IBM297 value: java.nio.charset.CharsetICU[IBM297]
* IBM420 value: java.nio.charset.CharsetICU[IBM420]
* IBM424 value: java.nio.charset.CharsetICU[IBM424]
* IBM437 value: java.nio.charset.CharsetICU[IBM437]
* IBM500 value: java.nio.charset.CharsetICU[IBM500]
* IBM775 value: java.nio.charset.CharsetICU[IBM775]
* IBM850 value: java.nio.charset.CharsetICU[IBM850]
* IBM852 value: java.nio.charset.CharsetICU[IBM852]
* IBM855 value: java.nio.charset.CharsetICU[IBM855]
* IBM857 value: java.nio.charset.CharsetICU[IBM857]
* IBM860 value: java.nio.charset.CharsetICU[IBM860]
* IBM861 value: java.nio.charset.CharsetICU[IBM861]
* IBM862 value: java.nio.charset.CharsetICU[IBM862]
* IBM863 value: java.nio.charset.CharsetICU[IBM863]
* IBM865 value: java.nio.charset.CharsetICU[IBM865]
* IBM866 value: java.nio.charset.CharsetICU[IBM866]
* IBM868 value: java.nio.charset.CharsetICU[IBM868]
* IBM869 value: java.nio.charset.CharsetICU[IBM869]
* IBM870 value: java.nio.charset.CharsetICU[IBM870]
* IBM871 value: java.nio.charset.CharsetICU[IBM871]
* IBM918 value: java.nio.charset.CharsetICU[IBM918]
* ISO-2022-CN value: java.nio.charset.CharsetICU[ISO-2022-CN]
* ISO-2022-CN-EXT value: java.nio.charset.CharsetICU[ISO-2022-CN-EXT]
* ISO-2022-JP value: java.nio.charset.CharsetICU[ISO-2022-JP]
* ISO-2022-JP-1 value: java.nio.charset.CharsetICU[ISO-2022-JP-1]
* ISO-2022-JP-2 value: java.nio.charset.CharsetICU[ISO-2022-JP-2]
* ISO-2022-KR value: java.nio.charset.CharsetICU[ISO-2022-KR]
* ISO-8859-1 value: java.nio.charset.CharsetICU[ISO-8859-1]
* ISO-8859-10 value: java.nio.charset.CharsetICU[ISO-8859-10]
* ISO-8859-13 value: java.nio.charset.CharsetICU[ISO-8859-13]
* ISO-8859-14 value: java.nio.charset.CharsetICU[ISO-8859-14]
* ISO-8859-15 value: java.nio.charset.CharsetICU[ISO-8859-15]
* ISO-8859-2 value: java.nio.charset.CharsetICU[ISO-8859-2]
* ISO-8859-3 value: java.nio.charset.CharsetICU[ISO-8859-3]
* ISO-8859-4 value: java.nio.charset.CharsetICU[ISO-8859-4]
* ISO-8859-5 value: java.nio.charset.CharsetICU[ISO-8859-5]
* ISO-8859-6 value: java.nio.charset.CharsetICU[ISO-8859-6]
* ISO-8859-7 value: java.nio.charset.CharsetICU[ISO-8859-7]
* ISO-8859-8 value: java.nio.charset.CharsetICU[ISO-8859-8]
* ISO-8859-9 value: java.nio.charset.CharsetICU[ISO-8859-9]
* KOI8-R value: java.nio.charset.CharsetICU[KOI8-R]
* KOI8-U value: java.nio.charset.CharsetICU[KOI8-U]
* macintosh value: java.nio.charset.CharsetICU[macintosh]
* SCSU value: java.nio.charset.CharsetICU[SCSU]
* Shift_JIS value: java.nio.charset.CharsetICU[Shift_JIS]
* TIS-620 value: java.nio.charset.CharsetICU[TIS-620]
* US-ASCII value: java.nio.charset.CharsetICU[US-ASCII]
* UTF-16 value: java.nio.charset.CharsetICU[UTF-16]
* UTF-16BE value: java.nio.charset.CharsetICU[UTF-16BE]
* UTF-16LE value: java.nio.charset.CharsetICU[UTF-16LE]
* UTF-32 value: java.nio.charset.CharsetICU[UTF-32]
* UTF-32BE value: java.nio.charset.CharsetICU[UTF-32BE]
* UTF-32LE value: java.nio.charset.CharsetICU[UTF-32LE]
* UTF-7 value: java.nio.charset.CharsetICU[UTF-7]
* UTF-8 value: java.nio.charset.CharsetICU[UTF-8]
* windows-1250 value: java.nio.charset.CharsetICU[windows-1250]
* windows-1251 value: java.nio.charset.CharsetICU[windows-1251]
* windows-1252 value: java.nio.charset.CharsetICU[windows-1252]
* windows-1253 value: java.nio.charset.CharsetICU[windows-1253]
* windows-1254 value: java.nio.charset.CharsetICU[windows-1254]
* windows-1255 value: java.nio.charset.CharsetICU[windows-1255]
* windows-1256 value: java.nio.charset.CharsetICU[windows-1256]
* windows-1257 value: java.nio.charset.CharsetICU[windows-1257]
* windows-1258 value: java.nio.charset.CharsetICU[windows-1258]
* x-compound-text value: java.nio.charset.CharsetICU[x-compound-text]
* x-ebcdic-xml-us value: java.nio.charset.CharsetICU[x-ebcdic-xml-us]
* x-gsm-03.38-2000 value: java.nio.charset.CharsetICU[x-gsm-03.38-2000]
* x-ibm-1047-s390 value: java.nio.charset.CharsetICU[x-ibm-1047-s390]
* x-ibm-1125_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1125_P100-1997]
* x-ibm-1129_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1129_P100-1997]
* x-ibm-1130_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1130_P100-1997]
* x-ibm-1131_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1131_P100-1997]
* x-ibm-1132_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-1132_P100-1998]
* x-ibm-1133_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1133_P100-1997]
* x-ibm-1137_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1137_P100-1999]
* x-ibm-1140-s390 value: java.nio.charset.CharsetICU[x-ibm-1140-s390]
* x-ibm-1141-s390 value: java.nio.charset.CharsetICU[x-ibm-1141-s390]
* x-ibm-1142-s390 value: java.nio.charset.CharsetICU[x-ibm-1142-s390]
* x-ibm-1143-s390 value: java.nio.charset.CharsetICU[x-ibm-1143-s390]
* x-ibm-1144-s390 value: java.nio.charset.CharsetICU[x-ibm-1144-s390]
* x-ibm-1145-s390 value: java.nio.charset.CharsetICU[x-ibm-1145-s390]
* x-ibm-1146-s390 value: java.nio.charset.CharsetICU[x-ibm-1146-s390]
* x-ibm-1147-s390 value: java.nio.charset.CharsetICU[x-ibm-1147-s390]
* x-ibm-1148-s390 value: java.nio.charset.CharsetICU[x-ibm-1148-s390]
* x-ibm-1149-s390 value: java.nio.charset.CharsetICU[x-ibm-1149-s390]
* x-ibm-1153-s390 value: java.nio.charset.CharsetICU[x-ibm-1153-s390]
* x-ibm-1154_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1154_P100-1999]
* x-ibm-1155_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1155_P100-1999]
* x-ibm-1156_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1156_P100-1999]
* x-ibm-1157_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1157_P100-1999]
* x-ibm-1158_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1158_P100-1999]
* x-ibm-1160_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1160_P100-1999]
* x-ibm-1162_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1162_P100-1999]
* x-ibm-1164_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-1164_P100-1999]
* x-ibm-1250_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1250_P100-1995]
* x-ibm-1251_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1251_P100-1995]
* x-ibm-1252_P100-2000 value: java.nio.charset.CharsetICU[x-ibm-1252_P100-2000]
* x-ibm-1253_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1253_P100-1995]
* x-ibm-1254_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1254_P100-1995]
* x-ibm-1255_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1255_P100-1995]
* x-ibm-1256_P110-1997 value: java.nio.charset.CharsetICU[x-ibm-1256_P110-1997]
* x-ibm-1257_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-1257_P100-1995]
* x-ibm-1258_P100-1997 value: java.nio.charset.CharsetICU[x-ibm-1258_P100-1997]
* x-ibm-12712-s390 value: java.nio.charset.CharsetICU[x-ibm-12712-s390]
* x-ibm-12712_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-12712_P100-1998]
* x-ibm-1373_P100-2002 value: java.nio.charset.CharsetICU[x-ibm-1373_P100-2002]
* x-ibm-1383_P110-1999 value: java.nio.charset.CharsetICU[x-ibm-1383_P110-1999]
* x-ibm-1386_P100-2001 value: java.nio.charset.CharsetICU[x-ibm-1386_P100-2001]
* x-ibm-16684_P110-2003 value: java.nio.charset.CharsetICU[x-ibm-16684_P110-2003]
* x-ibm-16804-s390 value: java.nio.charset.CharsetICU[x-ibm-16804-s390]
* x-ibm-16804_X110-1999 value: java.nio.charset.CharsetICU[x-ibm-16804_X110-1999]
* x-ibm-25546 value: java.nio.charset.CharsetICU[x-ibm-25546]
* x-ibm-33722_P12A_P12A-2009_U2 value:
* java.nio.charset.CharsetICU[x-ibm-33722_P12A_P12A-2009_U2]
* x-ibm-37-s390 value: java.nio.charset.CharsetICU[x-ibm-37-s390]
* x-ibm-4517_P100-2005 value: java.nio.charset.CharsetICU[x-ibm-4517_P100-2005]
* x-ibm-4899_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-4899_P100-1998]
* x-ibm-4909_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-4909_P100-1999]
* x-ibm-4971_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-4971_P100-1999]
* x-ibm-5123_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-5123_P100-1999]
* x-ibm-5351_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-5351_P100-1998]
* x-ibm-5352_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-5352_P100-1998]
* x-ibm-5353_P100-1998 value: java.nio.charset.CharsetICU[x-ibm-5353_P100-1998]
* x-ibm-5478_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-5478_P100-1995]
* x-ibm-803_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-803_P100-1999]
* x-ibm-813_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-813_P100-1995]
* x-ibm-8482_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-8482_P100-1999]
* x-ibm-901_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-901_P100-1999]
* x-ibm-902_P100-1999 value: java.nio.charset.CharsetICU[x-ibm-902_P100-1999]
* x-ibm-9067_X100-2005 value: java.nio.charset.CharsetICU[x-ibm-9067_X100-2005]
* x-ibm-916_P100-1995 value: java.nio.charset.CharsetICU[x-ibm-916_P100-1995]
* x-IBM1006 value: java.nio.charset.CharsetICU[x-IBM1006]
* x-IBM1025 value: java.nio.charset.CharsetICU[x-IBM1025]
* x-IBM1097 value: java.nio.charset.CharsetICU[x-IBM1097]
* x-IBM1098 value: java.nio.charset.CharsetICU[x-IBM1098]
* x-IBM1112 value: java.nio.charset.CharsetICU[x-IBM1112]
* x-IBM1122 value: java.nio.charset.CharsetICU[x-IBM1122]
* x-IBM1123 value: java.nio.charset.CharsetICU[x-IBM1123]
* x-IBM1124 value: java.nio.charset.CharsetICU[x-IBM1124]
* x-IBM1153 value: java.nio.charset.CharsetICU[x-IBM1153]
* x-IBM1363 value: java.nio.charset.CharsetICU[x-IBM1363]
* x-IBM1364 value: java.nio.charset.CharsetICU[x-IBM1364]
* x-IBM1371 value: java.nio.charset.CharsetICU[x-IBM1371]
* x-IBM1388 value: java.nio.charset.CharsetICU[x-IBM1388]
* x-IBM1390 value: java.nio.charset.CharsetICU[x-IBM1390]
* x-IBM1399 value: java.nio.charset.CharsetICU[x-IBM1399]
* x-IBM33722 value: java.nio.charset.CharsetICU[x-IBM33722]
* x-IBM720 value: java.nio.charset.CharsetICU[x-IBM720]
* x-IBM737 value: java.nio.charset.CharsetICU[x-IBM737]
* x-IBM856 value: java.nio.charset.CharsetICU[x-IBM856]
* x-IBM867 value: java.nio.charset.CharsetICU[x-IBM867]
* x-IBM875 value: java.nio.charset.CharsetICU[x-IBM875]
* x-IBM922 value: java.nio.charset.CharsetICU[x-IBM922]
* x-IBM930 value: java.nio.charset.CharsetICU[x-IBM930]
* x-IBM933 value: java.nio.charset.CharsetICU[x-IBM933]
* x-IBM935 value: java.nio.charset.CharsetICU[x-IBM935]
* x-IBM937 value: java.nio.charset.CharsetICU[x-IBM937]
* x-IBM939 value: java.nio.charset.CharsetICU[x-IBM939]
* x-IBM942 value: java.nio.charset.CharsetICU[x-IBM942]
* x-IBM943 value: java.nio.charset.CharsetICU[x-IBM943]
* x-IBM949 value: java.nio.charset.CharsetICU[x-IBM949]
* x-IBM949C value: java.nio.charset.CharsetICU[x-IBM949C]
* x-IBM950 value: java.nio.charset.CharsetICU[x-IBM950]
* x-IBM954 value: java.nio.charset.CharsetICU[x-IBM954]
* x-IBM964 value: java.nio.charset.CharsetICU[x-IBM964]
* x-IBM970 value: java.nio.charset.CharsetICU[x-IBM970]
* x-IBM971 value: java.nio.charset.CharsetICU[x-IBM971]
* x-IMAP-mailbox-name value: java.nio.charset.CharsetICU[x-IMAP-mailbox-name]
* x-iscii-be value: java.nio.charset.CharsetICU[x-iscii-be]
* x-iscii-gu value: java.nio.charset.CharsetICU[x-iscii-gu]
* x-iscii-ka value: java.nio.charset.CharsetICU[x-iscii-ka]
* x-iscii-ma value: java.nio.charset.CharsetICU[x-iscii-ma]
* x-iscii-or value: java.nio.charset.CharsetICU[x-iscii-or]
* x-iscii-pa value: java.nio.charset.CharsetICU[x-iscii-pa]
* x-iscii-ta value: java.nio.charset.CharsetICU[x-iscii-ta]
* x-iscii-te value: java.nio.charset.CharsetICU[x-iscii-te]
* x-ISCII91 value: java.nio.charset.CharsetICU[x-ISCII91]
* x-ISO-2022-CN-CNS value: java.nio.charset.CharsetICU[x-ISO-2022-CN-CNS]
* x-iso-8859-11 value: java.nio.charset.CharsetICU[x-iso-8859-11]
* x-JavaUnicode value: java.nio.charset.CharsetICU[x-JavaUnicode]
* x-JavaUnicode2 value: java.nio.charset.CharsetICU[x-JavaUnicode2]
* x-JIS7 value: java.nio.charset.CharsetICU[x-JIS7]
* x-JIS8 value: java.nio.charset.CharsetICU[x-JIS8]
* x-LMBCS-1 value: java.nio.charset.CharsetICU[x-LMBCS-1]
* x-mac-centraleurroman value: java.nio.charset.CharsetICU[x-mac-centraleurroman]
* x-mac-cyrillic value: java.nio.charset.CharsetICU[x-mac-cyrillic]
* x-mac-greek value: java.nio.charset.CharsetICU[x-mac-greek]
* x-mac-turkish value: java.nio.charset.CharsetICU[x-mac-turkish]
* x-MS950-HKSCS value: java.nio.charset.CharsetICU[x-MS950-HKSCS]
* x-UnicodeBig value: java.nio.charset.CharsetICU[x-UnicodeBig]
* x-UTF-16LE-BOM value: java.nio.charset.CharsetICU[x-UTF-16LE-BOM]
* x-UTF16_OppositeEndian value: java.nio.charset.CharsetICU[x-UTF16_OppositeEndian]
* x-UTF16_PlatformEndian value: java.nio.charset.CharsetICU[x-UTF16_PlatformEndian]
* x-UTF32_OppositeEndian value: java.nio.charset.CharsetICU[x-UTF32_OppositeEndian]
* x-UTF32_PlatformEndian value: java.nio.charset.CharsetICU[x-UTF32_PlatformEndian]
*
*/
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 EUC_JP = 0x12;
public static final int EUC_KR = 0x26;
public static final int ISO_2022_JP = 0x27;
public static final int ISO_2022_JP_2 = 0x28;
public static final int UTF_8 = 0x6A;
public static final int GBK = 0x71;
public static final int GB18030 = 0x72;
public static final int GB2312 = 0x07E9;
public static final int BIG5 = 0x07EA;
public static final int UCS2 = 0x03E8;
public static final int UTF_16 = 0x03F7;
public static final int HZ_GB_2312 = 0x0825;
/**
* 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,
EUC_JP,
EUC_KR,
ISO_2022_JP,
ISO_2022_JP_2,
UTF_8,
GBK,
GB18030,
GB2312,
BIG5,
UCS2,
UTF_16,
HZ_GB_2312,
};
/**
* 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_EUC_JP = "euc-jp";
public static final String MIMENAME_EUC_KR = "euc-kr";
public static final String MIMENAME_ISO_2022_JP = "iso-2022-jp";
public static final String MIMENAME_ISO_2022_JP_2 = "iso-2022-jp-2";
public static final String MIMENAME_UTF_8 = "utf-8";
public static final String MIMENAME_GBK = "gbk";
public static final String MIMENAME_GB18030 = "gb18030";
public static final String MIMENAME_GB2312 = "gb2312";
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 MIMENAME_HZ_GB_2312 = "hz-gb-2312";
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_EUC_JP,
MIMENAME_EUC_KR,
MIMENAME_ISO_2022_JP,
MIMENAME_ISO_2022_JP_2,
MIMENAME_UTF_8,
MIMENAME_GBK,
MIMENAME_GB18030,
MIMENAME_GB2312,
MIMENAME_BIG5,
MIMENAME_UCS2,
MIMENAME_UTF_16,
MIMENAME_HZ_GB_2312,
};
private static final SparseArray<String> MIBENUM_TO_NAME_MAP;
private static final SimpleArrayMap<String, Integer> NAME_TO_MIBENUM_MAP;
static {
// Create the HashMaps.
MIBENUM_TO_NAME_MAP = new SparseArray<String>();
NAME_TO_MIBENUM_MAP = new SimpleArrayMap<String, Integer>();
assert (MIBENUM_NUMBERS.length == MIME_NAMES.length);
final 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.
*/
public static String getMimeName(final int mibEnumValue)
throws UnsupportedEncodingException {
final 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.
*/
public static int getMibEnumValue(final String mimeName)
throws UnsupportedEncodingException {
if (null == mimeName) {
return -1;
}
final Integer mibEnumValue = NAME_TO_MIBENUM_MAP.get(mimeName);
if (mibEnumValue == null) {
throw new UnsupportedEncodingException();
}
return mibEnumValue;
}
}
src/com/android/messaging/mmslib/pdu/DeliveryInd.java
-138
View File
@@ -1,138 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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) {}
*/
}
src/com/android/messaging/mmslib/pdu/EncodedStringValue.java
-298
View File
@@ -1,298 +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 com.android.messaging.mmslib.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) {
this(CharacterSets.DEFAULT_CHARSET, data);
}
/**
* Constructor
*
* @param charset
* @param data The text in Java String
* @throws NullPointerException if Text-string value is null.
*/
public EncodedStringValue(int charset, String data) {
if (null == data) {
throw new NullPointerException("EncodedStringValue: Text-string is null");
}
mCharacterSet = charset;
try {
mData = data.getBytes(CharacterSets.getMimeName(charset));
} catch (UnsupportedEncodingException e) {
Log.e(TAG, "Input encoding " + charset + " must be supported.", e);
mData = data.getBytes();
}
}
/**
* 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 exception) {
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 exception) {
// 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;
}
}
src/com/android/messaging/mmslib/pdu/GenericPdu.java
-113
View File
@@ -1,113 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
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.
* @throws 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.
* @throws 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);
}
}
src/com/android/messaging/mmslib/pdu/MultimediaMessagePdu.java
-159
View File
@@ -1,159 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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);
}
/**
* Get the message size
*
* @return the size of the message
*/
public long getMessageSize() {
return mPduHeaders.getLongInteger(PduHeaders.MESSAGE_SIZE);
}
}
src/com/android/messaging/mmslib/pdu/NotificationInd.java
-285
View File
@@ -1,285 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws 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) {}
*/
}
src/com/android/messaging/mmslib/pdu/NotifyRespInd.java
-114
View File
@@ -1,114 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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.
* @throws NullPointerException if transactionId is null.
* @throws 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.
* @throws 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.
* @throws 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.
* @throws RuntimeException if an undeclared error occurs.
*/
public void setTransactionId(byte[] value) {
mPduHeaders.setTextString(value, PduHeaders.TRANSACTION_ID);
}
}
src/com/android/messaging/mmslib/pdu/PduBody.java
-87
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 com.android.messaging.mmslib.pdu;
import java.util.Vector;
public class PduBody {
private Vector<PduPart> mParts = null;
/**
* Constructor.
*/
public PduBody() {
mParts = new Vector<PduPart>();
}
/**
* 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();
}
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();
}
mParts.add(index, part);
}
/**
* 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 number of parts.
*
* @return the number of parts
*/
public int getPartsNum() {
return mParts.size();
}
}
src/com/android/messaging/mmslib/pdu/PduComposer.java
-1260
View File
File diff suppressed because it is too large Load Diff
src/com/android/messaging/mmslib/pdu/PduContentTypes.java
-110
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 com.android.messaging.mmslib.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 */
};
}
src/com/android/messaging/mmslib/pdu/PduHeaders.java
-743
View File
@@ -1,743 +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 com.android.messaging.mmslib.pdu;
import android.util.SparseArray;
import com.android.messaging.mmslib.InvalidHeaderValueException;
import java.util.ArrayList;
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
= 0xE7;
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 SparseArray<Object> mHeaderMap = null;
/**
* Constructor of PduHeaders.
*/
public PduHeaders() {
mHeaderMap = new SparseArray<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);
}
public boolean hasHeader(int field) {
return mHeaderMap.get(field, null) != null;
}
}
src/com/android/messaging/mmslib/pdu/PduParser.java
-2044
View File
File diff suppressed because it is too large Load Diff
src/com/android/messaging/mmslib/pdu/PduPart.java
-389
View File
@@ -1,389 +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 com.android.messaging.mmslib.pdu;
import android.net.Uri;
import android.util.SparseArray;
/**
* 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 SparseArray<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 SparseArray<Object>();
}
/**
* Set part data. The data are stored as byte array.
*
* @param data the data
*/
public void setData(final byte[] data) {
mPartData = data;
}
/**
* @return The part data or null if the data wasn't set or
* the data is stored as Uri.
* @see #getDataUri
*/
public byte[] getData() {
return mPartData;
}
/**
* Set data uri. The data are stored as Uri.
*
* @param uri the uri
*/
public void setDataUri(final 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(final 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.
final 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(final 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() {
final 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(final 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(final 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 value the value
* @throws NullPointerException if the value is null.
*/
public void setContentType(final 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 contentId the content-id value
* @throws NullPointerException if the value is null.
*/
public void setContentTransferEncoding(final 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(final 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(final 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) {
final byte[] contentId = (byte[]) mPartHeader.get(P_CONTENT_ID);
return "cid:" + new String(contentId);
} else {
return new String(location);
}
}
}
src/com/android/messaging/mmslib/pdu/PduPersister.java
-1683
View File
File diff suppressed because it is too large Load Diff
src/com/android/messaging/mmslib/pdu/QuotedPrintable.java
-68
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 com.android.messaging.mmslib.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();
}
}
src/com/android/messaging/mmslib/pdu/ReadOrigInd.java
-153
View File
@@ -1,153 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
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) {}
*/
}
src/com/android/messaging/mmslib/pdu/ReadRecInd.java
-144
View File
@@ -1,144 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
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.
* @throws 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) {}
*/
}
src/com/android/messaging/mmslib/pdu/RetrieveConf.java
-305
View File
@@ -1,305 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
/**
* 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() {
/*
* If the header is not there, assuming it is OK status.
* Some carriers may choose to not send this header.
*/
return mPduHeaders.hasHeader(PduHeaders.RETRIEVE_STATUS) ?
mPduHeaders.getOctet(PduHeaders.RETRIEVE_STATUS) : PduHeaders.RETRIEVE_STATUS_OK;
}
/**
* 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) {}
*/
}
src/com/android/messaging/mmslib/pdu/SendConf.java
-117
View File
@@ -1,117 +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 com.android.messaging.mmslib.pdu;
import com.android.messaging.mmslib.InvalidHeaderValueException;
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) {}
*/
}
src/com/android/messaging/mmslib/pdu/SendReq.java
-346
View File
@@ -1,346 +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 com.android.messaging.mmslib.pdu;
import android.util.Log;
import com.android.messaging.mmslib.InvalidHeaderValueException;
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);
// TODO: 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) {}
*/
}
src/com/android/messaging/mmslib/util/AbstractCache.java
-112
View File
@@ -1,112 +0,0 @@
/*
* Copyright (C) 2008 Esmertec AG.
* Copyright (C) 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 com.android.messaging.mmslib.util;
import android.support.v4.util.SimpleArrayMap;
import android.util.Log;
public abstract class AbstractCache<K, V> {
private static final String TAG = "AbstractCache";
private static final boolean LOCAL_LOGV = false;
private static final int MAX_CACHED_ITEMS = 500;
private final SimpleArrayMap<K, CacheEntry<V>> mCacheMap;
protected AbstractCache() {
mCacheMap = new SimpleArrayMap<K, CacheEntry<V>>();
}
public boolean put(K key, V value) {
if (LOCAL_LOGV) {
Log.v(TAG, "Trying to put " + key + " into cache.");
}
if (mCacheMap.size() >= MAX_CACHED_ITEMS) {
// TODO: Should remove the oldest or least hit cached entry
// and then cache the new one.
if (LOCAL_LOGV) {
Log.v(TAG, "Failed! size limitation reached.");
}
return false;
}
if (key != null) {
CacheEntry<V> cacheEntry = new CacheEntry<V>();
cacheEntry.value = value;
mCacheMap.put(key, cacheEntry);
if (LOCAL_LOGV) {
Log.v(TAG, key + " cached, " + mCacheMap.size() + " items total.");
}
return true;
}
return false;
}
public V get(K key) {
if (LOCAL_LOGV) {
Log.v(TAG, "Trying to get " + key + " from cache.");
}
if (key != null) {
CacheEntry<V> cacheEntry = mCacheMap.get(key);
if (cacheEntry != null) {
cacheEntry.hit++;
if (LOCAL_LOGV) {
Log.v(TAG, key + " hit " + cacheEntry.hit + " times.");
}
return cacheEntry.value;
}
}
return null;
}
public V purge(K key) {
if (LOCAL_LOGV) {
Log.v(TAG, "Trying to purge " + key);
}
CacheEntry<V> v = mCacheMap.remove(key);
if (LOCAL_LOGV) {
Log.v(TAG, mCacheMap.size() + " items cached.");
}
return v != null ? v.value : null;
}
public void purgeAll() {
if (LOCAL_LOGV) {
Log.v(TAG, "Purging cache, " + mCacheMap.size()
+ " items dropped.");
}
mCacheMap.clear();
}
public int size() {
return mCacheMap.size();
}
private static class CacheEntry<V> {
int hit;
V value;
}
}
src/com/android/messaging/mmslib/util/DownloadDrmHelper.java
-111
View File
@@ -1,111 +0,0 @@
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package com.android.messaging.mmslib.util;
import android.content.Context;
import android.drm.DrmManagerClient;
import android.util.Log;
public class DownloadDrmHelper {
private static final String TAG = "DownloadDrmHelper";
/** The MIME type of special DRM files */
public static final String MIMETYPE_DRM_MESSAGE = "application/vnd.oma.drm.message";
/** The extensions of special DRM files */
public static final String EXTENSION_DRM_MESSAGE = ".dm";
public static final String EXTENSION_INTERNAL_FWDL = ".fl";
/**
* Checks if the Media Type is a DRM Media Type
*
* @param drmManagerClient A DrmManagerClient
* @param mimetype Media Type to check
* @return True if the Media Type is DRM else false
*/
public static boolean isDrmMimeType(Context context, String mimetype) {
boolean result = false;
if (context != null) {
try {
DrmManagerClient drmClient = new DrmManagerClient(context);
if (drmClient != null && mimetype != null && mimetype.length() > 0) {
result = drmClient.canHandle("", mimetype);
}
} catch (IllegalArgumentException e) {
Log.w(TAG,
"DrmManagerClient instance could not be created, context is Illegal.");
} catch (IllegalStateException e) {
Log.w(TAG, "DrmManagerClient didn't initialize properly.");
}
}
return result;
}
/**
* Checks if the Media Type needs to be DRM converted
*
* @param mimetype Media type of the content
* @return True if convert is needed else false
*/
public static boolean isDrmConvertNeeded(String mimetype) {
return MIMETYPE_DRM_MESSAGE.equals(mimetype);
}
/**
* Modifies the file extension for a DRM Forward Lock file NOTE: This
* function shouldn't be called if the file shouldn't be DRM converted
*/
public static String modifyDrmFwLockFileExtension(String filename) {
if (filename != null) {
int extensionIndex;
extensionIndex = filename.lastIndexOf(".");
if (extensionIndex != -1) {
filename = filename.substring(0, extensionIndex);
}
filename = filename.concat(EXTENSION_INTERNAL_FWDL);
}
return filename;
}
/**
* Gets the original mime type of DRM protected content.
*
* @param context The context
* @param path Path to the file
* @param containingMime The current mime type of of the file i.e. the
* containing mime type
* @return The original mime type of the file if DRM protected else the
* currentMime
*/
public static String getOriginalMimeType(Context context, String path, String containingMime) {
String result = containingMime;
DrmManagerClient drmClient = new DrmManagerClient(context);
try {
if (drmClient.canHandle(path, null)) {
result = drmClient.getOriginalMimeType(path);
}
} catch (IllegalArgumentException ex) {
Log.w(TAG,
"Can't get original mime type since path is null or empty string.");
} catch (IllegalStateException ex) {
Log.w(TAG, "DrmManagerClient didn't initialize properly.");
}
return result;
}
}
src/com/android/messaging/mmslib/util/DrmConvertSession.java
-174
View File
@@ -1,174 +0,0 @@
/*
* Copyright (C) 2012 The Android Open Source Project
*
* Licensed under the Apache License, Version 2.0 (the "License");
* you may not use this file except in compliance with the License.
* You may obtain a copy of the License at
*
* http://www.apache.org/licenses/LICENSE-2.0
*
* Unless required by applicable law or agreed to in writing, software
* distributed under the License is distributed on an "AS IS" BASIS,
* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
* See the License for the specific language governing permissions and
* limitations under the License.
*
*/
package com.android.messaging.mmslib.util;
import android.content.Context;
import android.drm.DrmConvertedStatus;
import android.drm.DrmManagerClient;
import android.util.Log;
import com.android.messaging.mmslib.Downloads;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.RandomAccessFile;
public class DrmConvertSession {
private DrmManagerClient mDrmClient;
private int mConvertSessionId;
private static final String TAG = "DrmConvertSession";
private DrmConvertSession(DrmManagerClient drmClient, int convertSessionId) {
mDrmClient = drmClient;
mConvertSessionId = convertSessionId;
}
/**
* Start of converting a file.
*
* @param context The context of the application running the convert session.
* @param mimeType Mimetype of content that shall be converted.
* @return A convert session or null in case an error occurs.
*/
public static DrmConvertSession open(Context context, String mimeType) {
DrmManagerClient drmClient = null;
int convertSessionId = -1;
if (context != null && mimeType != null && !mimeType.equals("")) {
try {
drmClient = new DrmManagerClient(context);
try {
convertSessionId = drmClient.openConvertSession(mimeType);
} catch (IllegalArgumentException e) {
Log.w(TAG, "Conversion of Mimetype: " + mimeType
+ " is not supported.", e);
} catch (IllegalStateException e) {
Log.w(TAG, "Could not access Open DrmFramework.", e);
}
} catch (IllegalArgumentException e) {
Log.w(TAG,
"DrmManagerClient instance could not be created, context is Illegal.");
} catch (IllegalStateException e) {
Log.w(TAG, "DrmManagerClient didn't initialize properly.");
}
}
if (drmClient == null || convertSessionId < 0) {
return null;
} else {
return new DrmConvertSession(drmClient, convertSessionId);
}
}
/**
* Convert a buffer of data to protected format.
*
* @param buffer Buffer filled with data to convert.
* @param size The number of bytes that shall be converted.
* @return A Buffer filled with converted data, if execution is ok, in all
* other case null.
*/
public byte[] convert(byte[] inBuffer, int size) {
byte[] result = null;
if (inBuffer != null) {
DrmConvertedStatus convertedStatus = null;
try {
if (size != inBuffer.length) {
byte[] buf = new byte[size];
System.arraycopy(inBuffer, 0, buf, 0, size);
convertedStatus = mDrmClient.convertData(mConvertSessionId, buf);
} else {
convertedStatus = mDrmClient.convertData(mConvertSessionId, inBuffer);
}
if (convertedStatus != null &&
convertedStatus.statusCode == DrmConvertedStatus.STATUS_OK &&
convertedStatus.convertedData != null) {
result = convertedStatus.convertedData;
}
} catch (IllegalArgumentException e) {
Log.w(TAG, "Buffer with data to convert is illegal. Convertsession: "
+ mConvertSessionId, e);
} catch (IllegalStateException e) {
Log.w(TAG, "Could not convert data. Convertsession: " +
mConvertSessionId, e);
}
} else {
throw new IllegalArgumentException("Parameter inBuffer is null");
}
return result;
}
/**
* Ends a conversion session of a file.
*
* @param fileName The filename of the converted file.
* @return Downloads.Impl.STATUS_SUCCESS if execution is ok.
* Downloads.Impl.STATUS_FILE_ERROR in case converted file can not
* be accessed. Downloads.Impl.STATUS_NOT_ACCEPTABLE if a problem
* occurs when accessing drm framework.
* Downloads.Impl.STATUS_UNKNOWN_ERROR if a general error occurred.
*/
public int close(String filename) {
DrmConvertedStatus convertedStatus = null;
int result = Downloads.Impl.STATUS_UNKNOWN_ERROR;
if (mDrmClient != null && mConvertSessionId >= 0) {
try {
convertedStatus = mDrmClient.closeConvertSession(mConvertSessionId);
if (convertedStatus == null ||
convertedStatus.statusCode != DrmConvertedStatus.STATUS_OK ||
convertedStatus.convertedData == null) {
result = Downloads.Impl.STATUS_NOT_ACCEPTABLE;
} else {
RandomAccessFile rndAccessFile = null;
try {
rndAccessFile = new RandomAccessFile(filename, "rw");
rndAccessFile.seek(convertedStatus.offset);
rndAccessFile.write(convertedStatus.convertedData);
result = Downloads.Impl.STATUS_SUCCESS;
} catch (FileNotFoundException e) {
result = Downloads.Impl.STATUS_FILE_ERROR;
Log.w(TAG, "File: " + filename + " could not be found.", e);
} catch (IOException e) {
result = Downloads.Impl.STATUS_FILE_ERROR;
Log.w(TAG, "Could not access File: " + filename + " .", e);
} catch (IllegalArgumentException e) {
result = Downloads.Impl.STATUS_FILE_ERROR;
Log.w(TAG, "Could not open file in mode: rw", e);
} catch (SecurityException e) {
Log.w(TAG, "Access to File: " + filename +
" was denied denied by SecurityManager.", e);
} finally {
if (rndAccessFile != null) {
try {
rndAccessFile.close();
} catch (IOException e) {
result = Downloads.Impl.STATUS_FILE_ERROR;
Log.w(TAG, "Failed to close File:" + filename
+ ".", e);
}
}
}
}
} catch (IllegalStateException e) {
Log.w(TAG, "Could not close convertsession. Convertsession: " +
mConvertSessionId, e);
}
}
return result;
}
}
src/com/android/messaging/mmslib/util/PduCache.java
-262
View File
@@ -1,262 +0,0 @@
/*
* Copyright (C) 2008 Esmertec AG.
* Copyright (C) 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 com.android.messaging.mmslib.util;
import android.content.ContentUris;
import android.content.UriMatcher;
import android.net.Uri;
import android.provider.Telephony.Mms;
import android.support.v4.util.SimpleArrayMap;
import android.util.Log;
import android.util.SparseArray;
import java.util.HashSet;
public final class PduCache extends AbstractCache<Uri, PduCacheEntry> {
private static final String TAG = "PduCache";
private static final boolean LOCAL_LOGV = false;
private static final int MMS_ALL = 0;
private static final int MMS_ALL_ID = 1;
private static final int MMS_INBOX = 2;
private static final int MMS_INBOX_ID = 3;
private static final int MMS_SENT = 4;
private static final int MMS_SENT_ID = 5;
private static final int MMS_DRAFTS = 6;
private static final int MMS_DRAFTS_ID = 7;
private static final int MMS_OUTBOX = 8;
private static final int MMS_OUTBOX_ID = 9;
private static final int MMS_CONVERSATION = 10;
private static final int MMS_CONVERSATION_ID = 11;
private static final UriMatcher URI_MATCHER;
private static final SparseArray<Integer> MATCH_TO_MSGBOX_ID_MAP;
private static PduCache sInstance;
static {
URI_MATCHER = new UriMatcher(UriMatcher.NO_MATCH);
URI_MATCHER.addURI("mms", null, MMS_ALL);
URI_MATCHER.addURI("mms", "#", MMS_ALL_ID);
URI_MATCHER.addURI("mms", "inbox", MMS_INBOX);
URI_MATCHER.addURI("mms", "inbox/#", MMS_INBOX_ID);
URI_MATCHER.addURI("mms", "sent", MMS_SENT);
URI_MATCHER.addURI("mms", "sent/#", MMS_SENT_ID);
URI_MATCHER.addURI("mms", "drafts", MMS_DRAFTS);
URI_MATCHER.addURI("mms", "drafts/#", MMS_DRAFTS_ID);
URI_MATCHER.addURI("mms", "outbox", MMS_OUTBOX);
URI_MATCHER.addURI("mms", "outbox/#", MMS_OUTBOX_ID);
URI_MATCHER.addURI("mms-sms", "conversations", MMS_CONVERSATION);
URI_MATCHER.addURI("mms-sms", "conversations/#", MMS_CONVERSATION_ID);
MATCH_TO_MSGBOX_ID_MAP = new SparseArray<Integer>();
MATCH_TO_MSGBOX_ID_MAP.put(MMS_INBOX, Mms.MESSAGE_BOX_INBOX);
MATCH_TO_MSGBOX_ID_MAP.put(MMS_SENT, Mms.MESSAGE_BOX_SENT);
MATCH_TO_MSGBOX_ID_MAP.put(MMS_DRAFTS, Mms.MESSAGE_BOX_DRAFTS);
MATCH_TO_MSGBOX_ID_MAP.put(MMS_OUTBOX, Mms.MESSAGE_BOX_OUTBOX);
}
private final SparseArray<HashSet<Uri>> mMessageBoxes;
private final SimpleArrayMap<Long, HashSet<Uri>> mThreads;
private final HashSet<Uri> mUpdating;
private PduCache() {
mMessageBoxes = new SparseArray<HashSet<Uri>>();
mThreads = new SimpleArrayMap<Long, HashSet<Uri>>();
mUpdating = new HashSet<Uri>();
}
public static final synchronized PduCache getInstance() {
if (sInstance == null) {
if (LOCAL_LOGV) {
Log.v(TAG, "Constructing new PduCache instance.");
}
sInstance = new PduCache();
}
return sInstance;
}
@Override
public synchronized boolean put(Uri uri, PduCacheEntry entry) {
int msgBoxId = entry.getMessageBox();
HashSet<Uri> msgBox = mMessageBoxes.get(msgBoxId);
if (msgBox == null) {
msgBox = new HashSet<Uri>();
mMessageBoxes.put(msgBoxId, msgBox);
}
long threadId = entry.getThreadId();
HashSet<Uri> thread = mThreads.get(threadId);
if (thread == null) {
thread = new HashSet<Uri>();
mThreads.put(threadId, thread);
}
Uri finalKey = normalizeKey(uri);
boolean result = super.put(finalKey, entry);
if (result) {
msgBox.add(finalKey);
thread.add(finalKey);
}
setUpdating(uri, false);
return result;
}
public synchronized void setUpdating(Uri uri, boolean updating) {
if (updating) {
mUpdating.add(uri);
} else {
mUpdating.remove(uri);
}
}
public synchronized boolean isUpdating(Uri uri) {
return mUpdating.contains(uri);
}
@Override
public synchronized PduCacheEntry purge(Uri uri) {
int match = URI_MATCHER.match(uri);
switch (match) {
case MMS_ALL_ID:
return purgeSingleEntry(uri);
case MMS_INBOX_ID:
case MMS_SENT_ID:
case MMS_DRAFTS_ID:
case MMS_OUTBOX_ID:
String msgId = uri.getLastPathSegment();
return purgeSingleEntry(Uri.withAppendedPath(Mms.CONTENT_URI, msgId));
// Implicit batch of purge, return null.
case MMS_ALL:
case MMS_CONVERSATION:
purgeAll();
return null;
case MMS_INBOX:
case MMS_SENT:
case MMS_DRAFTS:
case MMS_OUTBOX:
purgeByMessageBox(MATCH_TO_MSGBOX_ID_MAP.get(match));
return null;
case MMS_CONVERSATION_ID:
purgeByThreadId(ContentUris.parseId(uri));
return null;
default:
return null;
}
}
private PduCacheEntry purgeSingleEntry(Uri key) {
mUpdating.remove(key);
PduCacheEntry entry = super.purge(key);
if (entry != null) {
removeFromThreads(key, entry);
removeFromMessageBoxes(key, entry);
return entry;
}
return null;
}
@Override
public synchronized void purgeAll() {
super.purgeAll();
mMessageBoxes.clear();
mThreads.clear();
mUpdating.clear();
}
/**
* @param uri The Uri to be normalized.
* @return Uri The normalized key of cached entry.
*/
private Uri normalizeKey(Uri uri) {
int match = URI_MATCHER.match(uri);
Uri normalizedKey = null;
switch (match) {
case MMS_ALL_ID:
normalizedKey = uri;
break;
case MMS_INBOX_ID:
case MMS_SENT_ID:
case MMS_DRAFTS_ID:
case MMS_OUTBOX_ID:
String msgId = uri.getLastPathSegment();
normalizedKey = Uri.withAppendedPath(Mms.CONTENT_URI, msgId);
break;
default:
return null;
}
if (LOCAL_LOGV) {
Log.v(TAG, uri + " -> " + normalizedKey);
}
return normalizedKey;
}
private void purgeByMessageBox(Integer msgBoxId) {
if (LOCAL_LOGV) {
Log.v(TAG, "Purge cache in message box: " + msgBoxId);
}
if (msgBoxId != null) {
HashSet<Uri> msgBox = mMessageBoxes.get(msgBoxId);
mMessageBoxes.remove(msgBoxId);
if (msgBox != null) {
for (Uri key : msgBox) {
mUpdating.remove(key);
PduCacheEntry entry = super.purge(key);
if (entry != null) {
removeFromThreads(key, entry);
}
}
}
}
}
private void removeFromThreads(Uri key, PduCacheEntry entry) {
HashSet<Uri> thread = mThreads.get(entry.getThreadId());
if (thread != null) {
thread.remove(key);
}
}
private void purgeByThreadId(long threadId) {
if (LOCAL_LOGV) {
Log.v(TAG, "Purge cache in thread: " + threadId);
}
HashSet<Uri> thread = mThreads.remove(threadId);
if (thread != null) {
for (Uri key : thread) {
mUpdating.remove(key);
PduCacheEntry entry = super.purge(key);
if (entry != null) {
removeFromMessageBoxes(key, entry);
}
}
}
}
private void removeFromMessageBoxes(Uri key, PduCacheEntry entry) {
HashSet<Uri> msgBox = mThreads.get(Long.valueOf(entry.getMessageBox()));
if (msgBox != null) {
msgBox.remove(key);
}
}
}
src/com/android/messaging/mmslib/util/PduCacheEntry.java
-44
View File
@@ -1,44 +0,0 @@
/*
* Copyright (C) 2008 Esmertec AG.
* Copyright (C) 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 com.android.messaging.mmslib.util;
import com.android.messaging.mmslib.pdu.GenericPdu;
public final class PduCacheEntry {
private final GenericPdu mPdu;
private final int mMessageBox;
private final long mThreadId;
public PduCacheEntry(GenericPdu pdu, int msgBox, long threadId) {
mPdu = pdu;
mMessageBox = msgBox;
mThreadId = threadId;
}
public GenericPdu getPdu() {
return mPdu;
}
public int getMessageBox() {
return mMessageBox;
}
public long getThreadId() {
return mThreadId;
}
}