auto import from //depot/cupcake/@135843
diff --git a/Android.mk b/Android.mk
new file mode 100644
index 0000000..2b16664
--- /dev/null
+++ b/Android.mk
@@ -0,0 +1,13 @@
+LOCAL_PATH:= $(call my-dir)
+include $(CLEAR_VARS)
+
+LOCAL_MODULE_TAGS := user development
+
+LOCAL_SRC_FILES := $(call all-subdir-java-files)
+
+LOCAL_JAVA_LIBRARIES :=
+
+LOCAL_PACKAGE_NAME := TelephonyProvider
+LOCAL_CERTIFICATE := platform
+
+include $(BUILD_PACKAGE)
diff --git a/AndroidManifest.xml b/AndroidManifest.xml
new file mode 100644
index 0000000..c1af548
--- /dev/null
+++ b/AndroidManifest.xml
@@ -0,0 +1,39 @@
+<?xml version="1.0" encoding="utf-8"?>
+<!-- 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.
+-->
+
+<manifest xmlns:android="http://schemas.android.com/apk/res/android"
+ package="com.android.providers.telephony"
+ android:sharedUserId="android.uid.phone"
+>
+
+ <application android:process="com.android.phone"
+ android:allowClearUserData="false"
+ android:label="Dialer Storage"
+ android:icon="@drawable/ic_launcher_phone">
+ <provider android:name="TelephonyProvider" android:authorities="telephony" android:multiprocess="true" />
+ <provider android:name="SmsProvider" android:authorities="sms" android:multiprocess="true"
+ android:readPermission="android.permission.READ_SMS"
+ android:writePermission="android.permission.WRITE_SMS" />
+ <provider android:name="MmsProvider" android:authorities="mms" android:multiprocess="true"
+ android:readPermission="android.permission.READ_SMS"
+ android:writePermission="android.permission.WRITE_SMS">
+ <grant-uri-permission android:pathPrefix="/part/" />
+ </provider>
+ <provider android:name="MmsSmsProvider" android:authorities="mms-sms" android:multiprocess="true"
+ android:readPermission="android.permission.READ_SMS"
+ android:writePermission="android.permission.WRITE_SMS" />
+ </application>
+</manifest>
diff --git a/MODULE_LICENSE_APACHE2 b/MODULE_LICENSE_APACHE2
new file mode 100644
index 0000000..e69de29
--- /dev/null
+++ b/MODULE_LICENSE_APACHE2
diff --git a/NOTICE b/NOTICE
new file mode 100644
index 0000000..c5b1efa
--- /dev/null
+++ b/NOTICE
@@ -0,0 +1,190 @@
+
+ Copyright (c) 2005-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.
+
+ 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.
+
+
+ Apache License
+ Version 2.0, January 2004
+ http://www.apache.org/licenses/
+
+ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+ 1. Definitions.
+
+ "License" shall mean the terms and conditions for use, reproduction,
+ and distribution as defined by Sections 1 through 9 of this document.
+
+ "Licensor" shall mean the copyright owner or entity authorized by
+ the copyright owner that is granting the License.
+
+ "Legal Entity" shall mean the union of the acting entity and all
+ other entities that control, are controlled by, or are under common
+ control with that entity. For the purposes of this definition,
+ "control" means (i) the power, direct or indirect, to cause the
+ direction or management of such entity, whether by contract or
+ otherwise, or (ii) ownership of fifty percent (50%) or more of the
+ outstanding shares, or (iii) beneficial ownership of such entity.
+
+ "You" (or "Your") shall mean an individual or Legal Entity
+ exercising permissions granted by this License.
+
+ "Source" form shall mean the preferred form for making modifications,
+ including but not limited to software source code, documentation
+ source, and configuration files.
+
+ "Object" form shall mean any form resulting from mechanical
+ transformation or translation of a Source form, including but
+ not limited to compiled object code, generated documentation,
+ and conversions to other media types.
+
+ "Work" shall mean the work of authorship, whether in Source or
+ Object form, made available under the License, as indicated by a
+ copyright notice that is included in or attached to the work
+ (an example is provided in the Appendix below).
+
+ "Derivative Works" shall mean any work, whether in Source or Object
+ form, that is based on (or derived from) the Work and for which the
+ editorial revisions, annotations, elaborations, or other modifications
+ represent, as a whole, an original work of authorship. For the purposes
+ of this License, Derivative Works shall not include works that remain
+ separable from, or merely link (or bind by name) to the interfaces of,
+ the Work and Derivative Works thereof.
+
+ "Contribution" shall mean any work of authorship, including
+ the original version of the Work and any modifications or additions
+ to that Work or Derivative Works thereof, that is intentionally
+ submitted to Licensor for inclusion in the Work by the copyright owner
+ or by an individual or Legal Entity authorized to submit on behalf of
+ the copyright owner. For the purposes of this definition, "submitted"
+ means any form of electronic, verbal, or written communication sent
+ to the Licensor or its representatives, including but not limited to
+ communication on electronic mailing lists, source code control systems,
+ and issue tracking systems that are managed by, or on behalf of, the
+ Licensor for the purpose of discussing and improving the Work, but
+ excluding communication that is conspicuously marked or otherwise
+ designated in writing by the copyright owner as "Not a Contribution."
+
+ "Contributor" shall mean Licensor and any individual or Legal Entity
+ on behalf of whom a Contribution has been received by Licensor and
+ subsequently incorporated within the Work.
+
+ 2. Grant of Copyright License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ copyright license to reproduce, prepare Derivative Works of,
+ publicly display, publicly perform, sublicense, and distribute the
+ Work and such Derivative Works in Source or Object form.
+
+ 3. Grant of Patent License. Subject to the terms and conditions of
+ this License, each Contributor hereby grants to You a perpetual,
+ worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+ (except as stated in this section) patent license to make, have made,
+ use, offer to sell, sell, import, and otherwise transfer the Work,
+ where such license applies only to those patent claims licensable
+ by such Contributor that are necessarily infringed by their
+ Contribution(s) alone or by combination of their Contribution(s)
+ with the Work to which such Contribution(s) was submitted. If You
+ institute patent litigation against any entity (including a
+ cross-claim or counterclaim in a lawsuit) alleging that the Work
+ or a Contribution incorporated within the Work constitutes direct
+ or contributory patent infringement, then any patent licenses
+ granted to You under this License for that Work shall terminate
+ as of the date such litigation is filed.
+
+ 4. Redistribution. You may reproduce and distribute copies of the
+ Work or Derivative Works thereof in any medium, with or without
+ modifications, and in Source or Object form, provided that You
+ meet the following conditions:
+
+ (a) You must give any other recipients of the Work or
+ Derivative Works a copy of this License; and
+
+ (b) You must cause any modified files to carry prominent notices
+ stating that You changed the files; and
+
+ (c) You must retain, in the Source form of any Derivative Works
+ that You distribute, all copyright, patent, trademark, and
+ attribution notices from the Source form of the Work,
+ excluding those notices that do not pertain to any part of
+ the Derivative Works; and
+
+ (d) If the Work includes a "NOTICE" text file as part of its
+ distribution, then any Derivative Works that You distribute must
+ include a readable copy of the attribution notices contained
+ within such NOTICE file, excluding those notices that do not
+ pertain to any part of the Derivative Works, in at least one
+ of the following places: within a NOTICE text file distributed
+ as part of the Derivative Works; within the Source form or
+ documentation, if provided along with the Derivative Works; or,
+ within a display generated by the Derivative Works, if and
+ wherever such third-party notices normally appear. The contents
+ of the NOTICE file are for informational purposes only and
+ do not modify the License. You may add Your own attribution
+ notices within Derivative Works that You distribute, alongside
+ or as an addendum to the NOTICE text from the Work, provided
+ that such additional attribution notices cannot be construed
+ as modifying the License.
+
+ You may add Your own copyright statement to Your modifications and
+ may provide additional or different license terms and conditions
+ for use, reproduction, or distribution of Your modifications, or
+ for any such Derivative Works as a whole, provided Your use,
+ reproduction, and distribution of the Work otherwise complies with
+ the conditions stated in this License.
+
+ 5. Submission of Contributions. Unless You explicitly state otherwise,
+ any Contribution intentionally submitted for inclusion in the Work
+ by You to the Licensor shall be under the terms and conditions of
+ this License, without any additional terms or conditions.
+ Notwithstanding the above, nothing herein shall supersede or modify
+ the terms of any separate license agreement you may have executed
+ with Licensor regarding such Contributions.
+
+ 6. Trademarks. This License does not grant permission to use the trade
+ names, trademarks, service marks, or product names of the Licensor,
+ except as required for reasonable and customary use in describing the
+ origin of the Work and reproducing the content of the NOTICE file.
+
+ 7. Disclaimer of Warranty. Unless required by applicable law or
+ agreed to in writing, Licensor provides the Work (and each
+ Contributor provides its Contributions) on an "AS IS" BASIS,
+ WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+ implied, including, without limitation, any warranties or conditions
+ of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+ PARTICULAR PURPOSE. You are solely responsible for determining the
+ appropriateness of using or redistributing the Work and assume any
+ risks associated with Your exercise of permissions under this License.
+
+ 8. Limitation of Liability. In no event and under no legal theory,
+ whether in tort (including negligence), contract, or otherwise,
+ unless required by applicable law (such as deliberate and grossly
+ negligent acts) or agreed to in writing, shall any Contributor be
+ liable to You for damages, including any direct, indirect, special,
+ incidental, or consequential damages of any character arising as a
+ result of this License or out of the use or inability to use the
+ Work (including but not limited to damages for loss of goodwill,
+ work stoppage, computer failure or malfunction, or any and all
+ other commercial damages or losses), even if such Contributor
+ has been advised of the possibility of such damages.
+
+ 9. Accepting Warranty or Additional Liability. While redistributing
+ the Work or Derivative Works thereof, You may choose to offer,
+ and charge a fee for, acceptance of support, warranty, indemnity,
+ or other liability obligations and/or rights consistent with this
+ License. However, in accepting such obligations, You may act only
+ on Your own behalf and on Your sole responsibility, not on behalf
+ of any other Contributor, and only if You agree to indemnify,
+ defend, and hold each Contributor harmless for any liability
+ incurred by, or claims asserted against, such Contributor by reason
+ of your accepting any such warranty or additional liability.
+
+ END OF TERMS AND CONDITIONS
+
diff --git a/res/drawable/ic_launcher_phone.png b/res/drawable/ic_launcher_phone.png
new file mode 100644
index 0000000..4e613ec
--- /dev/null
+++ b/res/drawable/ic_launcher_phone.png
Binary files differ
diff --git a/src/com/android/providers/telephony/MmsProvider.java b/src/com/android/providers/telephony/MmsProvider.java
new file mode 100644
index 0000000..37d1787
--- /dev/null
+++ b/src/com/android/providers/telephony/MmsProvider.java
@@ -0,0 +1,796 @@
+/*
+ * 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.providers.telephony;
+
+import com.google.android.mms.pdu.PduHeaders;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.Intent;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.ParcelFileDescriptor;
+import android.provider.BaseColumns;
+import android.provider.Telephony.Mms;
+import android.provider.Telephony.MmsSms;
+import android.provider.Telephony.Mms.Addr;
+import android.provider.Telephony.Mms.Part;
+import android.provider.Telephony.Mms.Rate;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.IOException;
+
+/**
+ * The class to provide base facility to access MMS related content,
+ * which is stored in a SQLite database and in the file system.
+ */
+public class MmsProvider extends ContentProvider {
+ static final String TABLE_PDU = "pdu";
+ static final String TABLE_ADDR = "addr";
+ static final String TABLE_PART = "part";
+ static final String TABLE_RATE = "rate";
+ static final String TABLE_DRM = "drm";
+
+ @Override
+ public boolean onCreate() {
+ mOpenHelper = MmsSmsDatabaseHelper.getInstance(getContext());
+ return true;
+ }
+
+ @Override
+ public Cursor query(Uri uri, String[] projection,
+ String selection, String[] selectionArgs, String sortOrder) {
+ SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+
+ // Generate the body of the query.
+ int match = sURLMatcher.match(uri);
+ if (LOCAL_LOGV) {
+ Log.v(TAG, "Query uri=" + uri + ", match=" + match);
+ }
+
+ switch (match) {
+ case MMS_ALL:
+ constructQueryForBox(qb, Mms.MESSAGE_BOX_ALL);
+ break;
+ case MMS_INBOX:
+ constructQueryForBox(qb, Mms.MESSAGE_BOX_INBOX);
+ break;
+ case MMS_SENT:
+ constructQueryForBox(qb, Mms.MESSAGE_BOX_SENT);
+ break;
+ case MMS_DRAFTS:
+ constructQueryForBox(qb, Mms.MESSAGE_BOX_DRAFTS);
+ break;
+ case MMS_OUTBOX:
+ constructQueryForBox(qb, Mms.MESSAGE_BOX_OUTBOX);
+ break;
+ case MMS_ALL_ID:
+ qb.setTables(TABLE_PDU);
+ qb.appendWhere(Mms._ID + "=" + uri.getPathSegments().get(0));
+ break;
+ case MMS_INBOX_ID:
+ case MMS_SENT_ID:
+ case MMS_DRAFTS_ID:
+ case MMS_OUTBOX_ID:
+ qb.setTables(TABLE_PDU);
+ qb.appendWhere(Mms._ID + "=" + uri.getPathSegments().get(1));
+ qb.appendWhere(" AND " + Mms.MESSAGE_BOX + "="
+ + getMessageBoxByMatch(match));
+ break;
+ case MMS_ALL_PART:
+ qb.setTables(TABLE_PART);
+ break;
+ case MMS_MSG_PART:
+ qb.setTables(TABLE_PART);
+ qb.appendWhere(Part.MSG_ID + "=" + uri.getPathSegments().get(0));
+ break;
+ case MMS_PART_ID:
+ qb.setTables(TABLE_PART);
+ qb.appendWhere(Part._ID + "=" + uri.getPathSegments().get(1));
+ break;
+ case MMS_MSG_ADDR:
+ qb.setTables(TABLE_ADDR);
+ qb.appendWhere(Addr.MSG_ID + "=" + uri.getPathSegments().get(0));
+ break;
+ case MMS_REPORT_STATUS:
+ /*
+ SELECT DISTINCT address,
+ T.delivery_status AS delivery_status,
+ T.read_status AS read_status
+ FROM addr
+ INNER JOIN (SELECT P1._id AS id1, P2._id AS id2, P3._id AS id3,
+ ifnull(P2.st, 0) AS delivery_status,
+ ifnull(P3.read_status, 0) AS read_status
+ FROM pdu P1
+ INNER JOIN pdu P2
+ ON P1.m_id = P2.m_id AND P2.m_type = 134
+ LEFT JOIN pdu P3
+ ON P1.m_id = P3.m_id AND P3.m_type = 136
+ UNION
+ SELECT P1._id AS id1, P2._id AS id2, P3._id AS id3,
+ ifnull(P2.st, 0) AS delivery_status,
+ ifnull(P3.read_status, 0) AS read_status
+ FROM pdu P1
+ INNER JOIN pdu P3
+ ON P1.m_id = P3.m_id AND P3.m_type = 136
+ LEFT JOIN pdu P2
+ ON P1.m_id = P2.m_id AND P2.m_type = 134) T
+ ON (msg_id = id2 AND type = 151)
+ OR (msg_id = id3 AND type = 137)
+ WHERE T.id1 = ?;
+ */
+ qb.setTables("addr INNER JOIN (SELECT P1._id AS id1, P2._id" +
+ " AS id2, P3._id AS id3, ifnull(P2.st, 0) AS" +
+ " delivery_status, ifnull(P3.read_status, 0) AS" +
+ " read_status FROM pdu P1 INNER JOIN pdu P2 ON" +
+ " P1.m_id=P2.m_id AND P2.m_type=134 LEFT JOIN" +
+ " pdu P3 ON P1.m_id=P3.m_id AND P3.m_type=136" +
+ " UNION SELECT P1._id AS id1, P2._id AS id2, P3._id" +
+ " AS id3, ifnull(P2.st, 0) AS delivery_status," +
+ " ifnull(P3.read_status, 0) AS read_status FROM" +
+ " pdu P1 INNER JOIN pdu P3 ON P1.m_id=P3.m_id AND" +
+ " P3.m_type=136 LEFT JOIN pdu P2 ON P1.m_id=P2.m_id" +
+ " AND P2.m_type=134) T ON (msg_id=id2 AND type=151)" +
+ " OR (msg_id=id3 AND type=137)");
+ qb.appendWhere("T.id1 = " + uri.getLastPathSegment());
+ qb.setDistinct(true);
+ break;
+ case MMS_REPORT_REQUEST:
+ /*
+ SELECT address, d_rpt, rr
+ FROM addr join pdu on pdu._id = addr.msg_id
+ WHERE pdu._id = messageId AND addr.type = 151
+ */
+ qb.setTables(TABLE_ADDR + " join " +
+ TABLE_PDU + " on pdu._id = addr.msg_id");
+ qb.appendWhere("pdu._id = " + uri.getLastPathSegment());
+ qb.appendWhere(" AND " + "addr.type = " + PduHeaders.TO);
+ break;
+ case MMS_SENDING_RATE:
+ qb.setTables(TABLE_RATE);
+ break;
+ case MMS_DRM_STORAGE_ID:
+ qb.setTables(TABLE_DRM);
+ qb.appendWhere(BaseColumns._ID + "=" + uri.getLastPathSegment());
+ break;
+ default:
+ Log.e(TAG, "Invalid request: " + uri);
+ return null;
+ }
+
+ String finalSortOrder = null;
+ if (TextUtils.isEmpty(sortOrder)) {
+ if (qb.getTables().equals(TABLE_PDU)) {
+ finalSortOrder = Mms.DATE + " DESC";
+ } else if (qb.getTables().equals(TABLE_PART)) {
+ finalSortOrder = Part.SEQ;
+ }
+ } else {
+ finalSortOrder = sortOrder;
+ }
+
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ Cursor ret = qb.query(db, projection, selection,
+ selectionArgs, null, null, finalSortOrder);
+
+ // TODO: Does this need to be a URI for this provider.
+ ret.setNotificationUri(getContext().getContentResolver(), uri);
+ return ret;
+ }
+
+ private void constructQueryForBox(SQLiteQueryBuilder qb, int msgBox) {
+ qb.setTables(TABLE_PDU);
+
+ if (msgBox != Mms.MESSAGE_BOX_ALL) {
+ qb.appendWhere(Mms.MESSAGE_BOX + "=" + msgBox);
+ }
+ }
+
+ @Override
+ public String getType(Uri uri) {
+ int match = sURLMatcher.match(uri);
+ switch (match) {
+ case MMS_ALL:
+ case MMS_INBOX:
+ case MMS_SENT:
+ case MMS_DRAFTS:
+ case MMS_OUTBOX:
+ return VND_ANDROID_DIR_MMS;
+ case MMS_ALL_ID:
+ case MMS_INBOX_ID:
+ case MMS_SENT_ID:
+ case MMS_DRAFTS_ID:
+ case MMS_OUTBOX_ID:
+ return VND_ANDROID_MMS;
+ case MMS_PART_ID: {
+ Cursor cursor = mOpenHelper.getReadableDatabase().query(
+ TABLE_PART, new String[] { Part.CONTENT_TYPE },
+ Part._ID + " = ?", new String[] { uri.getLastPathSegment() },
+ null, null, null);
+ if (cursor != null) {
+ try {
+ if ((cursor.getCount() == 1) && cursor.moveToFirst()) {
+ return cursor.getString(0);
+ } else {
+ Log.e(TAG, "cursor.count() != 1: " + uri);
+ }
+ } finally {
+ cursor.close();
+ }
+ } else {
+ Log.e(TAG, "cursor == null: " + uri);
+ }
+ return "*/*";
+ }
+ case MMS_ALL_PART:
+ case MMS_MSG_PART:
+ case MMS_MSG_ADDR:
+ default:
+ return "*/*";
+ }
+ }
+
+ @Override
+ public Uri insert(Uri uri, ContentValues values) {
+ int msgBox = Mms.MESSAGE_BOX_ALL;
+ boolean notify = true;
+
+ int match = sURLMatcher.match(uri);
+ if (LOCAL_LOGV) {
+ Log.v(TAG, "Insert uri=" + uri + ", match=" + match);
+ }
+
+ String table = TABLE_PDU;
+ switch (match) {
+ case MMS_ALL:
+ Object msgBoxObj = values.getAsInteger(Mms.MESSAGE_BOX);
+ if (msgBoxObj != null) {
+ msgBox = (Integer) msgBoxObj;
+ }
+ else {
+ // default to inbox
+ msgBox = Mms.MESSAGE_BOX_INBOX;
+ }
+ break;
+ case MMS_INBOX:
+ msgBox = Mms.MESSAGE_BOX_INBOX;
+ break;
+ case MMS_SENT:
+ msgBox = Mms.MESSAGE_BOX_SENT;
+ break;
+ case MMS_DRAFTS:
+ msgBox = Mms.MESSAGE_BOX_DRAFTS;
+ break;
+ case MMS_OUTBOX:
+ msgBox = Mms.MESSAGE_BOX_OUTBOX;
+ break;
+ case MMS_MSG_PART:
+ notify = false;
+ table = TABLE_PART;
+ break;
+ case MMS_MSG_ADDR:
+ notify = false;
+ table = TABLE_ADDR;
+ break;
+ case MMS_SENDING_RATE:
+ notify = false;
+ table = TABLE_RATE;
+ break;
+ case MMS_DRM_STORAGE:
+ notify = false;
+ table = TABLE_DRM;
+ break;
+ default:
+ Log.e(TAG, "Invalid request: " + uri);
+ return null;
+ }
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ ContentValues finalValues;
+ Uri res = Mms.CONTENT_URI;
+ long rowId;
+
+ if (table.equals(TABLE_PDU)) {
+ boolean addDate = !values.containsKey(Mms.DATE);
+ boolean addMsgBox = !values.containsKey(Mms.MESSAGE_BOX);
+
+ // Filter keys we don't support yet.
+ filterUnsupportedKeys(values);
+
+ // TODO: Should initialValues be validated, e.g. if it
+ // missed some significant keys?
+ finalValues = new ContentValues(values);
+
+ long timeInMillis = System.currentTimeMillis();
+
+ if (addDate) {
+ finalValues.put(Mms.DATE, timeInMillis / 1000L);
+ }
+
+ if (addMsgBox && (msgBox != Mms.MESSAGE_BOX_ALL)) {
+ finalValues.put(Mms.MESSAGE_BOX, msgBox);
+ }
+
+ if (msgBox != Mms.MESSAGE_BOX_INBOX) {
+ // Mark all non-inbox messages read.
+ finalValues.put(Mms.READ, 1);
+ }
+
+ if ((rowId = db.insert(table, null, finalValues)) <= 0) {
+ Log.e(TAG, "MmsProvider.insert: failed! " + finalValues);
+ return null;
+ }
+
+ res = Uri.parse(res + "/" + rowId);
+
+ } else if (table.equals(TABLE_ADDR)) {
+ finalValues = new ContentValues(values);
+ finalValues.put(Addr.MSG_ID, uri.getPathSegments().get(0));
+
+ if ((rowId = db.insert(table, null, finalValues)) <= 0) {
+ Log.e(TAG, "Failed to insert address: " + finalValues);
+ return null;
+ }
+
+ res = Uri.parse(res + "/addr/" + rowId);
+ } else if (table.equals(TABLE_PART)) {
+ finalValues = new ContentValues(values);
+
+ if (match == MMS_MSG_PART) {
+ finalValues.put(Part.MSG_ID, uri.getPathSegments().get(0));
+ }
+
+ // Generate the '_data' field of the part with default
+ // permission settings.
+ String path = getContext().getDir("parts", 0).getPath()
+ + "/PART_" + System.currentTimeMillis();
+
+ finalValues.put(Part._DATA, path);
+
+ File partFile = new File(path);
+ if (!partFile.exists()) {
+ try {
+ if (!partFile.createNewFile()) {
+ throw new IllegalStateException(
+ "Unable to create new partFile: " + path);
+ }
+ } catch (IOException e) {
+ Log.e(TAG, "createNewFile", e);
+ throw new IllegalStateException(
+ "Unable to create new partFile: " + path);
+ }
+ }
+
+ if ((rowId = db.insert(table, null, finalValues)) <= 0) {
+ Log.e(TAG, "MmsProvider.insert: failed! " + finalValues);
+ return null;
+ }
+
+ res = Uri.parse(res + "/part/" + rowId);
+ } else if (table.equals(TABLE_RATE)) {
+ long now = values.getAsLong(Rate.SENT_TIME);
+ long oneHourAgo = now - 1000 * 60 * 60;
+ // Delete all unused rows (time earlier than one hour ago).
+ db.delete(table, Rate.SENT_TIME + "<=" + oneHourAgo, null);
+ db.insert(table, null, values);
+ } else if (table.equals(TABLE_DRM)) {
+ String path = getContext().getDir("parts", 0).getPath()
+ + "/PART_" + System.currentTimeMillis();
+ finalValues = new ContentValues(1);
+ finalValues.put("_data", path);
+
+ File partFile = new File(path);
+ if (!partFile.exists()) {
+ try {
+ if (!partFile.createNewFile()) {
+ throw new IllegalStateException(
+ "Unable to create new file: " + path);
+ }
+ } catch (IOException e) {
+ Log.e(TAG, "createNewFile", e);
+ throw new IllegalStateException(
+ "Unable to create new file: " + path);
+ }
+ }
+
+ if ((rowId = db.insert(table, null, finalValues)) <= 0) {
+ Log.e(TAG, "MmsProvider.insert: failed! " + finalValues);
+ return null;
+ }
+ res = Uri.parse(res + "/drm/" + rowId);
+ } else {
+ throw new AssertionError("Unknown table type: " + table);
+ }
+
+ if (notify) {
+ notifyChange();
+ }
+ return res;
+ }
+
+ private int getMessageBoxByMatch(int match) {
+ switch (match) {
+ case MMS_INBOX_ID:
+ case MMS_INBOX:
+ return Mms.MESSAGE_BOX_INBOX;
+ case MMS_SENT_ID:
+ case MMS_SENT:
+ return Mms.MESSAGE_BOX_SENT;
+ case MMS_DRAFTS_ID:
+ case MMS_DRAFTS:
+ return Mms.MESSAGE_BOX_DRAFTS;
+ case MMS_OUTBOX_ID:
+ case MMS_OUTBOX:
+ return Mms.MESSAGE_BOX_OUTBOX;
+ default:
+ throw new IllegalArgumentException("bad Arg: " + match);
+ }
+ }
+
+ @Override
+ public int delete(Uri uri, String selection,
+ String[] selectionArgs) {
+ int match = sURLMatcher.match(uri);
+ if (LOCAL_LOGV) {
+ Log.v(TAG, "Delete uri=" + uri + ", match=" + match);
+ }
+
+ String table, extraSelection = null;
+ boolean notify = false;
+
+ switch (match) {
+ case MMS_ALL_ID:
+ case MMS_INBOX_ID:
+ case MMS_SENT_ID:
+ case MMS_DRAFTS_ID:
+ case MMS_OUTBOX_ID:
+ notify = true;
+ table = TABLE_PDU;
+ extraSelection = Mms._ID + "=" + uri.getLastPathSegment();
+ break;
+ case MMS_ALL:
+ case MMS_INBOX:
+ case MMS_SENT:
+ case MMS_DRAFTS:
+ case MMS_OUTBOX:
+ notify = true;
+ table = TABLE_PDU;
+ if (match != MMS_ALL) {
+ int msgBox = getMessageBoxByMatch(match);
+ extraSelection = Mms.MESSAGE_BOX + "=" + msgBox;
+ }
+ break;
+ case MMS_ALL_PART:
+ table = TABLE_PART;
+ break;
+ case MMS_MSG_PART:
+ table = TABLE_PART;
+ extraSelection = Part.MSG_ID + "=" + uri.getPathSegments().get(0);
+ break;
+ case MMS_PART_ID:
+ table = TABLE_PART;
+ extraSelection = Part._ID + "=" + uri.getPathSegments().get(1);
+ break;
+ case MMS_MSG_ADDR:
+ table = TABLE_ADDR;
+ extraSelection = Addr.MSG_ID + "=" + uri.getPathSegments().get(0);
+ break;
+ case MMS_DRM_STORAGE:
+ table = TABLE_DRM;
+ break;
+ default:
+ Log.w(TAG, "No match for URI '" + uri + "'");
+ return 0;
+ }
+
+ String finalSelection = concatSelections(selection, extraSelection);
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int deletedRows = 0;
+
+ if (TABLE_PDU.equals(table)) {
+ deletedRows = deleteMessages(getContext(), db, finalSelection,
+ selectionArgs, uri);
+ } else if (TABLE_PART.equals(table)) {
+ deletedRows = deleteParts(db, finalSelection, selectionArgs);
+ } else if (TABLE_DRM.equals(table)) {
+ deletedRows = deleteTempDrmData(db, finalSelection, selectionArgs);
+ } else {
+ deletedRows = db.delete(table, finalSelection, selectionArgs);
+ }
+
+ if ((deletedRows > 0) && notify) {
+ notifyChange();
+ }
+ return deletedRows;
+ }
+
+ static int deleteMessages(Context context, SQLiteDatabase db,
+ String selection, String[] selectionArgs, Uri uri) {
+ Cursor cursor = db.query(TABLE_PDU, new String[] { Mms._ID },
+ selection, selectionArgs, null, null, null);
+ if (cursor == null) {
+ return 0;
+ }
+
+ try {
+ if (cursor.getCount() == 0) {
+ return 0;
+ }
+
+ while (cursor.moveToNext()) {
+ deleteParts(db, Part.MSG_ID + " = ?",
+ new String[] { String.valueOf(cursor.getLong(0)) });
+ }
+ } finally {
+ cursor.close();
+ }
+
+ int count = db.delete(TABLE_PDU, selection, selectionArgs);
+ if (count > 0) {
+ Intent intent = new Intent(Mms.Intents.CONTENT_CHANGED_ACTION);
+ intent.putExtra(Mms.Intents.DELETED_CONTENTS, uri);
+ if (LOCAL_LOGV) {
+ Log.v(TAG, "Broadcasting intent: " + intent);
+ }
+ context.sendBroadcast(intent);
+ }
+ return count;
+ }
+
+ private static int deleteParts(SQLiteDatabase db, String selection,
+ String[] selectionArgs) {
+ return deleteDataRows(db, TABLE_PART, selection, selectionArgs);
+ }
+
+ private static int deleteTempDrmData(SQLiteDatabase db, String selection,
+ String[] selectionArgs) {
+ return deleteDataRows(db, TABLE_DRM, selection, selectionArgs);
+ }
+
+ private static int deleteDataRows(SQLiteDatabase db, String table,
+ String selection, String[] selectionArgs) {
+ Cursor cursor = db.query(table, new String[] { "_data" },
+ selection, selectionArgs, null, null, null);
+ if (cursor == null) {
+ // FIXME: This might be an error, ignore it may cause
+ // unpredictable result.
+ return 0;
+ }
+
+ try {
+ if (cursor.getCount() == 0) {
+ return 0;
+ }
+
+ while (cursor.moveToNext()) {
+ try {
+ // Delete the associated files saved on file-system.
+ new File(cursor.getString(0)).delete();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ }
+ }
+ } finally {
+ cursor.close();
+ }
+
+ return db.delete(table, selection, selectionArgs);
+ }
+
+ @Override
+ public int update(Uri uri, ContentValues values,
+ String selection, String[] selectionArgs) {
+ int match = sURLMatcher.match(uri);
+ if (LOCAL_LOGV) {
+ Log.v(TAG, "Update uri=" + uri + ", match=" + match);
+ }
+
+ boolean notify = false;
+ String msgId = null;
+ String table;
+
+ switch (match) {
+ case MMS_ALL_ID:
+ case MMS_INBOX_ID:
+ case MMS_SENT_ID:
+ case MMS_DRAFTS_ID:
+ case MMS_OUTBOX_ID:
+ msgId = uri.getLastPathSegment();
+ // fall-through
+ case MMS_ALL:
+ case MMS_INBOX:
+ case MMS_SENT:
+ case MMS_DRAFTS:
+ case MMS_OUTBOX:
+ notify = true;
+ table = TABLE_PDU;
+ break;
+ case MMS_MSG_PART:
+ case MMS_PART_ID:
+ table = TABLE_PART;
+ break;
+ default:
+ Log.w(TAG, "Update operation for '" + uri + "' not implemented.");
+ return 0;
+ }
+
+ String extraSelection = null;
+ ContentValues finalValues;
+ if (table.equals(TABLE_PDU)) {
+ // Filter keys that we don't support yet.
+ filterUnsupportedKeys(values);
+ finalValues = new ContentValues(values);
+
+ if (msgId != null) {
+ extraSelection = Mms._ID + "=" + msgId;
+ }
+ } else if (table.equals(TABLE_PART)) {
+ finalValues = new ContentValues(values);
+
+ switch (match) {
+ case MMS_MSG_PART:
+ extraSelection = Part.MSG_ID + "=" + uri.getPathSegments().get(0);
+ break;
+ case MMS_PART_ID:
+ extraSelection = Part._ID + "=" + uri.getPathSegments().get(1);
+ break;
+ default:
+ break;
+ }
+ } else {
+ return 0;
+ }
+
+ String finalSelection = concatSelections(selection, extraSelection);
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int count = db.update(table, finalValues, finalSelection, selectionArgs);
+ if (notify && (count > 0)) {
+ notifyChange();
+ }
+ return count;
+ }
+
+ @Override
+ public ParcelFileDescriptor openFile(Uri uri, String mode)
+ throws FileNotFoundException {
+ return openFileHelper(uri, mode);
+ }
+
+ private void filterUnsupportedKeys(ContentValues values) {
+ // Some columns are unsupported. They should therefore
+ // neither be inserted nor updated. Filter them out.
+ values.remove(Mms.DELIVERY_TIME_TOKEN);
+ values.remove(Mms.SENDER_VISIBILITY);
+ values.remove(Mms.REPLY_CHARGING);
+ values.remove(Mms.REPLY_CHARGING_DEADLINE_TOKEN);
+ values.remove(Mms.REPLY_CHARGING_DEADLINE);
+ values.remove(Mms.REPLY_CHARGING_ID);
+ values.remove(Mms.REPLY_CHARGING_SIZE);
+ values.remove(Mms.PREVIOUSLY_SENT_BY);
+ values.remove(Mms.PREVIOUSLY_SENT_DATE);
+ values.remove(Mms.STORE);
+ values.remove(Mms.MM_STATE);
+ values.remove(Mms.MM_FLAGS_TOKEN);
+ values.remove(Mms.MM_FLAGS);
+ values.remove(Mms.STORE_STATUS);
+ values.remove(Mms.STORE_STATUS_TEXT);
+ values.remove(Mms.STORED);
+ values.remove(Mms.TOTALS);
+ values.remove(Mms.MBOX_TOTALS);
+ values.remove(Mms.MBOX_TOTALS_TOKEN);
+ values.remove(Mms.QUOTAS);
+ values.remove(Mms.MBOX_QUOTAS);
+ values.remove(Mms.MBOX_QUOTAS_TOKEN);
+ values.remove(Mms.MESSAGE_COUNT);
+ values.remove(Mms.START);
+ values.remove(Mms.DISTRIBUTION_INDICATOR);
+ values.remove(Mms.ELEMENT_DESCRIPTOR);
+ values.remove(Mms.LIMIT);
+ values.remove(Mms.RECOMMENDED_RETRIEVAL_MODE);
+ values.remove(Mms.RECOMMENDED_RETRIEVAL_MODE_TEXT);
+ values.remove(Mms.STATUS_TEXT);
+ values.remove(Mms.APPLIC_ID);
+ values.remove(Mms.REPLY_APPLIC_ID);
+ values.remove(Mms.AUX_APPLIC_ID);
+ values.remove(Mms.DRM_CONTENT);
+ values.remove(Mms.ADAPTATION_ALLOWED);
+ values.remove(Mms.REPLACE_ID);
+ values.remove(Mms.CANCEL_ID);
+ values.remove(Mms.CANCEL_STATUS);
+
+ // Keys shouldn't be inserted or updated.
+ values.remove(Mms._ID);
+ }
+
+ private void notifyChange() {
+ getContext().getContentResolver().notifyChange(
+ MmsSms.CONTENT_URI, null);
+ }
+
+ private final static String TAG = "MmsProvider";
+ private final static String VND_ANDROID_MMS = "vnd.android/mms";
+ private final static String VND_ANDROID_DIR_MMS = "vnd.android-dir/mms";
+ private final static boolean DEBUG = false;
+ private final static boolean LOCAL_LOGV = DEBUG ? Config.LOGD : Config.LOGV;
+
+ 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_ALL_PART = 10;
+ private static final int MMS_MSG_PART = 11;
+ private static final int MMS_PART_ID = 12;
+ private static final int MMS_MSG_ADDR = 13;
+ private static final int MMS_SENDING_RATE = 14;
+ private static final int MMS_REPORT_STATUS = 15;
+ private static final int MMS_REPORT_REQUEST = 16;
+ private static final int MMS_DRM_STORAGE = 17;
+ private static final int MMS_DRM_STORAGE_ID = 18;
+
+ private static final UriMatcher
+ sURLMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+ static {
+ sURLMatcher.addURI("mms", null, MMS_ALL);
+ sURLMatcher.addURI("mms", "#", MMS_ALL_ID);
+ sURLMatcher.addURI("mms", "inbox", MMS_INBOX);
+ sURLMatcher.addURI("mms", "inbox/#", MMS_INBOX_ID);
+ sURLMatcher.addURI("mms", "sent", MMS_SENT);
+ sURLMatcher.addURI("mms", "sent/#", MMS_SENT_ID);
+ sURLMatcher.addURI("mms", "drafts", MMS_DRAFTS);
+ sURLMatcher.addURI("mms", "drafts/#", MMS_DRAFTS_ID);
+ sURLMatcher.addURI("mms", "outbox", MMS_OUTBOX);
+ sURLMatcher.addURI("mms", "outbox/#", MMS_OUTBOX_ID);
+ sURLMatcher.addURI("mms", "part", MMS_ALL_PART);
+ sURLMatcher.addURI("mms", "#/part", MMS_MSG_PART);
+ sURLMatcher.addURI("mms", "part/#", MMS_PART_ID);
+ sURLMatcher.addURI("mms", "#/addr", MMS_MSG_ADDR);
+ sURLMatcher.addURI("mms", "rate", MMS_SENDING_RATE);
+ sURLMatcher.addURI("mms", "report-status/#", MMS_REPORT_STATUS);
+ sURLMatcher.addURI("mms", "report-request/#", MMS_REPORT_REQUEST);
+ sURLMatcher.addURI("mms", "drm", MMS_DRM_STORAGE);
+ sURLMatcher.addURI("mms", "drm/#", MMS_DRM_STORAGE_ID);
+ }
+
+ private SQLiteOpenHelper mOpenHelper;
+
+ private static String concatSelections(String selection1, String selection2) {
+ if (TextUtils.isEmpty(selection1)) {
+ return selection2;
+ } else if (TextUtils.isEmpty(selection2)) {
+ return selection1;
+ } else {
+ return selection1 + " AND " + selection2;
+ }
+ }
+}
+
diff --git a/src/com/android/providers/telephony/MmsSmsDatabaseHelper.java b/src/com/android/providers/telephony/MmsSmsDatabaseHelper.java
new file mode 100644
index 0000000..31d7cb7
--- /dev/null
+++ b/src/com/android/providers/telephony/MmsSmsDatabaseHelper.java
@@ -0,0 +1,2035 @@
+/*
+ * 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.providers.telephony;
+
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_DELIVERY_IND;
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND;
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_READ_ORIG_IND;
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_READ_REC_IND;
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF;
+import static com.google.android.mms.pdu.PduHeaders.MESSAGE_TYPE_SEND_REQ;
+
+import android.content.Context;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.provider.BaseColumns;
+import android.provider.Telephony.Mms;
+import android.provider.Telephony.MmsSms;
+import android.provider.Telephony.Sms;
+import android.provider.Telephony.Threads;
+import android.provider.Telephony.Mms.Addr;
+import android.provider.Telephony.Mms.Part;
+import android.provider.Telephony.Mms.Rate;
+import android.provider.Telephony.MmsSms.PendingMessages;
+import android.util.Log;
+
+public class MmsSmsDatabaseHelper extends SQLiteOpenHelper {
+ private static final String TAG = "MmsSmsDatabaseHelper";
+
+ private static final String SMS_UPDATE_THREAD_READ_BODY =
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE " + Sms.READ + " = 0" +
+ " AND " + Sms.THREAD_ID + " = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new." + Sms.THREAD_ID + "; ";
+
+ private static final String UPDATE_THREAD_COUNT_ON_NEW =
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = " + Sms.THREAD_ID +
+ " WHERE " + Sms.THREAD_ID + " = new.thread_id" +
+ " AND sms." + Sms.TYPE + " != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = " + Mms.THREAD_ID +
+ " WHERE " + Mms.THREAD_ID + " = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND " + Mms.MESSAGE_BOX + " != 3) " +
+ " WHERE threads._id = new.thread_id; ";
+
+ private static final String UPDATE_THREAD_COUNT_ON_OLD =
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = " + Sms.THREAD_ID +
+ " WHERE " + Sms.THREAD_ID + " = old.thread_id" +
+ " AND sms." + Sms.TYPE + " != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = " + Mms.THREAD_ID +
+ " WHERE " + Mms.THREAD_ID + " = old.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND " + Mms.MESSAGE_BOX + " != 3) " +
+ " WHERE threads._id = old.thread_id; ";
+
+ private static final String SMS_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE =
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new." + Sms.BODY + ", " +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new." + Sms.THREAD_ID + "; " +
+ UPDATE_THREAD_COUNT_ON_NEW +
+ SMS_UPDATE_THREAD_READ_BODY +
+ "END;";
+
+ private static final String PDU_UPDATE_THREAD_CONSTRAINTS =
+ " WHEN new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_RETRIEVE_CONF +
+ " OR new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_NOTIFICATION_IND +
+ " OR new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_SEND_REQ + " ";
+
+ private static final String PDU_UPDATE_THREAD_READ_BODY =
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM " + MmsProvider.TABLE_PDU +
+ " WHERE " + Mms.READ + " = 0" +
+ " AND " + Mms.THREAD_ID + " = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new." + Mms.THREAD_ID + "; ";
+
+ private static final String PDU_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE =
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new." + Mms.SUBJECT + ", " +
+ " snippet_cs = new." + Mms.SUBJECT_CHARSET +
+ " WHERE threads._id = new." + Mms.THREAD_ID + "; " +
+ UPDATE_THREAD_COUNT_ON_NEW +
+ PDU_UPDATE_THREAD_READ_BODY +
+ "END;";
+
+ private static final String UPDATE_THREAD_SNIPPET_SNIPPET_CS_ON_DELETE =
+ " UPDATE threads SET snippet = " +
+ " (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet, thread_id FROM pdu" +
+ " UNION SELECT date, body AS snippet, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; " +
+ " UPDATE threads SET snippet_cs = " +
+ " (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub_cs AS snippet_cs, thread_id FROM pdu" +
+ " UNION SELECT date, 0 AS snippet_cs, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; ";
+
+ private static MmsSmsDatabaseHelper mInstance = null;
+
+ static final String DATABASE_NAME = "mmssms.db";
+ static final int DATABASE_VERSION = 41;
+
+ private MmsSmsDatabaseHelper(Context context) {
+ super(context, DATABASE_NAME, null, DATABASE_VERSION);
+ }
+
+ /**
+ * Return a singleton helper for the combined MMS and SMS
+ * database.
+ */
+ /* package */ static synchronized MmsSmsDatabaseHelper getInstance(Context context) {
+ if (mInstance == null) {
+ mInstance = new MmsSmsDatabaseHelper(context);
+ }
+ return mInstance;
+ }
+
+ public static void updateThread(SQLiteDatabase db, long thread_id) {
+ if (thread_id < 0) {
+ updateAllThreads(db, null, null);
+ return;
+ }
+
+ // Delete the row for this thread in the threads table if
+ // there are no more messages attached to it in either
+ // the sms or pdu tables.
+ int rows = db.delete("threads",
+ "_id = ? AND _id NOT IN" +
+ " (SELECT thread_id FROM sms " +
+ " UNION SELECT thread_id FROM pdu)",
+ new String[] { String.valueOf(thread_id) });
+ if (rows > 0) {
+ // If this deleted a row, we have no more work to do.
+ return;
+ }
+ // Update the message count in the threads table as the sum
+ // of all messages in both the sms and pdu tables.
+ db.execSQL(
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = " + Sms.THREAD_ID +
+ " WHERE " + Sms.THREAD_ID + " = " + thread_id +
+ " AND sms." + Sms.TYPE + " != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = " + Mms.THREAD_ID +
+ " WHERE " + Mms.THREAD_ID + " = " + thread_id +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND " + Mms.MESSAGE_BOX + " != 3) " +
+ " WHERE threads._id = " + thread_id + ";");
+
+ // Update the date and the snippet (and its character set) in
+ // the threads table to be that of the most recent message in
+ // the thread.
+ db.execSQL(
+ " UPDATE threads" +
+ " SET" +
+ " date =" +
+ " (SELECT date FROM" +
+ " (SELECT date * 1000 AS date, thread_id FROM pdu" +
+ " UNION SELECT date, thread_id FROM sms)" +
+ " WHERE thread_id = " + thread_id + " ORDER BY date DESC LIMIT 1)," +
+ " snippet =" +
+ " (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet, thread_id FROM pdu" +
+ " UNION SELECT date, body AS snippet, thread_id FROM sms)" +
+ " WHERE thread_id = " + thread_id + " ORDER BY date DESC LIMIT 1)," +
+ " snippet_cs =" +
+ " (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub_cs AS snippet_cs, thread_id FROM pdu" +
+ " UNION SELECT date, 0 AS snippet_cs, thread_id FROM sms)" +
+ " WHERE thread_id = " + thread_id + " ORDER BY date DESC LIMIT 1)" +
+ " WHERE threads._id = " + thread_id + ";");
+
+ // Update the error column of the thread to indicate if there
+ // are any messages in it that have failed to send.
+ db.execSQL(
+ "UPDATE threads SET error =" +
+ " (SELECT COUNT(*) FROM sms WHERE type=5" +
+ " AND thread_id = " + thread_id + " LIMIT 1)" +
+ " WHERE threads._id = " + thread_id + ";");
+ }
+
+ public static void updateAllThreads(SQLiteDatabase db, String where, String[] whereArgs) {
+ if (where == null) {
+ where = "";
+ } else {
+ where = "WHERE (" + where + ")";
+ }
+ String query = "SELECT _id FROM threads WHERE _id IN " +
+ "(SELECT DISTINCT thread_id FROM sms " + where + ")";
+ Cursor c = db.rawQuery(query, whereArgs);
+ if (c != null) {
+ while (c.moveToNext()) {
+ updateThread(db, c.getInt(0));
+ }
+ c.close();
+ }
+ // remove orphaned threads
+ db.delete("threads",
+ "_id NOT IN (SELECT DISTINCT thread_id FROM sms " +
+ "UNION SELECT DISTINCT thread_id FROM pdu)", null);
+ }
+
+ public static int deleteOneSms(SQLiteDatabase db, int message_id) {
+ int thread_id = -1;
+ // Find the thread ID that the specified SMS belongs to.
+ Cursor c = db.query("sms", new String[] { "thread_id" },
+ "_id=" + message_id, null, null, null, null);
+ if (c != null) {
+ if (c.moveToFirst()) {
+ thread_id = c.getInt(0);
+ }
+ c.close();
+ }
+
+ // Delete the specified message.
+ int rows = db.delete("sms", "_id=" + message_id, null);
+ if (thread_id > 0) {
+ // Update its thread.
+ updateThread(db, thread_id);
+ }
+ return rows;
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ createMmsTables(db);
+ createSmsTables(db);
+ createCommonTables(db);
+ createCommonTriggers(db);
+ createMmsTriggers(db);
+ }
+
+ private void createMmsTables(SQLiteDatabase db) {
+ // N.B.: Whenever the columns here are changed, the columns in
+ // {@ref MmsSmsProvider} must be changed to match.
+ db.execSQL("CREATE TABLE " + MmsProvider.TABLE_PDU + " (" +
+ Mms._ID + " INTEGER PRIMARY KEY," +
+ Mms.THREAD_ID + " INTEGER," +
+ Mms.DATE + " INTEGER," +
+ Mms.MESSAGE_BOX + " INTEGER," +
+ Mms.READ + " INTEGER DEFAULT 0," +
+ Mms.MESSAGE_ID + " TEXT," +
+ Mms.SUBJECT + " TEXT," +
+ Mms.SUBJECT_CHARSET + " INTEGER," +
+ Mms.CONTENT_TYPE + " TEXT," +
+ Mms.CONTENT_LOCATION + " TEXT," +
+ Mms.EXPIRY + " INTEGER," +
+ Mms.MESSAGE_CLASS + " TEXT," +
+ Mms.MESSAGE_TYPE + " INTEGER," +
+ Mms.MMS_VERSION + " INTEGER," +
+ Mms.MESSAGE_SIZE + " INTEGER," +
+ Mms.PRIORITY + " INTEGER," +
+ Mms.READ_REPORT + " INTEGER," +
+ Mms.REPORT_ALLOWED + " INTEGER," +
+ Mms.RESPONSE_STATUS + " INTEGER," +
+ Mms.STATUS + " INTEGER," +
+ Mms.TRANSACTION_ID + " TEXT," +
+ Mms.RETRIEVE_STATUS + " INTEGER," +
+ Mms.RETRIEVE_TEXT + " TEXT," +
+ Mms.RETRIEVE_TEXT_CHARSET + " INTEGER," +
+ Mms.READ_STATUS + " INTEGER," +
+ Mms.CONTENT_CLASS + " INTEGER," +
+ Mms.RESPONSE_TEXT + " TEXT," +
+ Mms.DELIVERY_TIME + " INTEGER," +
+ Mms.DELIVERY_REPORT + " INTEGER);");
+
+ db.execSQL("CREATE TABLE " + MmsProvider.TABLE_ADDR + " (" +
+ Addr._ID + " INTEGER PRIMARY KEY," +
+ Addr.MSG_ID + " INTEGER," +
+ Addr.CONTACT_ID + " INTEGER," +
+ Addr.ADDRESS + " TEXT," +
+ Addr.TYPE + " INTEGER," +
+ Addr.CHARSET + " INTEGER);");
+
+ db.execSQL("CREATE TABLE " + MmsProvider.TABLE_PART + " (" +
+ Part._ID + " INTEGER PRIMARY KEY," +
+ Part.MSG_ID + " INTEGER," +
+ Part.SEQ + " INTEGER DEFAULT 0," +
+ Part.CONTENT_TYPE + " TEXT," +
+ Part.NAME + " TEXT," +
+ Part.CHARSET + " INTEGER," +
+ Part.CONTENT_DISPOSITION + " TEXT," +
+ Part.FILENAME + " TEXT," +
+ Part.CONTENT_ID + " TEXT," +
+ Part.CONTENT_LOCATION + " TEXT," +
+ Part.CT_START + " INTEGER," +
+ Part.CT_TYPE + " TEXT," +
+ Part._DATA + " TEXT);");
+
+ db.execSQL("CREATE TABLE " + MmsProvider.TABLE_RATE + " (" +
+ Rate.SENT_TIME + " INTEGER);");
+
+ db.execSQL("CREATE TABLE " + MmsProvider.TABLE_DRM + " (" +
+ BaseColumns._ID + " INTEGER PRIMARY KEY," +
+ "_data TEXT);");
+ }
+
+ private void createMmsTriggers(SQLiteDatabase db) {
+ // Cleans up parts when a MM is deleted.
+ db.execSQL("CREATE TRIGGER part_cleanup DELETE ON " + MmsProvider.TABLE_PDU + " " +
+ "BEGIN " +
+ " DELETE FROM " + MmsProvider.TABLE_PART +
+ " WHERE " + Part.MSG_ID + "=old._id;" +
+ "END;");
+
+ // Cleans up address info when a MM is deleted.
+ db.execSQL("CREATE TRIGGER addr_cleanup DELETE ON " + MmsProvider.TABLE_PDU + " " +
+ "BEGIN " +
+ " DELETE FROM " + MmsProvider.TABLE_ADDR +
+ " WHERE " + Addr.MSG_ID + "=old._id;" +
+ "END;");
+
+ // Delete obsolete delivery-report, read-report while deleting their
+ // associated Send.req.
+ db.execSQL("CREATE TRIGGER cleanup_delivery_and_read_report " +
+ "AFTER DELETE ON " + MmsProvider.TABLE_PDU + " " +
+ "WHEN old." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_SEND_REQ + " " +
+ "BEGIN " +
+ " DELETE FROM " + MmsProvider.TABLE_PDU +
+ " WHERE (" + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_DELIVERY_IND +
+ " OR " + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_READ_ORIG_IND + ")" +
+ " AND " + Mms.MESSAGE_ID + "=old." + Mms.MESSAGE_ID + "; " +
+ "END;");
+ }
+
+ private void createSmsTables(SQLiteDatabase db) {
+ // N.B.: Whenever the columns here are changed, the columns in
+ // {@ref MmsSmsProvider} must be changed to match.
+ db.execSQL("CREATE TABLE sms (" +
+ "_id INTEGER PRIMARY KEY," +
+ "thread_id INTEGER," +
+ "address TEXT," +
+ "person INTEGER," +
+ "date INTEGER," +
+ "protocol INTEGER," +
+ "read INTEGER DEFAULT 0," +
+ "status INTEGER DEFAULT -1," + // a TP-Status value
+ // or -1 if it
+ // status hasn't
+ // been received
+ "type INTEGER," +
+ "reply_path_present INTEGER," +
+ "subject TEXT," +
+ "body TEXT," +
+ "service_center TEXT);");
+
+ /**
+ * This table is used by the SMS dispatcher to hold
+ * incomplete partial messages until all the parts arrive.
+ */
+ db.execSQL("CREATE TABLE raw (" +
+ "_id INTEGER PRIMARY KEY," +
+ "date INTEGER," +
+ "reference_number INTEGER," + // one per full message
+ "count INTEGER," + // the number of parts
+ "sequence INTEGER," + // the part number of this message
+ "destination_port INTEGER," +
+ "address TEXT," +
+ "pdu TEXT);"); // the raw PDU for this part
+
+ db.execSQL("CREATE TABLE attachments (" +
+ "sms_id INTEGER," +
+ "content_url TEXT," +
+ "offset INTEGER);");
+
+ /**
+ * This table is used by the SMS dispatcher to hold pending
+ * delivery status report intents.
+ */
+ db.execSQL("CREATE TABLE sr_pending (" +
+ "reference_number INTEGER," +
+ "action TEXT," +
+ "data TEXT);");
+ }
+
+ private void createCommonTables(SQLiteDatabase db) {
+ // TODO Ensure that each entry is removed when the last use of
+ // any address equivalent to its address is removed.
+
+ /**
+ * This table maps the first instance seen of any particular
+ * MMS/SMS address to an ID, which is then used as its
+ * canonical representation. If the same address or an
+ * equivalent address (as determined by our Sqlite
+ * PHONE_NUMBERS_EQUAL extension) is seen later, this same ID
+ * will be used.
+ */
+ db.execSQL("CREATE TABLE canonical_addresses (" +
+ "_id INTEGER PRIMARY KEY," +
+ "address TEXT);");
+
+ /**
+ * This table maps the subject and an ordered set of recipient
+ * IDs, separated by spaces, to a unique thread ID. The IDs
+ * come from the canonical_addresses table. This works
+ * because messages are considered to be part of the same
+ * thread if they have the same subject (or a null subject)
+ * and the same set of recipients.
+ */
+ db.execSQL("CREATE TABLE threads (" +
+ Threads._ID + " INTEGER PRIMARY KEY," +
+ Threads.DATE + " INTEGER DEFAULT 0," +
+ Threads.MESSAGE_COUNT + " INTEGER DEFAULT 0," +
+ Threads.RECIPIENT_IDS + " TEXT," +
+ Threads.SNIPPET + " TEXT," +
+ Threads.SNIPPET_CHARSET + " INTEGER DEFAULT 0," +
+ Threads.READ + " INTEGER DEFAULT 1," +
+ Threads.TYPE + " INTEGER DEFAULT 0," +
+ Threads.ERROR + " INTEGER DEFAULT 0);");
+
+ /**
+ * This table stores the queue of messages to be sent/downloaded.
+ */
+ db.execSQL("CREATE TABLE " + MmsSmsProvider.TABLE_PENDING_MSG +" (" +
+ PendingMessages._ID + " INTEGER PRIMARY KEY," +
+ PendingMessages.PROTO_TYPE + " INTEGER," +
+ PendingMessages.MSG_ID + " INTEGER," +
+ PendingMessages.MSG_TYPE + " INTEGER," +
+ PendingMessages.ERROR_TYPE + " INTEGER," +
+ PendingMessages.ERROR_CODE + " INTEGER," +
+ PendingMessages.RETRY_INDEX + " INTEGER NOT NULL DEFAULT 0," +
+ PendingMessages.DUE_TIME + " INTEGER," +
+ PendingMessages.LAST_TRY + " INTEGER);");
+
+ }
+
+ // TODO Check the query plans for these triggers.
+ private void createCommonTriggers(SQLiteDatabase db) {
+ // Updates threads table whenever a message is added to pdu.
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON " +
+ MmsProvider.TABLE_PDU + " " +
+ PDU_UPDATE_THREAD_CONSTRAINTS +
+ PDU_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE);
+
+ // Updates threads table whenever a message is added to sms.
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_insert AFTER INSERT ON sms " +
+ SMS_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE);
+
+ // Updates threads table whenever a message in pdu is updated.
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF " + Mms.DATE + ", " + Mms.SUBJECT + ", " + Mms.MESSAGE_BOX +
+ " ON " + MmsProvider.TABLE_PDU + " " +
+ PDU_UPDATE_THREAD_CONSTRAINTS +
+ PDU_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE);
+
+ // Updates threads table whenever a message in sms is updated.
+ db.execSQL("CREATE TRIGGER sms_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF " + Sms.DATE + ", " + Sms.BODY + ", " + Sms.TYPE +
+ " ON sms " +
+ SMS_UPDATE_THREAD_DATE_SNIPPET_COUNT_ON_UPDATE);
+
+ // Updates threads table whenever a message in pdu is updated.
+ db.execSQL("CREATE TRIGGER pdu_update_thread_read_on_update AFTER" +
+ " UPDATE OF " + Mms.READ +
+ " ON " + MmsProvider.TABLE_PDU + " " +
+ PDU_UPDATE_THREAD_CONSTRAINTS +
+ "BEGIN " +
+ PDU_UPDATE_THREAD_READ_BODY +
+ "END;");
+
+ // Updates threads table whenever a message in sms is updated.
+ db.execSQL("CREATE TRIGGER sms_update_thread_read_on_update AFTER" +
+ " UPDATE OF " + Sms.READ +
+ " ON sms " +
+ "BEGIN " +
+ SMS_UPDATE_THREAD_READ_BODY +
+ "END;");
+
+ // Update threads table whenever a message in pdu is deleted
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_delete " +
+ "AFTER DELETE ON pdu " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000)" +
+ " WHERE threads._id = old." + Mms.THREAD_ID + "; " +
+ UPDATE_THREAD_COUNT_ON_OLD +
+ UPDATE_THREAD_SNIPPET_SNIPPET_CS_ON_DELETE +
+ "END;");
+
+ // When the last message in a thread is deleted, these
+ // triggers ensure that the entry for its thread ID is removed
+ // from the threads table.
+ db.execSQL("CREATE TRIGGER delete_obsolete_threads_pdu " +
+ "AFTER DELETE ON pdu " +
+ "BEGIN " +
+ " DELETE FROM threads " +
+ " WHERE " +
+ " _id = old.thread_id " +
+ " AND _id NOT IN " +
+ " (SELECT thread_id FROM sms " +
+ " UNION SELECT thread_id from pdu); " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER delete_obsolete_threads_when_update_pdu " +
+ "AFTER UPDATE OF " + Mms.THREAD_ID + " ON pdu " +
+ "WHEN old." + Mms.THREAD_ID + " != new." + Mms.THREAD_ID + " " +
+ "BEGIN " +
+ " DELETE FROM threads " +
+ " WHERE " +
+ " _id = old.thread_id " +
+ " AND _id NOT IN " +
+ " (SELECT thread_id FROM sms " +
+ " UNION SELECT thread_id from pdu); " +
+ "END;");
+ // Insert pending status for M-Notification.ind or M-ReadRec.ind
+ // when they are inserted into Inbox/Outbox.
+ db.execSQL("CREATE TRIGGER insert_mms_pending_on_insert " +
+ "AFTER INSERT ON pdu " +
+ "WHEN new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_NOTIFICATION_IND +
+ " OR new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_READ_REC_IND + " " +
+ "BEGIN " +
+ " INSERT INTO " + MmsSmsProvider.TABLE_PENDING_MSG +
+ " (" + PendingMessages.PROTO_TYPE + "," +
+ " " + PendingMessages.MSG_ID + "," +
+ " " + PendingMessages.MSG_TYPE + "," +
+ " " + PendingMessages.ERROR_TYPE + "," +
+ " " + PendingMessages.ERROR_CODE + "," +
+ " " + PendingMessages.RETRY_INDEX + "," +
+ " " + PendingMessages.DUE_TIME + ") " +
+ " VALUES " +
+ " (" + MmsSms.MMS_PROTO + "," +
+ " new." + BaseColumns._ID + "," +
+ " new." + Mms.MESSAGE_TYPE + ",0,0,0,0);" +
+ "END;");
+
+ // Insert pending status for M-Send.req when it is moved into Outbox.
+ db.execSQL("CREATE TRIGGER insert_mms_pending_on_update " +
+ "AFTER UPDATE ON pdu " +
+ "WHEN new." + Mms.MESSAGE_TYPE + "=" + MESSAGE_TYPE_SEND_REQ +
+ " AND new." + Mms.MESSAGE_BOX + "=" + Mms.MESSAGE_BOX_OUTBOX +
+ " AND old." + Mms.MESSAGE_BOX + "!=" + Mms.MESSAGE_BOX_OUTBOX + " " +
+ "BEGIN " +
+ " INSERT INTO " + MmsSmsProvider.TABLE_PENDING_MSG +
+ " (" + PendingMessages.PROTO_TYPE + "," +
+ " " + PendingMessages.MSG_ID + "," +
+ " " + PendingMessages.MSG_TYPE + "," +
+ " " + PendingMessages.ERROR_TYPE + "," +
+ " " + PendingMessages.ERROR_CODE + "," +
+ " " + PendingMessages.RETRY_INDEX + "," +
+ " " + PendingMessages.DUE_TIME + ") " +
+ " VALUES " +
+ " (" + MmsSms.MMS_PROTO + "," +
+ " new." + BaseColumns._ID + "," +
+ " new." + Mms.MESSAGE_TYPE + ",0,0,0,0);" +
+ "END;");
+
+ // When a message is moved out of Outbox, delete its pending status.
+ db.execSQL("CREATE TRIGGER delete_mms_pending_on_update " +
+ "AFTER UPDATE ON " + MmsProvider.TABLE_PDU + " " +
+ "WHEN old." + Mms.MESSAGE_BOX + "=" + Mms.MESSAGE_BOX_OUTBOX +
+ " AND new." + Mms.MESSAGE_BOX + "!=" + Mms.MESSAGE_BOX_OUTBOX + " " +
+ "BEGIN " +
+ " DELETE FROM " + MmsSmsProvider.TABLE_PENDING_MSG +
+ " WHERE " + PendingMessages.MSG_ID + "=new._id; " +
+ "END;");
+
+ // Delete pending status for a message when it is deleted.
+ db.execSQL("CREATE TRIGGER delete_mms_pending_on_delete " +
+ "AFTER DELETE ON " + MmsProvider.TABLE_PDU + " " +
+ "BEGIN " +
+ " DELETE FROM " + MmsSmsProvider.TABLE_PENDING_MSG +
+ " WHERE " + PendingMessages.MSG_ID + "=old._id; " +
+ "END;");
+
+ // TODO Add triggers for SMS retry-status management.
+
+ // Update the error flag of threads when the error type of
+ // a pending MM is updated.
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update_mms " +
+ " AFTER UPDATE OF err_type ON pending_msgs " +
+ " WHEN (OLD.err_type < 10 AND NEW.err_type >= 10)" +
+ " OR (OLD.err_type >= 10 AND NEW.err_type < 10) " +
+ "BEGIN" +
+ " UPDATE threads SET error = " +
+ " CASE" +
+ " WHEN NEW.err_type >= 10 THEN error + 1" +
+ " ELSE error - 1" +
+ " END " +
+ " WHERE _id =" +
+ " (SELECT DISTINCT thread_id" +
+ " FROM pdu" +
+ " WHERE _id = NEW.msg_id); " +
+ "END;");
+
+ // Update the error flag of threads when delete pending message.
+ db.execSQL("CREATE TRIGGER update_threads_error_on_delete_mms " +
+ " BEFORE DELETE ON pdu" +
+ " WHEN OLD._id IN (SELECT DISTINCT msg_id" +
+ " FROM pending_msgs" +
+ " WHERE err_type >= 10) " +
+ "BEGIN " +
+ " UPDATE threads SET error = error - 1" +
+ " WHERE _id = OLD.thread_id; " +
+ "END;");
+
+ // Update the error flag of threads while moving an MM out of Outbox,
+ // which was failed to be sent permanently.
+ db.execSQL("CREATE TRIGGER update_threads_error_on_move_mms " +
+ " BEFORE UPDATE OF msg_box ON pdu " +
+ " WHEN (OLD.msg_box = 4 AND NEW.msg_box != 4) " +
+ " AND (OLD._id IN (SELECT DISTINCT msg_id" +
+ " FROM pending_msgs" +
+ " WHERE err_type >= 10)) " +
+ "BEGIN " +
+ " UPDATE threads SET error = error - 1" +
+ " WHERE _id = OLD.thread_id; " +
+ "END;");
+
+ // Update the error flag of threads after a text message was
+ // failed to send/receive.
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update_sms " +
+ " AFTER UPDATE OF type ON sms" +
+ " WHEN (OLD.type != 5 AND NEW.type = 5)" +
+ " OR (OLD.type = 5 AND NEW.type != 5) " +
+ "BEGIN " +
+ " UPDATE threads SET error = " +
+ " CASE" +
+ " WHEN NEW.type = 5 THEN error + 1" +
+ " ELSE error - 1" +
+ " END " +
+ " WHERE _id = NEW.thread_id; " +
+ "END;");
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int currentVersion) {
+ Log.w(TAG, "Upgrading database from version " + oldVersion
+ + " to " + currentVersion + ".");
+
+ switch (oldVersion) {
+ case 24:
+ if (currentVersion <= 24) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion25(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 25:
+ if (currentVersion <= 25) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion26(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 26:
+ if (currentVersion <= 26) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion27(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 27:
+ if (currentVersion <= 27) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion28(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 28:
+ if (currentVersion <= 28) {
+ return;
+ }
+
+ // Test whether this database file is from TC2 branch.
+ Cursor c = db.rawQuery("SELECT * FROM threads", null);
+ if (c != null) {
+ try {
+ c.getColumnIndexOrThrow("snippet_cs");
+ } catch (IllegalArgumentException e) {
+ // Column 'snippet_cs' doesn't exist, which means
+ // this database file was maintained by TC2 branch
+ // and its version is inconsistent.
+ Log.w(TAG, "Upgrade database file from TC2!!!");
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion28(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ } finally {
+ c.close();
+ }
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion29(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 29:
+ if (currentVersion <= 29) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion30(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 30:
+ if (currentVersion <= 30) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion31(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 31:
+ if (currentVersion <= 31) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion32(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 32:
+ if (currentVersion <= 32) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion33(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 33:
+ if (currentVersion <= 33) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion34(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 34:
+ if (currentVersion <= 34) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion35(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 35:
+ if (currentVersion <= 35) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion36(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 36:
+ if (currentVersion <= 36) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion37(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 37:
+ if (currentVersion <= 37) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion38(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 38:
+ if (currentVersion <= 38) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion39(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 39:
+ if (currentVersion <= 39) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion40(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 40:
+ if (currentVersion <= 40) {
+ return;
+ }
+
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion41(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break; // force to destroy all old data;
+ } finally {
+ db.endTransaction();
+ }
+ // fall-through
+ case 41:
+ if (currentVersion <= 41) {
+ return;
+ }
+ db.beginTransaction();
+ try {
+ upgradeDatabaseToVersion42(db);
+ db.setTransactionSuccessful();
+ } catch (Throwable ex) {
+ Log.e(TAG, ex.getMessage(), ex);
+ break;
+ } finally {
+ db.endTransaction();
+ }
+ return;
+ }
+
+ Log.w(TAG, "Destroying all old data.");
+ dropCommonTriggers(db);
+ dropMmsTriggers(db);
+ dropCommonTables(db);
+ dropMmsTables(db);
+ dropSmsTables(db);
+ onCreate(db);
+ }
+
+ private void dropCommonTables(SQLiteDatabase db) {
+ db.execSQL("DROP TABLE IF EXISTS canonical_addresses");
+ db.execSQL("DROP TABLE IF EXISTS threads");
+ db.execSQL("DROP TABLE IF EXISTS " + MmsSmsProvider.TABLE_PENDING_MSG);
+ }
+
+ private void dropCommonTriggers(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS delete_obsolete_threads_pdu");
+ db.execSQL("DROP TRIGGER IF EXISTS delete_obsolete_threads_when_update_pdu");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_read_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_read_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS insert_mms_pending_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS insert_mms_pending_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS delete_mms_pending_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS delete_mms_pending_on_delete");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_update_mms");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_delete_mms");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_move_mms");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_update_sms");
+ }
+
+ private void dropSmsTables(SQLiteDatabase db) {
+ db.execSQL("DROP TABLE IF EXISTS sms");
+ db.execSQL("DROP TABLE IF EXISTS newSmsIndicator");
+ db.execSQL("DROP TABLE IF EXISTS raw");
+ db.execSQL("DROP TABLE IF EXISTS attachments");
+ db.execSQL("DROP TABLE IF EXISTS thread_ids");
+ db.execSQL("DROP TABLE IF EXISTS sr_pending");
+ }
+
+ private void dropMmsTables(SQLiteDatabase db) {
+ db.execSQL("DROP TABLE IF EXISTS " + MmsProvider.TABLE_PDU + ";");
+ db.execSQL("DROP TABLE IF EXISTS " + MmsProvider.TABLE_ADDR + ";");
+ db.execSQL("DROP TABLE IF EXISTS " + MmsProvider.TABLE_PART + ";");
+ db.execSQL("DROP TABLE IF EXISTS " + MmsProvider.TABLE_RATE + ";");
+ db.execSQL("DROP TABLE IF EXISTS " + MmsProvider.TABLE_DRM + ";");
+ }
+
+ private void dropMmsTriggers(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS part_cleanup;");
+ db.execSQL("DROP TRIGGER IF EXISTS addr_cleanup;");
+ db.execSQL("DROP TRIGGER IF EXISTS cleanup_delivery_and_read_report;");
+ }
+
+ private void upgradeDatabaseToVersion25(SQLiteDatabase db) {
+ db.execSQL("ALTER TABLE threads " +
+ "ADD COLUMN type INTEGER NOT NULL DEFAULT 0;");
+ }
+
+ private void upgradeDatabaseToVersion26(SQLiteDatabase db) {
+ db.execSQL("ALTER TABLE threads " +
+ "ADD COLUMN error INTEGER DEFAULT 0;");
+
+ // Do NOT use defined symbols when upgrading database
+ // because they may be changed and cannot be applied
+ // to old database.
+ db.execSQL("UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); ");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update " +
+ " AFTER UPDATE OF err_type ON pending_msgs " +
+ "BEGIN " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_delete " +
+ " AFTER DELETE ON pending_msgs " +
+ "BEGIN " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms.thread_id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion27(SQLiteDatabase db) {
+ db.execSQL("UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); ");
+
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_delete");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update " +
+ " AFTER UPDATE OF err_type ON pending_msgs " +
+ "BEGIN " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_delete " +
+ " AFTER DELETE ON pending_msgs " +
+ "BEGIN " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM pdu LEFT JOIN pending_msgs" +
+ " ON pdu._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 1 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "UPDATE threads SET error = 1 WHERE _id IN" +
+ " (SELECT thread_id FROM sms LEFT JOIN pending_msgs" +
+ " ON sms._id = pending_msgs.msg_id" +
+ " WHERE proto_type = 0 AND err_type >= 10" +
+ " GROUP BY thread_id); " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion28(SQLiteDatabase db) {
+ db.execSQL("ALTER TABLE threads " +
+ "ADD COLUMN snippet_cs INTEGER NOT NULL DEFAULT 0;");
+
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_read_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_delete");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON pdu " +
+ " WHEN new.msg_box!=5 AND new.msg_box!=3" +
+ " AND (new.m_type=132 OR new.m_type=130 OR new.m_type=128) " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, sub, msg_box ON pdu " +
+ " WHEN new.msg_box!=5 AND new.msg_box!=3" +
+ " AND (new.m_type=132 OR new.m_type=130 OR new.m_type=128) " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_read_on_update AFTER" +
+ " UPDATE OF read ON pdu " +
+ " WHEN new.msg_box!=5 AND new.msg_box!=3" +
+ " AND (new.m_type=132 OR new.m_type=130 OR new.m_type=128) " +
+ "BEGIN " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_delete " +
+ "AFTER DELETE ON sms " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = (SELECT body FROM SMS ORDER BY date DESC LIMIT 1)" +
+ " WHERE threads._id = old.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion29(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_read_on_update");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, sub, msg_box ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_read_on_update AFTER" +
+ " UPDATE OF read ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion30(SQLiteDatabase db) {
+ // Since SQLite doesn't support altering constraints
+ // of an existing table, I have to create a new table
+ // with updated constraints, copy old data into this
+ // table, drop old table and then rename the new table
+ // to 'threads'.
+ db.execSQL("CREATE TABLE temp_threads (" +
+ "_id INTEGER PRIMARY KEY," +
+ "date INTEGER DEFAULT 0," +
+ "subject TEXT," +
+ "recipient_ids TEXT," +
+ "snippet TEXT," +
+ "snippet_cs INTEGER DEFAULT 0," +
+ "read INTEGER DEFAULT 1," +
+ "type INTEGER DEFAULT 0," +
+ "error INTEGER DEFAULT 0);");
+ db.execSQL("INSERT INTO temp_threads SELECT * FROM threads;");
+ db.execSQL("DROP TABLE IF EXISTS threads;");
+ db.execSQL("ALTER TABLE temp_threads RENAME TO threads;");
+ }
+
+ private void upgradeDatabaseToVersion31(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_delete");
+
+ // Update threads table whenever a message in sms is deleted
+ // (Usually an abandoned draft.)
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_delete " +
+ "AFTER DELETE ON sms " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet = (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet_cs = (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ "END;");
+
+ // Update threads table whenever a message in pdu is deleted
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_delete " +
+ "AFTER DELETE ON pdu " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000)" +
+ " WHERE threads._id = old.thread_id;" +
+ " UPDATE threads SET" +
+ " snippet = (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet_cs = (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion32(SQLiteDatabase db) {
+ db.execSQL("CREATE TABLE IF NOT EXISTS rate (sent_time INTEGER);");
+ }
+
+ private void upgradeDatabaseToVersion33(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_delete");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update_mms " +
+ " AFTER UPDATE OF err_type ON pending_msgs " +
+ " WHEN (OLD.err_type < 10 AND NEW.err_type >= 10)" +
+ " OR (OLD.err_type >= 10 AND NEW.err_type < 10) " +
+ "BEGIN" +
+ " UPDATE threads SET error = " +
+ " CASE" +
+ " WHEN NEW.err_type >= 10 THEN error + 1" +
+ " ELSE error - 1" +
+ " END " +
+ " WHERE _id =" +
+ " (SELECT DISTINCT thread_id" +
+ " FROM pdu" +
+ " WHERE _id = NEW.msg_id); " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_delete_mms " +
+ " BEFORE DELETE ON pdu" +
+ " WHEN OLD._id IN (SELECT DISTINCT msg_id" +
+ " FROM pending_msgs" +
+ " WHERE err_type >= 10) " +
+ "BEGIN " +
+ " UPDATE threads SET error = error - 1" +
+ " WHERE _id = OLD.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_update_sms " +
+ " AFTER UPDATE OF type ON sms" +
+ " WHEN (OLD.type != 5 AND NEW.type = 5)" +
+ " OR (OLD.type = 5 AND NEW.type != 5) " +
+ "BEGIN " +
+ " UPDATE threads SET error = " +
+ " CASE" +
+ " WHEN NEW.type = 5 THEN error + 1" +
+ " ELSE error - 1" +
+ " END " +
+ " WHERE _id = NEW.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER update_threads_error_on_delete_sms " +
+ " AFTER DELETE ON sms" +
+ " WHEN (OLD.type = 5) " +
+ "BEGIN " +
+ " UPDATE threads SET error = error - 1" +
+ " WHERE _id = OLD.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion34(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_date_subject_on_update");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_insert AFTER INSERT ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, body, msg_box" +
+ " ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion35(SQLiteDatabase db) {
+ db.execSQL("CREATE TABLE temp_threads (" +
+ "_id INTEGER PRIMARY KEY," +
+ "date INTEGER DEFAULT 0," +
+ "message_count INTEGER DEFAULT 0," +
+ "recipient_ids TEXT," +
+ "snippet TEXT," +
+ "snippet_cs INTEGER DEFAULT 0," +
+ "read INTEGER DEFAULT 1," +
+ "type INTEGER DEFAULT 0," +
+ "error INTEGER DEFAULT 0);");
+ db.execSQL("INSERT INTO temp_threads " +
+ "SELECT _id, date, 0 AS message_count, recipient_ids," +
+ " snippet, snippet_cs, read, type, error " +
+ "FROM threads;");
+ db.execSQL("DROP TABLE IF EXISTS threads;");
+ db.execSQL("ALTER TABLE temp_threads RENAME TO threads;");
+
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_delete");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_delete");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_insert AFTER INSERT ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_delete " +
+ "AFTER DELETE ON sms " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet = (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet_cs = (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_delete " +
+ "AFTER DELETE ON pdu " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000)" +
+ " WHERE threads._id = old.thread_id;" +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet = (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET" +
+ " snippet_cs = (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet," +
+ " sub_cs AS snippet_cs FROM pdu" +
+ " UNION SELECT date, body AS snippet, NULL AS snippet_cs" +
+ " FROM sms) ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = old.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, body, type" +
+ " ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, sub, msg_box ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion36(SQLiteDatabase db) {
+ db.execSQL("CREATE TABLE IF NOT EXISTS drm (_id INTEGER PRIMARY KEY, _data TEXT);");
+ db.execSQL("CREATE TRIGGER IF NOT EXISTS drm_file_cleanup DELETE ON drm " +
+ "BEGIN SELECT _DELETE_FILE(old._data); END;");
+ }
+
+ private void upgradeDatabaseToVersion37(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_delete");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_delete");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_delete " +
+ "AFTER DELETE ON sms " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET snippet = " +
+ " (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet, thread_id FROM pdu" +
+ " UNION SELECT date, body AS snippet, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; " +
+ " UPDATE threads SET snippet_cs = " +
+ " (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub_cs AS snippet_cs, thread_id FROM pdu" +
+ " UNION SELECT date, 0 AS snippet_cs, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_delete " +
+ "AFTER DELETE ON pdu " +
+ "BEGIN " +
+ " UPDATE threads SET " +
+ " date = (strftime('%s','now') * 1000)" +
+ " WHERE threads._id = old.thread_id;" +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = old.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = old.thread_id; " +
+ " UPDATE threads SET snippet = " +
+ " (SELECT snippet FROM" +
+ " (SELECT date * 1000 AS date, sub AS snippet, thread_id FROM pdu" +
+ " UNION SELECT date, body AS snippet, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; " +
+ " UPDATE threads SET snippet_cs = " +
+ " (SELECT snippet_cs FROM" +
+ " (SELECT date * 1000 AS date, sub_cs AS snippet_cs, thread_id FROM pdu" +
+ " UNION SELECT date, 0 AS snippet_cs, thread_id FROM sms)" +
+ " WHERE thread_id = OLD.thread_id ORDER BY date DESC LIMIT 1) " +
+ " WHERE threads._id = OLD.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TABLE temp_part (" +
+ "_id INTEGER PRIMARY KEY," +
+ "mid INTEGER," +
+ "seq INTEGER DEFAULT 0," +
+ "ct TEXT," +
+ "name TEXT," +
+ "chset INTEGER," +
+ "cd TEXT," +
+ "fn TEXT," +
+ "cid TEXT," +
+ "cl TEXT," +
+ "ctt_s INTEGER," +
+ "ctt_t TEXT," +
+ "_data TEXT);");
+ db.execSQL("INSERT INTO temp_part SELECT * FROM part;");
+ db.execSQL("UPDATE temp_part SET seq='0';");
+ db.execSQL("UPDATE temp_part SET seq='-1' WHERE ct='application/smil';");
+ db.execSQL("DROP TABLE IF EXISTS part;");
+ db.execSQL("ALTER TABLE temp_part RENAME TO part;");
+ }
+
+ private void upgradeDatabaseToVersion38(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS part_file_cleanup;");
+ db.execSQL("DROP TRIGGER IF EXISTS drm_file_cleanup;");
+ }
+
+ private void upgradeDatabaseToVersion39(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_insert AFTER INSERT ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is NULL) + " +
+ " (SELECT COUNT(DISTINCT pdu.m_id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is not NULL) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, body, type" +
+ " ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is NULL) + " +
+ " (SELECT COUNT(DISTINCT pdu.m_id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is not NULL) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is NULL) + " +
+ " (SELECT COUNT(DISTINCT pdu.m_id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is not NULL) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, sub, msg_box ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is NULL) + " +
+ " (SELECT COUNT(DISTINCT pdu.m_id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3 " +
+ " AND pdu.m_id is not NULL) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion40(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_date_subject_on_update");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_on_insert");
+ db.execSQL("DROP TRIGGER IF EXISTS pdu_update_thread_date_subject_on_update");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_on_insert AFTER INSERT ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER sms_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, body, type" +
+ " ON sms " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.body," +
+ " snippet_cs = 0" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM sms" +
+ " WHERE read = 0" +
+ " AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1" +
+ " ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_on_insert AFTER INSERT ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+
+ db.execSQL("CREATE TRIGGER pdu_update_thread_date_subject_on_update AFTER" +
+ " UPDATE OF date, sub, msg_box ON pdu " +
+ " WHEN new.m_type=132 OR new.m_type=130 OR new.m_type=128 " +
+ "BEGIN" +
+ " UPDATE threads SET" +
+ " date = (strftime('%s','now') * 1000), " +
+ " snippet = new.sub, " +
+ " snippet_cs = new.sub_cs" +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET message_count = " +
+ " (SELECT COUNT(sms._id) FROM sms LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND sms.type != 3) + " +
+ " (SELECT COUNT(pdu._id) FROM pdu LEFT JOIN threads " +
+ " ON threads._id = thread_id" +
+ " WHERE thread_id = new.thread_id" +
+ " AND (m_type=132 OR m_type=130 OR m_type=128)" +
+ " AND msg_box != 3) " +
+ " WHERE threads._id = new.thread_id; " +
+ " UPDATE threads SET read = " +
+ " CASE (SELECT COUNT(*)" +
+ " FROM pdu" +
+ " WHERE read = 0 AND thread_id = threads._id)" +
+ " WHEN 0 THEN 1 ELSE 0" +
+ " END" +
+ " WHERE threads._id = new.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion41(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_move_mms");
+ db.execSQL("CREATE TRIGGER update_threads_error_on_move_mms " +
+ " BEFORE UPDATE OF msg_box ON pdu " +
+ " WHEN (OLD.msg_box = 4 AND NEW.msg_box != 4) " +
+ " AND (OLD._id IN (SELECT DISTINCT msg_id" +
+ " FROM pending_msgs" +
+ " WHERE err_type >= 10)) " +
+ "BEGIN " +
+ " UPDATE threads SET error = error - 1" +
+ " WHERE _id = OLD.thread_id; " +
+ "END;");
+ }
+
+ private void upgradeDatabaseToVersion42(SQLiteDatabase db) {
+ db.execSQL("DROP TRIGGER IF EXISTS sms_update_thread_on_delete");
+ db.execSQL("DROP TRIGGER IF EXISTS delete_obsolete_threads_sms");
+ db.execSQL("DROP TRIGGER IF EXISTS update_threads_error_on_delete_sms");
+ }
+}
diff --git a/src/com/android/providers/telephony/MmsSmsProvider.java b/src/com/android/providers/telephony/MmsSmsProvider.java
new file mode 100644
index 0000000..b27e332
--- /dev/null
+++ b/src/com/android/providers/telephony/MmsSmsProvider.java
@@ -0,0 +1,1019 @@
+/*
+ * 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.providers.telephony;
+
+import com.google.android.mms.pdu.PduHeaders;
+
+import android.content.ContentProvider;
+import android.content.ContentValues;
+import android.content.Context;
+import android.content.UriMatcher;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.provider.BaseColumns;
+import android.provider.Telephony.CanonicalAddressesColumns;
+import android.provider.Telephony.Mms;
+import android.provider.Telephony.MmsSms;
+import android.provider.Telephony.Sms;
+import android.provider.Telephony.Threads;
+import android.provider.Telephony.ThreadsColumns;
+import android.provider.Telephony.MmsSms.PendingMessages;
+import android.provider.Telephony.Sms.Conversations;
+import android.text.TextUtils;
+import android.util.Log;
+
+import java.util.Arrays;
+import java.util.HashSet;
+import java.util.List;
+import java.util.Set;
+
+/**
+ * This class provides the ability to query the MMS and SMS databases
+ * at the same time, mixing messages from both in a single thread
+ * (A.K.A. conversation).
+ *
+ * A virtual column, MmsSms.TYPE_DISCRIMINATOR_COLUMN, may be
+ * requested in the projection for a query. Its value is either "mms"
+ * or "sms", depending on whether the message represented by the row
+ * is an MMS message or an SMS message, respectively.
+ *
+ * This class also provides the ability to find out what addresses
+ * participated in a particular thread. It doesn't support updates
+ * for either of these.
+ *
+ * This class provides a way to allocate and retrieve thread IDs.
+ * This is done atomically through a query. There is no insert URI
+ * for this.
+ *
+ * Finally, this class provides a way to delete or update all messages
+ * in a thread.
+ */
+public class MmsSmsProvider extends ContentProvider {
+ private static final UriMatcher URI_MATCHER =
+ new UriMatcher(UriMatcher.NO_MATCH);
+ private static final String LOG_TAG = "MmsSmsProvider";
+
+ private static final String NO_DELETES_INSERTS_OR_UPDATES =
+ "MmsSmsProvider does not support deletes, inserts, or updates for this URI.";
+ private static final int URI_CONVERSATIONS = 0;
+ private static final int URI_CONVERSATIONS_MESSAGES = 1;
+ private static final int URI_CONVERSATIONS_RECIPIENTS = 2;
+ private static final int URI_MESSAGES_BY_PHONE = 3;
+ private static final int URI_THREAD_ID = 4;
+ private static final int URI_CANONICAL_ADDRESS = 5;
+ private static final int URI_PENDING_MSG = 6;
+ private static final int URI_COMPLETE_CONVERSATIONS = 7;
+ private static final int URI_UNDELIVERED_MSG = 8;
+ private static final int URI_CONVERSATIONS_SUBJECT = 9;
+ private static final int URI_NOTIFICATIONS = 10;
+ private static final int URI_OBSOLETE_THREADS = 11;
+ private static final int URI_DRAFT = 12;
+
+ /**
+ * the name of the table that is used to store the queue of
+ * messages(both MMS and SMS) to be sent/downloaded.
+ */
+ public static final String TABLE_PENDING_MSG = "pending_msgs";
+
+ // These constants are used to construct union queries across the
+ // MMS and SMS base tables.
+
+ // These are the columns that appear in both the MMS ("pdu") and
+ // SMS ("sms") message tables.
+ private static final String[] MMS_SMS_COLUMNS =
+ { BaseColumns._ID, Mms.DATE, Mms.READ, Mms.THREAD_ID };
+
+ // These are the columns that appear only in the MMS message
+ // table.
+ private static final String[] MMS_ONLY_COLUMNS = {
+ Mms.CONTENT_CLASS, Mms.CONTENT_LOCATION, Mms.CONTENT_TYPE,
+ Mms.DELIVERY_REPORT, Mms.EXPIRY, Mms.MESSAGE_CLASS, Mms.MESSAGE_ID,
+ Mms.MESSAGE_SIZE, Mms.MESSAGE_TYPE, Mms.MESSAGE_BOX, Mms.PRIORITY,
+ Mms.READ_STATUS, Mms.RESPONSE_STATUS, Mms.RESPONSE_TEXT,
+ Mms.RETRIEVE_STATUS, Mms.RETRIEVE_TEXT_CHARSET, Mms.REPORT_ALLOWED,
+ Mms.READ_REPORT, Mms.STATUS, Mms.SUBJECT, Mms.SUBJECT_CHARSET,
+ Mms.TRANSACTION_ID, Mms.MMS_VERSION };
+
+ // These are the columns that appear only in the SMS message
+ // table.
+ private static final String[] SMS_ONLY_COLUMNS =
+ { "address", "body", "person", "reply_path_present",
+ "service_center", "status", "subject", "type" };
+
+ // These are all the columns that appear in the "threads" table.
+ private static final String[] THREADS_COLUMNS = {
+ BaseColumns._ID,
+ ThreadsColumns.DATE,
+ ThreadsColumns.RECIPIENT_IDS,
+ ThreadsColumns.MESSAGE_COUNT
+ };
+
+ // These are all the columns that appear in the MMS and SMS
+ // message tables.
+ private static final String[] UNION_COLUMNS =
+ new String[MMS_SMS_COLUMNS.length
+ + MMS_ONLY_COLUMNS.length
+ + SMS_ONLY_COLUMNS.length];
+
+ // These are all the columns that appear in the MMS table.
+ private static final Set<String> MMS_COLUMNS = new HashSet<String>();
+
+ // These are all the columns that appear in the SMS table.
+ private static final Set<String> SMS_COLUMNS = new HashSet<String>();
+
+ private static final String VND_ANDROID_DIR_MMS_SMS =
+ "vnd.android-dir/mms-sms";
+
+ private static final String[] ID_PROJECTION = { BaseColumns._ID };
+
+ private static final String[] EMPTY_STRING_ARRAY = new String[0];
+
+ private static final String SMS_CONVERSATION_CONSTRAINT = "(" +
+ Sms.TYPE + " != " + Sms.MESSAGE_TYPE_DRAFT + ")";
+
+ private static final String MMS_CONVERSATION_CONSTRAINT = "(" +
+ Mms.MESSAGE_BOX + " != " + Mms.MESSAGE_BOX_DRAFTS + " AND (" +
+ Mms.MESSAGE_TYPE + " = " + PduHeaders.MESSAGE_TYPE_SEND_REQ + " OR " +
+ Mms.MESSAGE_TYPE + " = " + PduHeaders.MESSAGE_TYPE_RETRIEVE_CONF + " OR " +
+ Mms.MESSAGE_TYPE + " = " + PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND + "))";
+
+ private static final String AUTHORITY = "mms-sms";
+
+ static {
+ URI_MATCHER.addURI(AUTHORITY, "conversations", URI_CONVERSATIONS);
+ URI_MATCHER.addURI(AUTHORITY, "complete-conversations", URI_COMPLETE_CONVERSATIONS);
+
+ // In these patterns, "#" is the thread ID.
+ URI_MATCHER.addURI(
+ AUTHORITY, "conversations/#", URI_CONVERSATIONS_MESSAGES);
+ URI_MATCHER.addURI(
+ AUTHORITY, "conversations/#/recipients",
+ URI_CONVERSATIONS_RECIPIENTS);
+
+ URI_MATCHER.addURI(
+ AUTHORITY, "conversations/#/subject",
+ URI_CONVERSATIONS_SUBJECT);
+
+ // URI for deleting obsolete threads.
+ URI_MATCHER.addURI(AUTHORITY, "conversations/obsolete", URI_OBSOLETE_THREADS);
+
+ URI_MATCHER.addURI(
+ AUTHORITY, "messages/byphone/*",
+ URI_MESSAGES_BY_PHONE);
+
+ // In this pattern, two query parameter names are expected:
+ // "subject" and "recipient." Multiple "recipient" parameters
+ // may be present.
+ URI_MATCHER.addURI(AUTHORITY, "threadID", URI_THREAD_ID);
+
+ // Use this pattern to query the canonical address by given ID.
+ URI_MATCHER.addURI(AUTHORITY, "canonical-address/#", URI_CANONICAL_ADDRESS);
+
+ // In this pattern, two query parameters may be supplied:
+ // "protocol" and "message." For example:
+ // content://mms-sms/pending?
+ // -> Return all pending messages;
+ // content://mms-sms/pending?protocol=sms
+ // -> Only return pending SMs;
+ // content://mms-sms/pending?protocol=mms&message=1
+ // -> Return the the pending MM which ID equals '1'.
+ //
+ URI_MATCHER.addURI(AUTHORITY, "pending", URI_PENDING_MSG);
+
+ // Use this pattern to get a list of undelivered messages.
+ URI_MATCHER.addURI(AUTHORITY, "undelivered", URI_UNDELIVERED_MSG);
+
+ // Use this pattern to see what delivery status reports (for
+ // both MMS and SMS) have not been delivered to the user.
+ URI_MATCHER.addURI(AUTHORITY, "notifications", URI_NOTIFICATIONS);
+
+ URI_MATCHER.addURI(AUTHORITY, "draft", URI_DRAFT);
+ initializeColumnSets();
+ }
+
+ private SQLiteOpenHelper mOpenHelper;
+
+ @Override
+ public boolean onCreate() {
+ mOpenHelper = MmsSmsDatabaseHelper.getInstance(getContext());
+ return true;
+ }
+
+ @Override
+ public Cursor query(Uri uri, String[] projection,
+ String selection, String[] selectionArgs, String sortOrder) {
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ Cursor cursor = null;
+
+ switch(URI_MATCHER.match(uri)) {
+ case URI_COMPLETE_CONVERSATIONS:
+ cursor = getCompleteConversations(
+ projection, selection, selectionArgs, sortOrder);
+ break;
+ case URI_CONVERSATIONS:
+ String simple = uri.getQueryParameter("simple");
+ if ((simple != null) && simple.equals("true")) {
+ String threadType = uri.getQueryParameter("thread_type");
+ if (!TextUtils.isEmpty(threadType)) {
+ selection = concatSelections(
+ selection, Threads.TYPE + "=" + threadType);
+ }
+ cursor = getSimpleConversations(
+ projection, selection, selectionArgs, sortOrder);
+ } else {
+ cursor = getConversations(
+ projection, selection, selectionArgs, sortOrder);
+ }
+ break;
+ case URI_CONVERSATIONS_MESSAGES:
+ cursor = getConversationMessages(
+ uri.getPathSegments().get(1), projection, selection,
+ selectionArgs, sortOrder);
+ break;
+ case URI_CONVERSATIONS_RECIPIENTS:
+ cursor = getConversationById(
+ uri.getPathSegments().get(1), projection, selection,
+ selectionArgs, sortOrder);
+ break;
+ case URI_CONVERSATIONS_SUBJECT:
+ cursor = getConversationById(
+ uri.getPathSegments().get(1), projection, selection,
+ selectionArgs, sortOrder);
+ break;
+ case URI_MESSAGES_BY_PHONE:
+ cursor = getMessagesByPhoneNumber(
+ uri.getPathSegments().get(2), projection, selection,
+ selectionArgs, sortOrder);
+ break;
+ case URI_THREAD_ID:
+ List<String> recipients = uri.getQueryParameters("recipient");
+
+ cursor = getThreadId(recipients);
+ break;
+ case URI_CANONICAL_ADDRESS: {
+ String extraSelection = "_id=" + uri.getPathSegments().get(1);
+ String finalSelection = TextUtils.isEmpty(selection)
+ ? extraSelection : extraSelection + " AND " + selection;
+ cursor = db.query("canonical_addresses",
+ new String[] {"address"}, finalSelection, selectionArgs,
+ null, null, sortOrder);
+ break;
+ }
+ case URI_PENDING_MSG: {
+ String protoName = uri.getQueryParameter("protocol");
+ String msgId = uri.getQueryParameter("message");
+ int proto = TextUtils.isEmpty(protoName) ? -1
+ : (protoName.equals("sms") ? MmsSms.SMS_PROTO : MmsSms.MMS_PROTO);
+
+ String extraSelection = (proto != -1) ?
+ (PendingMessages.PROTO_TYPE + "=" + proto) : " 0=0 ";
+ if (!TextUtils.isEmpty(msgId)) {
+ extraSelection += " AND " + PendingMessages.MSG_ID + "=" + msgId;
+ }
+
+ String finalSelection = TextUtils.isEmpty(selection)
+ ? extraSelection : ("(" + extraSelection + ") AND " + selection);
+ String finalOrder = TextUtils.isEmpty(sortOrder)
+ ? PendingMessages.DUE_TIME : sortOrder;
+ cursor = db.query(TABLE_PENDING_MSG, null,
+ finalSelection, selectionArgs, null, null, finalOrder);
+ break;
+ }
+ case URI_UNDELIVERED_MSG: {
+ cursor = getUndeliveredMessages(projection, selection,
+ selectionArgs, sortOrder);
+ break;
+ }
+ case URI_DRAFT: {
+ cursor = getDraftThread(projection, selection, selectionArgs, sortOrder);
+ break;
+ }
+ default:
+ throw new IllegalStateException("Unrecognized URI:" + uri);
+ }
+
+ cursor.setNotificationUri(getContext().getContentResolver(), MmsSms.CONTENT_URI);
+ return cursor;
+ }
+
+ /**
+ * Return the canonical address ID for this address.
+ */
+ private long getSingleAddressId(String address) {
+ boolean isEmail = Mms.isEmailAddress(address);
+ String refinedAddress = isEmail ? address.toLowerCase() : address;
+ String selection =
+ isEmail
+ ? "address = ?"
+ : "PHONE_NUMBERS_EQUAL(address, ?)";
+ String[] selectionArgs = new String[] { refinedAddress };
+ Cursor cursor = null;
+
+ try {
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ cursor = db.query(
+ "canonical_addresses", ID_PROJECTION,
+ selection, selectionArgs, null, null, null);
+
+ if (cursor.getCount() == 0) {
+ ContentValues contentValues = new ContentValues(1);
+ contentValues.put(CanonicalAddressesColumns.ADDRESS, refinedAddress);
+
+ db = mOpenHelper.getWritableDatabase();
+ return db.insert("canonical_addresses",
+ CanonicalAddressesColumns.ADDRESS, contentValues);
+ }
+
+ if (cursor.moveToFirst()) {
+ return cursor.getLong(cursor.getColumnIndexOrThrow(BaseColumns._ID));
+ }
+ } finally {
+ if (cursor != null) {
+ cursor.close();
+ }
+ }
+
+ return -1L;
+ }
+
+ /**
+ * Return the canonical address IDs for these addresses.
+ */
+ private Set<Long> getAddressIds(List<String> addresses) {
+ Set<Long> result = new HashSet<Long>(addresses.size());
+
+ for (String address : addresses) {
+ if (!address.equals(PduHeaders.FROM_INSERT_ADDRESS_TOKEN_STR)) {
+ long id = getSingleAddressId(address);
+ if (id != -1L) {
+ result.add(id);
+ } else {
+ Log.e(LOG_TAG, "Address ID not found for: " + address);
+ }
+ }
+ }
+ return result;
+ }
+
+ /**
+ * Return a sorted array of the given Set of Longs.
+ */
+ private long[] getSortedSet(Set<Long> numbers) {
+ int size = numbers.size();
+ long[] result = new long[size];
+ int i = 0;
+
+ for (Long number : numbers) {
+ result[i++] = number;
+ }
+ Arrays.sort(result);
+ return result;
+ }
+
+ /**
+ * Return a String of the numbers in the given array, in order,
+ * separated by spaces.
+ */
+ private String getSpaceSeparatedNumbers(long[] numbers) {
+ int size = numbers.length;
+ StringBuilder buffer = new StringBuilder();
+
+ for (int i = 0; i < size; i++) {
+ if (i != 0) {
+ buffer.append(' ');
+ }
+ buffer.append(numbers[i]);
+ }
+ return buffer.toString();
+ }
+
+ /**
+ * Insert a record for a new thread.
+ */
+ private void insertThread(String recipientIds, int numberOfRecipients) {
+ ContentValues values = new ContentValues(4);
+
+ long date = System.currentTimeMillis();
+ values.put(ThreadsColumns.DATE, date - date % 1000);
+ values.put(ThreadsColumns.RECIPIENT_IDS, recipientIds);
+ if (numberOfRecipients > 1) {
+ values.put(Threads.TYPE, Threads.BROADCAST_THREAD);
+ }
+ values.put(ThreadsColumns.MESSAGE_COUNT, 0);
+
+ mOpenHelper.getWritableDatabase().insert("threads", null, values);
+ getContext().getContentResolver().notifyChange(MmsSms.CONTENT_URI, null);
+ }
+
+ /**
+ * Return the thread ID for this list of
+ * recipients IDs. If no thread exists with this ID, create
+ * one and return it. Callers should always use
+ * Threads.getThreadId to access this information.
+ */
+ private synchronized Cursor getThreadId(List<String> recipients) {
+ String recipientIds =
+ getSpaceSeparatedNumbers(
+ getSortedSet(getAddressIds(recipients)));
+ String THREAD_QUERY = "SELECT _id FROM threads " +
+ "WHERE recipient_ids = ?";
+
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ Cursor cursor = db.rawQuery(THREAD_QUERY, new String[] { recipientIds });
+
+ if (cursor.getCount() == 0) {
+ cursor.close();
+ insertThread(recipientIds, recipients.size());
+ db = mOpenHelper.getReadableDatabase(); // In case insertThread closed it
+ cursor = db.rawQuery(THREAD_QUERY, new String[] { recipientIds });
+ }
+
+ return cursor;
+ }
+
+ private static String concatSelections(String selection1, String selection2) {
+ if (TextUtils.isEmpty(selection1)) {
+ return selection2;
+ } else if (TextUtils.isEmpty(selection2)) {
+ return selection1;
+ } else {
+ return selection1 + " AND " + selection2;
+ }
+ }
+
+ /**
+ * If a null projection is given, return the union of all columns
+ * in both the MMS and SMS messages tables. Otherwise, return the
+ * given projection.
+ */
+ private static String[] handleNullMessageProjection(
+ String[] projection) {
+ return projection == null ? UNION_COLUMNS : projection;
+ }
+
+ /**
+ * If a null projection is given, return the set of all columns in
+ * the threads table. Otherwise, return the given projection.
+ */
+ private static String[] handleNullThreadsProjection(
+ String[] projection) {
+ return projection == null ? THREADS_COLUMNS : projection;
+ }
+
+ /**
+ * If a null sort order is given, return "normalized_date ASC".
+ * Otherwise, return the given sort order.
+ */
+ private static String handleNullSortOrder (String sortOrder) {
+ return sortOrder == null ? "normalized_date ASC" : sortOrder;
+ }
+
+ /**
+ * Return existing threads in the database.
+ */
+ private Cursor getSimpleConversations(String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ return mOpenHelper.getReadableDatabase().query("threads", projection,
+ selection, selectionArgs, null, null, " date DESC");
+ }
+
+ /**
+ * Return the thread which has draft in both MMS and SMS.
+ *
+ * Use this query:
+ *
+ * SELECT ...
+ * FROM (SELECT _id, thread_id, ...
+ * FROM pdu
+ * WHERE msg_box = 3 AND ...
+ * UNION
+ * SELECT _id, thread_id, ...
+ * FROM sms
+ * WHERE type = 3 AND ...
+ * )
+ * ;
+ */
+ private Cursor getDraftThread(String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ String[] innerProjection = new String[] {BaseColumns._ID, Conversations.THREAD_ID};
+ SQLiteQueryBuilder mmsQueryBuilder = new SQLiteQueryBuilder();
+ SQLiteQueryBuilder smsQueryBuilder = new SQLiteQueryBuilder();
+
+ mmsQueryBuilder.setTables(MmsProvider.TABLE_PDU);
+ smsQueryBuilder.setTables(SmsProvider.TABLE_SMS);
+
+ String mmsSubQuery = mmsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerProjection,
+ MMS_COLUMNS, 1, "mms",
+ concatSelections(selection, Mms.MESSAGE_BOX + "=" + Mms.MESSAGE_BOX_DRAFTS),
+ selectionArgs, null, null);
+ String smsSubQuery = smsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerProjection,
+ SMS_COLUMNS, 1, "sms",
+ concatSelections(selection, Sms.TYPE + "=" + Sms.MESSAGE_TYPE_DRAFT),
+ selectionArgs, null, null);
+ SQLiteQueryBuilder unionQueryBuilder = new SQLiteQueryBuilder();
+
+ unionQueryBuilder.setDistinct(true);
+
+ String unionQuery = unionQueryBuilder.buildUnionQuery(
+ new String[] { mmsSubQuery, smsSubQuery }, null, null);
+
+ SQLiteQueryBuilder outerQueryBuilder = new SQLiteQueryBuilder();
+
+ outerQueryBuilder.setTables("(" + unionQuery + ")");
+
+ String outerQuery = outerQueryBuilder.buildQuery(
+ projection, null, null, null, null, sortOrder, null);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(outerQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Return the most recent message in each conversation in both MMS
+ * and SMS.
+ *
+ * Use this query:
+ *
+ * SELECT ...
+ * FROM (SELECT thread_id AS tid, date * 1000 AS normalized_date, ...
+ * FROM pdu
+ * WHERE msg_box != 3 AND ...
+ * GROUP BY thread_id
+ * HAVING date = MAX(date)
+ * UNION
+ * SELECT thread_id AS tid, date AS normalized_date, ...
+ * FROM sms
+ * WHERE ...
+ * GROUP BY thread_id
+ * HAVING date = MAX(date))
+ * GROUP BY tid
+ * HAVING normalized_date = MAX(normalized_date);
+ *
+ * The msg_box != 3 comparisons ensure that we don't include draft
+ * messages.
+ */
+ private Cursor getConversations(String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ SQLiteQueryBuilder mmsQueryBuilder = new SQLiteQueryBuilder();
+ SQLiteQueryBuilder smsQueryBuilder = new SQLiteQueryBuilder();
+
+ mmsQueryBuilder.setTables(MmsProvider.TABLE_PDU);
+ smsQueryBuilder.setTables(SmsProvider.TABLE_SMS);
+
+ String[] columns = handleNullMessageProjection(projection);
+ String[] innerMmsProjection = makeProjectionWithDateAndThreadId(
+ UNION_COLUMNS, 1000);
+ String[] innerSmsProjection = makeProjectionWithDateAndThreadId(
+ UNION_COLUMNS, 1);
+ String mmsSubQuery = mmsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerMmsProjection,
+ MMS_COLUMNS, 1, "mms",
+ concatSelections(selection, MMS_CONVERSATION_CONSTRAINT), selectionArgs,
+ "thread_id", "date = MAX(date)");
+ String smsSubQuery = smsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerSmsProjection,
+ SMS_COLUMNS, 1, "sms",
+ concatSelections(selection, SMS_CONVERSATION_CONSTRAINT), selectionArgs,
+ "thread_id", "date = MAX(date)");
+ SQLiteQueryBuilder unionQueryBuilder = new SQLiteQueryBuilder();
+
+ unionQueryBuilder.setDistinct(true);
+
+ String unionQuery = unionQueryBuilder.buildUnionQuery(
+ new String[] { mmsSubQuery, smsSubQuery }, null, null);
+
+ SQLiteQueryBuilder outerQueryBuilder = new SQLiteQueryBuilder();
+
+ outerQueryBuilder.setTables("(" + unionQuery + ")");
+
+ String outerQuery = outerQueryBuilder.buildQuery(
+ columns, null, null, "tid",
+ "normalized_date = MAX(normalized_date)", sortOrder, null);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(outerQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Return every message in each conversation in both MMS
+ * and SMS.
+ */
+ private Cursor getCompleteConversations(String[] projection,
+ String selection, String[] selectionArgs, String sortOrder) {
+ String unionQuery = buildConversationQuery(
+ projection, selection, selectionArgs, sortOrder);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(unionQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Add normalized date and thread_id to the list of columns for an
+ * inner projection. This is necessary so that the outer query
+ * can have access to these columns even if the caller hasn't
+ * requested them in the result.
+ */
+ private String[] makeProjectionWithDateAndThreadId(
+ String[] projection, int dateMultiple) {
+ int projectionSize = projection.length;
+ String[] result = new String[projectionSize + 2];
+
+ result[0] = "thread_id AS tid";
+ result[1] = "date * " + dateMultiple + " AS normalized_date";
+ for (int i = 0; i < projectionSize; i++) {
+ result[i + 2] = projection[i];
+ }
+ return result;
+ }
+
+ /**
+ * Return the union of MMS and SMS messages for this thread ID.
+ */
+ private Cursor getConversationMessages(
+ String threadIdString, String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ try {
+ Long.parseLong(threadIdString);
+ } catch (NumberFormatException exception) {
+ Log.e(LOG_TAG, "Thread ID must be a Long.");
+ return null;
+ }
+
+ String finalSelection = concatSelections(
+ selection, "thread_id = " + threadIdString);
+ String unionQuery = buildConversationQuery(
+ projection, finalSelection, selectionArgs, sortOrder);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(unionQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Return the union of MMS and SMS messages whose recipients
+ * included this phone number.
+ *
+ * Use this query:
+ *
+ * SELECT ...
+ * FROM pdu, (SELECT _id AS address_id
+ * FROM addr
+ * WHERE PHONE_NUMBERS_EQUAL(addr.address, '<phoneNumber>'))
+ * AS matching_addresses
+ * WHERE pdu._id = matching_addresses.address_id
+ * UNION
+ * SELECT ...
+ * FROM sms
+ * WHERE PHONE_NUMBERS_EQUAL(sms.address, '<phoneNumber>');
+ */
+ private Cursor getMessagesByPhoneNumber(
+ String phoneNumber, String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ String escapedPhoneNumber = DatabaseUtils.sqlEscapeString(phoneNumber);
+ String finalMmsSelection =
+ concatSelections(
+ selection,
+ "pdu._id = matching_addresses.address_id");
+ String finalSmsSelection =
+ concatSelections(
+ selection,
+ "PHONE_NUMBERS_EQUAL(address, " +
+ escapedPhoneNumber + ")");
+ SQLiteQueryBuilder mmsQueryBuilder = new SQLiteQueryBuilder();
+ SQLiteQueryBuilder smsQueryBuilder = new SQLiteQueryBuilder();
+
+ mmsQueryBuilder.setDistinct(true);
+ smsQueryBuilder.setDistinct(true);
+ mmsQueryBuilder.setTables(
+ MmsProvider.TABLE_PDU +
+ ", (SELECT _id AS address_id " +
+ "FROM addr WHERE PHONE_NUMBERS_EQUAL(addr.address, " +
+ escapedPhoneNumber + ")) " +
+ "AS matching_addresses");
+ smsQueryBuilder.setTables(SmsProvider.TABLE_SMS);
+
+ String[] columns = handleNullMessageProjection(projection);
+ String mmsSubQuery = mmsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, columns, MMS_COLUMNS,
+ 0, "mms", finalMmsSelection, selectionArgs, null, null);
+ String smsSubQuery = smsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, columns, SMS_COLUMNS,
+ 0, "sms", finalSmsSelection, selectionArgs, null, null);
+ SQLiteQueryBuilder unionQueryBuilder = new SQLiteQueryBuilder();
+
+ unionQueryBuilder.setDistinct(true);
+
+ String unionQuery = unionQueryBuilder.buildUnionQuery(
+ new String[] { mmsSubQuery, smsSubQuery }, sortOrder, null);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(unionQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Return the conversation of certain thread ID.
+ */
+ private Cursor getConversationById(
+ String threadIdString, String[] projection, String selection,
+ String[] selectionArgs, String sortOrder) {
+ try {
+ Long.parseLong(threadIdString);
+ } catch (NumberFormatException exception) {
+ Log.e(LOG_TAG, "Thread ID must be a Long.");
+ return null;
+ }
+
+ String extraSelection = "_id=" + threadIdString;
+ String finalSelection = concatSelections(selection, extraSelection);
+ SQLiteQueryBuilder queryBuilder = new SQLiteQueryBuilder();
+ String[] columns = handleNullThreadsProjection(projection);
+
+ queryBuilder.setDistinct(true);
+ queryBuilder.setTables("threads");
+ return queryBuilder.query(
+ mOpenHelper.getReadableDatabase(), columns, finalSelection,
+ selectionArgs, sortOrder, null, null);
+ }
+
+ private static String joinPduAndPendingMsgTables() {
+ return MmsProvider.TABLE_PDU + " LEFT JOIN " + TABLE_PENDING_MSG
+ + " ON pdu._id = pending_msgs.msg_id";
+ }
+
+ private static String[] createMmsProjection(String[] old) {
+ String[] newProjection = new String[old.length];
+ for (int i = 0; i < old.length; i++) {
+ if (old[i].equals(BaseColumns._ID)) {
+ newProjection[i] = "pdu._id";
+ } else {
+ newProjection[i] = old[i];
+ }
+ }
+ return newProjection;
+ }
+
+ private Cursor getUndeliveredMessages(
+ String[] projection, String selection, String[] selectionArgs,
+ String sortOrder) {
+ String[] mmsProjection = createMmsProjection(projection);
+
+ SQLiteQueryBuilder mmsQueryBuilder = new SQLiteQueryBuilder();
+ SQLiteQueryBuilder smsQueryBuilder = new SQLiteQueryBuilder();
+
+ mmsQueryBuilder.setTables(joinPduAndPendingMsgTables());
+ smsQueryBuilder.setTables(SmsProvider.TABLE_SMS);
+
+ String finalMmsSelection = concatSelections(
+ selection, Mms.MESSAGE_BOX + " = " + Mms.MESSAGE_BOX_OUTBOX);
+ String finalSmsSelection = concatSelections(
+ selection, "(" + Sms.TYPE + " = " + Sms.MESSAGE_TYPE_OUTBOX
+ + " OR " + Sms.TYPE + " = " + Sms.MESSAGE_TYPE_FAILED
+ + " OR " + Sms.TYPE + " = " + Sms.MESSAGE_TYPE_QUEUED + ")");
+
+ String[] smsColumns = handleNullMessageProjection(projection);
+ String[] mmsColumns = handleNullMessageProjection(mmsProjection);
+ String[] innerMmsProjection = makeProjectionWithDateAndThreadId(
+ mmsColumns, 1000);
+ String[] innerSmsProjection = makeProjectionWithDateAndThreadId(
+ smsColumns, 1);
+
+ Set<String> columnsPresentInTable = new HashSet<String>(MMS_COLUMNS);
+ columnsPresentInTable.add("pdu._id");
+ columnsPresentInTable.add(PendingMessages.ERROR_TYPE);
+ String mmsSubQuery = mmsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerMmsProjection,
+ columnsPresentInTable, 1, "mms", finalMmsSelection, selectionArgs,
+ null, null);
+ String smsSubQuery = smsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerSmsProjection,
+ SMS_COLUMNS, 1, "sms", finalSmsSelection, selectionArgs,
+ null, null);
+ SQLiteQueryBuilder unionQueryBuilder = new SQLiteQueryBuilder();
+
+ unionQueryBuilder.setDistinct(true);
+
+ String unionQuery = unionQueryBuilder.buildUnionQuery(
+ new String[] { smsSubQuery, mmsSubQuery }, null, null);
+
+ SQLiteQueryBuilder outerQueryBuilder = new SQLiteQueryBuilder();
+
+ outerQueryBuilder.setTables("(" + unionQuery + ")");
+
+ String outerQuery = outerQueryBuilder.buildQuery(
+ smsColumns, null, null, null, null, sortOrder, null);
+
+ return mOpenHelper.getReadableDatabase().rawQuery(outerQuery, EMPTY_STRING_ARRAY);
+ }
+
+ /**
+ * Add normalized date to the list of columns for an inner
+ * projection.
+ */
+ private static String[] makeProjectionWithNormalizedDate(
+ String[] projection, int dateMultiple) {
+ int projectionSize = projection.length;
+ String[] result = new String[projectionSize + 1];
+
+ result[0] = "date * " + dateMultiple + " AS normalized_date";
+ System.arraycopy(projection, 0, result, 1, projectionSize);
+ return result;
+ }
+
+ private static String buildConversationQuery(String[] projection,
+ String selection, String[] selectionArgs, String sortOrder) {
+ String[] mmsProjection = createMmsProjection(projection);
+
+ SQLiteQueryBuilder mmsQueryBuilder = new SQLiteQueryBuilder();
+ SQLiteQueryBuilder smsQueryBuilder = new SQLiteQueryBuilder();
+
+ mmsQueryBuilder.setDistinct(true);
+ smsQueryBuilder.setDistinct(true);
+ mmsQueryBuilder.setTables(joinPduAndPendingMsgTables());
+ smsQueryBuilder.setTables(SmsProvider.TABLE_SMS);
+
+ String[] smsColumns = handleNullMessageProjection(projection);
+ String[] mmsColumns = handleNullMessageProjection(mmsProjection);
+ String[] innerMmsProjection = makeProjectionWithNormalizedDate(mmsColumns, 1000);
+ String[] innerSmsProjection = makeProjectionWithNormalizedDate(smsColumns, 1);
+
+ Set<String> columnsPresentInTable = new HashSet<String>(MMS_COLUMNS);
+ columnsPresentInTable.add("pdu._id");
+ columnsPresentInTable.add(PendingMessages.ERROR_TYPE);
+
+ String mmsSelection = concatSelections(selection,
+ Mms.MESSAGE_BOX + " != " + Mms.MESSAGE_BOX_DRAFTS);
+ String mmsSubQuery = mmsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerMmsProjection,
+ columnsPresentInTable, 0, "mms",
+ concatSelections(mmsSelection, MMS_CONVERSATION_CONSTRAINT),
+ selectionArgs, null, null);
+ String smsSubQuery = smsQueryBuilder.buildUnionSubQuery(
+ MmsSms.TYPE_DISCRIMINATOR_COLUMN, innerSmsProjection, SMS_COLUMNS,
+ 0, "sms", concatSelections(selection, SMS_CONVERSATION_CONSTRAINT),
+ selectionArgs, null, null);
+ SQLiteQueryBuilder unionQueryBuilder = new SQLiteQueryBuilder();
+
+ unionQueryBuilder.setDistinct(true);
+
+ String unionQuery = unionQueryBuilder.buildUnionQuery(
+ new String[] { smsSubQuery, mmsSubQuery },
+ handleNullSortOrder(sortOrder), null);
+
+ SQLiteQueryBuilder outerQueryBuilder = new SQLiteQueryBuilder();
+
+ outerQueryBuilder.setTables("(" + unionQuery + ")");
+
+ return outerQueryBuilder.buildQuery(
+ smsColumns, null, null, null, null, sortOrder, null);
+ }
+
+ @Override
+ public String getType(Uri uri) {
+ return VND_ANDROID_DIR_MMS_SMS;
+ }
+
+ @Override
+ public int delete(Uri uri, String selection,
+ String[] selectionArgs) {
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ Context context = getContext();
+ int affectedRows = 0;
+
+ switch(URI_MATCHER.match(uri)) {
+ case URI_CONVERSATIONS_MESSAGES:
+ long threadId;
+ try {
+ threadId = Long.parseLong(uri.getLastPathSegment());
+ } catch (NumberFormatException e) {
+ Log.e(LOG_TAG, "Thread ID must be a long.");
+ break;
+ }
+ affectedRows = deleteConversation(uri, selection, selectionArgs);
+ MmsSmsDatabaseHelper.updateThread(db, threadId);
+ break;
+ case URI_CONVERSATIONS:
+ affectedRows = MmsProvider.deleteMessages(context, db,
+ selection, selectionArgs, uri)
+ + db.delete("sms", selection, selectionArgs);
+ MmsSmsDatabaseHelper.updateAllThreads(db, selection, selectionArgs);
+ break;
+ case URI_OBSOLETE_THREADS:
+ affectedRows = db.delete("threads",
+ "_id NOT IN (SELECT DISTINCT thread_id FROM sms " +
+ "UNION SELECT DISTINCT thread_id FROM pdu)", null);
+ break;
+ default:
+ throw new UnsupportedOperationException(NO_DELETES_INSERTS_OR_UPDATES);
+ }
+
+ if (affectedRows > 0) {
+ context.getContentResolver().notifyChange(MmsSms.CONTENT_URI, null);
+ }
+ return affectedRows;
+ }
+
+ /**
+ * Delete the conversation with the given thread ID.
+ */
+ private int deleteConversation(Uri uri, String selection, String[] selectionArgs) {
+ String threadId = uri.getLastPathSegment();
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ String finalSelection = concatSelections(selection, "thread_id = " + threadId);
+ return MmsProvider.deleteMessages(getContext(), db, finalSelection,
+ selectionArgs, uri)
+ + db.delete("sms", finalSelection, selectionArgs);
+ }
+
+ @Override
+ public Uri insert(Uri uri, ContentValues values) {
+ throw new UnsupportedOperationException(NO_DELETES_INSERTS_OR_UPDATES);
+ }
+
+ @Override
+ public int update(Uri uri, ContentValues values,
+ String selection, String[] selectionArgs) {
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int affectedRows = 0;
+ switch(URI_MATCHER.match(uri)) {
+ case URI_CONVERSATIONS_MESSAGES:
+ String threadIdString = uri.getPathSegments().get(1);
+ affectedRows = updateConversation(threadIdString, values,
+ selection, selectionArgs);
+ break;
+ case URI_PENDING_MSG:
+ affectedRows = db.update(TABLE_PENDING_MSG, values, selection, null);
+ break;
+ default:
+ throw new UnsupportedOperationException(
+ NO_DELETES_INSERTS_OR_UPDATES);
+ }
+
+ if (affectedRows > 0) {
+ getContext().getContentResolver().notifyChange(
+ MmsSms.CONTENT_URI, null);
+ }
+ return affectedRows;
+ }
+
+ private int updateConversation(
+ String threadIdString, ContentValues values, String selection,
+ String[] selectionArgs) {
+ try {
+ Long.parseLong(threadIdString);
+ } catch (NumberFormatException exception) {
+ Log.e(LOG_TAG, "Thread ID must be a Long.");
+ return 0;
+ }
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ String finalSelection = concatSelections(selection, "thread_id=" + threadIdString);
+ return db.update(MmsProvider.TABLE_PDU, values, finalSelection, selectionArgs)
+ + db.update("sms", values, finalSelection, selectionArgs);
+ }
+
+ /**
+ * Construct Sets of Strings containing exactly the columns
+ * present in each table. We will use this when constructing
+ * UNION queries across the MMS and SMS tables.
+ */
+ private static void initializeColumnSets() {
+ int commonColumnCount = MMS_SMS_COLUMNS.length;
+ int mmsOnlyColumnCount = MMS_ONLY_COLUMNS.length;
+ int smsOnlyColumnCount = SMS_ONLY_COLUMNS.length;
+ Set<String> unionColumns = new HashSet<String>();
+
+ for (int i = 0; i < commonColumnCount; i++) {
+ MMS_COLUMNS.add(MMS_SMS_COLUMNS[i]);
+ SMS_COLUMNS.add(MMS_SMS_COLUMNS[i]);
+ unionColumns.add(MMS_SMS_COLUMNS[i]);
+ }
+ for (int i = 0; i < mmsOnlyColumnCount; i++) {
+ MMS_COLUMNS.add(MMS_ONLY_COLUMNS[i]);
+ unionColumns.add(MMS_ONLY_COLUMNS[i]);
+ }
+ for (int i = 0; i < smsOnlyColumnCount; i++) {
+ SMS_COLUMNS.add(SMS_ONLY_COLUMNS[i]);
+ unionColumns.add(SMS_ONLY_COLUMNS[i]);
+ }
+
+ int i = 0;
+ for (String columnName : unionColumns) {
+ UNION_COLUMNS[i++] = columnName;
+ }
+ }
+}
diff --git a/src/com/android/providers/telephony/SmsProvider.java b/src/com/android/providers/telephony/SmsProvider.java
new file mode 100644
index 0000000..ee60142
--- /dev/null
+++ b/src/com/android/providers/telephony/SmsProvider.java
@@ -0,0 +1,712 @@
+/*
+ * Copyright (C) 2006 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.providers.telephony;
+
+import android.content.ContentProvider;
+import android.content.ContentResolver;
+import android.content.ContentValues;
+import android.content.UriMatcher;
+import com.android.internal.database.ArrayListCursor;
+import android.database.Cursor;
+import android.database.DatabaseUtils;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.provider.Contacts;
+import android.provider.Telephony.Mms;
+import android.provider.Telephony.MmsSms;
+import android.provider.Telephony.Sms;
+import android.provider.Telephony.TextBasedSmsColumns;
+import android.provider.Telephony.Threads;
+import android.telephony.gsm.SmsManager;
+import android.telephony.gsm.SmsMessage;
+import android.text.TextUtils;
+import android.util.Config;
+import android.util.Log;
+
+import java.util.ArrayList;
+import java.util.HashMap;
+
+public class SmsProvider extends ContentProvider {
+ private static final Uri NOTIFICATION_URI = Uri.parse("content://sms");
+ private static final Uri SIM_URI = Uri.parse("content://sms/sim");
+ static final String TABLE_SMS = "sms";
+ private static final String TABLE_RAW = "raw";
+ private static final String TABLE_SR_PENDING = "sr_pending";
+
+ private static final Integer ONE = Integer.valueOf(1);
+
+ /**
+ * These are the columns that are available when reading SMS
+ * messages from the SIM. Columns whose names begin with "is_"
+ * have either "true" or "false" as their values.
+ */
+ private final static String[] SIM_COLUMNS = new String[] {
+ // N.B.: These columns must appear in the same order as the
+ // calls to add appear in convertSimToSms.
+ "service_center_address", // getServiceCenterAddress
+ "address", // getDisplayOriginatingAddress
+ "message_class", // getMessageClass
+ "body", // getDisplayMessageBody
+ "date", // getTimestampMillis
+ "status", // getStatusOnSim
+ "index_on_sim", // getIndexOnSim
+ "is_status_report", // isStatusReportMessage
+ "transport_type", // Always "sms".
+ "type" // Always MESSAGE_TYPE_ALL.
+ };
+
+ @Override
+ public boolean onCreate() {
+ mOpenHelper = MmsSmsDatabaseHelper.getInstance(getContext());
+ return true;
+ }
+
+ @Override
+ public Cursor query(Uri url, String[] projectionIn, String selection,
+ String[] selectionArgs, String sort) {
+ SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+
+ // Generate the body of the query.
+ int match = sURLMatcher.match(url);
+ switch (match) {
+ case SMS_ALL:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_ALL);
+ break;
+
+ case SMS_UNDELIVERED:
+ constructQueryForUndelivered(qb);
+ break;
+
+ case SMS_FAILED:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_FAILED);
+ break;
+
+ case SMS_QUEUED:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_QUEUED);
+ break;
+
+ case SMS_INBOX:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_INBOX);
+ break;
+
+ case SMS_SENT:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_SENT);
+ break;
+
+ case SMS_DRAFT:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_DRAFT);
+ break;
+
+ case SMS_OUTBOX:
+ constructQueryForBox(qb, Sms.MESSAGE_TYPE_OUTBOX);
+ break;
+
+ case SMS_ALL_ID:
+ qb.setTables(TABLE_SMS);
+ qb.appendWhere("(_id = " + url.getPathSegments().get(0) + ")");
+ break;
+
+ case SMS_INBOX_ID:
+ case SMS_FAILED_ID:
+ case SMS_SENT_ID:
+ case SMS_DRAFT_ID:
+ case SMS_OUTBOX_ID:
+ qb.setTables(TABLE_SMS);
+ qb.appendWhere("(_id = " + url.getPathSegments().get(1) + ")");
+ break;
+
+ case SMS_CONVERSATIONS_ID:
+ int threadID;
+
+ try {
+ threadID = Integer.parseInt(url.getPathSegments().get(1));
+ if (Config.LOGD) {
+ Log.d(TAG, "query conversations: threadID=" + threadID);
+ }
+ }
+ catch (Exception ex) {
+ Log.e(TAG,
+ "Bad conversation thread id: "
+ + url.getPathSegments().get(1));
+ return null;
+ }
+
+ qb.setTables(TABLE_SMS);
+ qb.appendWhere("thread_id = " + threadID);
+ break;
+
+ case SMS_CONVERSATIONS:
+ qb.setTables("sms, (SELECT thread_id AS group_thread_id, MAX(date) AS group_date, COUNT(*) AS msg_count FROM sms GROUP BY thread_id) AS groups");
+ qb.appendWhere("sms.thread_id = groups.group_thread_id AND sms.date = groups.group_date");
+ qb.setProjectionMap(sConversationProjectionMap);
+ break;
+
+ case SMS_RAW_MESSAGE:
+ qb.setTables("raw");
+ break;
+
+ case SMS_STATUS_PENDING:
+ qb.setTables("sr_pending");
+ break;
+
+ case SMS_ATTACHMENT:
+ qb.setTables("attachments");
+ break;
+
+ case SMS_ATTACHMENT_ID:
+ qb.setTables("attachments");
+ qb.appendWhere(
+ "(sms_id = " + url.getPathSegments().get(1) + ")");
+ break;
+
+ case SMS_QUERY_THREAD_ID:
+ qb.setTables("canonical_addresses");
+ if (projectionIn == null) {
+ projectionIn = sIDProjection;
+ }
+ break;
+
+ case SMS_STATUS_ID:
+ qb.setTables(TABLE_SMS);
+ qb.appendWhere("(_id = " + url.getPathSegments().get(1) + ")");
+ break;
+
+ case SMS_ALL_SIM:
+ return getAllMessagesFromSim();
+
+ case SMS_SIM:
+ String messageIndexString = url.getPathSegments().get(1);
+
+ return getSingleMessageFromSim(messageIndexString);
+
+ default:
+ Log.e(TAG, "Invalid request: " + url);
+ return null;
+ }
+
+ String orderBy = null;
+
+ if (!TextUtils.isEmpty(sort)) {
+ orderBy = sort;
+ } else if (qb.getTables().equals(TABLE_SMS)) {
+ orderBy = Sms.DEFAULT_SORT_ORDER;
+ }
+
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ Cursor ret = qb.query(db, projectionIn, selection, selectionArgs,
+ null, null, orderBy);
+
+ // TODO: Since the URLs are a mess, always use content://sms
+ ret.setNotificationUri(getContext().getContentResolver(),
+ NOTIFICATION_URI);
+ return ret;
+ }
+
+ private ArrayList<String> convertSimToSms(SmsMessage message) {
+ ArrayList result = new ArrayList();
+
+ // N.B.: These calls must appear in the same order as the
+ // columns appear in SIM_COLUMNS.
+ result.add(message.getServiceCenterAddress());
+ result.add(message.getDisplayOriginatingAddress());
+ result.add(message.getMessageClass().toString());
+ result.add(message.getDisplayMessageBody());
+ result.add(message.getTimestampMillis());
+ result.add(Sms.STATUS_NONE);
+ result.add(message.getIndexOnSim());
+ result.add(message.isStatusReportMessage());
+ result.add("sms");
+ result.add(TextBasedSmsColumns.MESSAGE_TYPE_ALL);
+ return result;
+ }
+
+ /**
+ * Return a Cursor containing just one message from the SIM.
+ */
+ private Cursor getSingleMessageFromSim(String messageIndexString) {
+ try {
+ int messageIndex = Integer.parseInt(messageIndexString);
+ SmsManager smsManager = SmsManager.getDefault();
+ ArrayList<SmsMessage> messages = smsManager.getAllMessagesFromSim();
+ ArrayList<ArrayList> singleRow = new ArrayList<ArrayList>();
+
+ SmsMessage message = messages.get(messageIndex);
+ if (message == null) {
+ throw new IllegalArgumentException(
+ "Message not retrieved. ID: " + messageIndexString);
+ }
+ singleRow.add(convertSimToSms(message));
+ return withSimNotificationUri(
+ new ArrayListCursor(SIM_COLUMNS, singleRow));
+ } catch (NumberFormatException exception) {
+ throw new IllegalArgumentException(
+ "Bad SMS SIM ID: " + messageIndexString);
+ }
+ }
+
+ /**
+ * Return a Cursor listing all the messages stored on the SIM.
+ */
+ private Cursor getAllMessagesFromSim() {
+ SmsManager smsManager = SmsManager.getDefault();
+ ArrayList<SmsMessage> messages = smsManager.getAllMessagesFromSim();
+ ArrayList<ArrayList> rows = new ArrayList<ArrayList>();
+
+ for (int count = messages.size(), i = 0; i < count; i++) {
+ SmsMessage message = messages.get(i);
+ if (message != null) {
+ rows.add(convertSimToSms(message));
+ }
+ }
+ return withSimNotificationUri(new ArrayListCursor(SIM_COLUMNS, rows));
+ }
+
+ private Cursor withSimNotificationUri(Cursor cursor) {
+ cursor.setNotificationUri(getContext().getContentResolver(),
+ SIM_URI);
+ return cursor;
+ }
+
+ private void constructQueryForBox(SQLiteQueryBuilder qb, int type) {
+ qb.setTables(TABLE_SMS);
+
+ if (type != Sms.MESSAGE_TYPE_ALL) {
+ qb.appendWhere("type=" + type);
+ }
+ }
+
+ private void constructQueryForUndelivered(SQLiteQueryBuilder qb) {
+ qb.setTables(TABLE_SMS);
+
+ qb.appendWhere("(type=" + Sms.MESSAGE_TYPE_OUTBOX +
+ " OR type=" + Sms.MESSAGE_TYPE_FAILED +
+ " OR type=" + Sms.MESSAGE_TYPE_QUEUED + ")");
+ }
+
+ @Override
+ public String getType(Uri url) {
+ switch (url.getPathSegments().size()) {
+ case 0:
+ return VND_ANDROID_DIR_SMS;
+ case 1:
+ try {
+ Integer.parseInt(url.getPathSegments().get(0));
+ return VND_ANDROID_SMS;
+ } catch (NumberFormatException ex) {
+ return VND_ANDROID_DIR_SMS;
+ }
+ case 2:
+ // TODO: What about "threadID"?
+ if (url.getPathSegments().get(0).equals("conversations")) {
+ return VND_ANDROID_SMSCHAT;
+ } else {
+ return VND_ANDROID_SMS;
+ }
+ }
+ return null;
+ }
+
+ @Override
+ public Uri insert(Uri url, ContentValues initialValues) {
+ ContentValues values;
+ long rowID;
+ int type = Sms.MESSAGE_TYPE_ALL;
+
+ int match = sURLMatcher.match(url);
+ if (Config.LOGD) {
+ Log.d(TAG, "insert url=" + url + ", match=" + match);
+ }
+
+ String table = TABLE_SMS;
+
+ switch (match) {
+ case SMS_ALL:
+ Integer typeObj = initialValues.getAsInteger(Sms.TYPE);
+ if (typeObj != null) {
+ type = typeObj.intValue();
+ } else {
+ // default to inbox
+ type = Sms.MESSAGE_TYPE_INBOX;
+ }
+ break;
+
+ case SMS_INBOX:
+ type = Sms.MESSAGE_TYPE_INBOX;
+ break;
+
+ case SMS_FAILED:
+ type = Sms.MESSAGE_TYPE_FAILED;
+ break;
+
+ case SMS_QUEUED:
+ type = Sms.MESSAGE_TYPE_QUEUED;
+ break;
+
+ case SMS_SENT:
+ type = Sms.MESSAGE_TYPE_SENT;
+ break;
+
+ case SMS_DRAFT:
+ type = Sms.MESSAGE_TYPE_DRAFT;
+ break;
+
+ case SMS_OUTBOX:
+ type = Sms.MESSAGE_TYPE_OUTBOX;
+ break;
+
+ case SMS_RAW_MESSAGE:
+ table = "raw";
+ break;
+
+ case SMS_STATUS_PENDING:
+ table = "sr_pending";
+ break;
+
+ case SMS_ATTACHMENT:
+ table = "attachments";
+ break;
+
+ case SMS_NEW_THREAD_ID:
+ table = "canonical_addresses";
+ break;
+
+ default:
+ Log.e(TAG, "Invalid request: " + url);
+ return null;
+ }
+
+ if (table.equals(TABLE_SMS)) {
+ boolean addDate = false;
+ boolean addType = false;
+
+ // Make sure that the date and type are set
+ if (initialValues == null) {
+ values = new ContentValues(1);
+ addDate = true;
+ addType = true;
+ } else {
+ values = new ContentValues(initialValues);
+
+ if (!initialValues.containsKey(Sms.DATE)) {
+ addDate = true;
+ }
+
+ if (!initialValues.containsKey(Sms.TYPE)) {
+ addType = true;
+ }
+ }
+
+ if (addDate) {
+ values.put(Sms.DATE, new Long(System.currentTimeMillis()));
+ }
+
+ if (addType && (type != Sms.MESSAGE_TYPE_ALL)) {
+ values.put(Sms.TYPE, Integer.valueOf(type));
+ }
+
+ // thread_id
+ Long threadId = values.getAsLong(Sms.THREAD_ID);
+ String address = values.getAsString(Sms.ADDRESS);
+
+ if (((threadId == null) || (threadId == 0)) && (address != null)) {
+ values.put(Sms.THREAD_ID, Threads.getOrCreateThreadId(
+ getContext(), address));
+ }
+
+ if (type == Sms.MESSAGE_TYPE_INBOX) {
+ // Look up the person if not already filled in.
+ if ((values.getAsLong(Sms.PERSON) == null)
+ && (!TextUtils.isEmpty(address))) {
+ Cursor cursor = getContext().getContentResolver().query(
+ Uri.withAppendedPath(
+ Contacts.Phones.CONTENT_FILTER_URL, address),
+ new String[] { Contacts.Phones.PERSON_ID },
+ null, null, null);
+ if (cursor != null) {
+ if (cursor.getCount() > 0) {
+ cursor.moveToFirst();
+ Long id = Long.valueOf(cursor.getLong(0));
+ values.put(Sms.PERSON, id);
+ }
+ cursor.deactivate();
+ }
+ }
+ } else {
+ // Mark all non-inbox messages read.
+ values.put(Sms.READ, ONE);
+ }
+ } else {
+ if (initialValues == null) {
+ values = new ContentValues(1);
+ } else {
+ values = initialValues;
+ }
+ }
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ rowID = db.insert(table, "body", values);
+ if (rowID > 0) {
+ Uri uri = Uri.parse("content://" + table + "/" + rowID);
+ notifyChange(uri);
+ return uri;
+ } else {
+ Log.e(TAG,
+ "SmsProvider.insert: failed! " + values.toString());
+ }
+
+ return null;
+ }
+
+ @Override
+ public int delete(Uri url, String where, String[] whereArgs) {
+ int count;
+ int match = sURLMatcher.match(url);
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ switch (match) {
+ case SMS_ALL:
+ count = db.delete(TABLE_SMS, where, whereArgs);
+ if (count != 0) {
+ // Don't update threads unless something changed.
+ MmsSmsDatabaseHelper.updateAllThreads(db, where, whereArgs);
+ }
+ break;
+
+ case SMS_ALL_ID:
+ try {
+ int message_id = Integer.parseInt(url.getPathSegments().get(0));
+ count = MmsSmsDatabaseHelper.deleteOneSms(db, message_id);
+ } catch (Exception e) {
+ throw new IllegalArgumentException(
+ "Bad message id: " + url.getPathSegments().get(0));
+ }
+ break;
+
+ case SMS_CONVERSATIONS_ID:
+ int threadID;
+
+ try {
+ threadID = Integer.parseInt(url.getPathSegments().get(1));
+ } catch (Exception ex) {
+ throw new IllegalArgumentException(
+ "Bad conversation thread id: "
+ + url.getPathSegments().get(1));
+ }
+
+ // delete the messages from the sms table
+ where = DatabaseUtils.concatenateWhere("thread_id=" + threadID, where);
+ count = db.delete(TABLE_SMS, where, whereArgs);
+ MmsSmsDatabaseHelper.updateThread(db, threadID);
+ break;
+
+ case SMS_RAW_MESSAGE:
+ count = db.delete("raw", where, whereArgs);
+ break;
+
+ case SMS_STATUS_PENDING:
+ count = db.delete("sr_pending", where, whereArgs);
+ break;
+
+ case SMS_SIM:
+ String messageIndexString = url.getPathSegments().get(1);
+
+ return deleteMessageFromSim(messageIndexString);
+
+ default:
+ throw new IllegalArgumentException("Unknown URL");
+ }
+
+ if (count > 0) {
+ notifyChange(url);
+ }
+ return count;
+ }
+
+ /**
+ * Delete the message at index from SIM. Return true iff
+ * successful.
+ */
+ private int deleteMessageFromSim(String messageIndexString) {
+ SmsManager smsManager = SmsManager.getDefault();
+
+ try {
+ return smsManager.deleteMessageFromSim(
+ Integer.parseInt(messageIndexString))
+ ? 1 : 0;
+ } catch (NumberFormatException exception) {
+ throw new IllegalArgumentException(
+ "Bad SMS SIM ID: " + messageIndexString);
+ } finally {
+ ContentResolver cr = getContext().getContentResolver();
+
+ cr.notifyChange(SIM_URI, null);
+ }
+ }
+
+ @Override
+ public int update(
+ Uri url, ContentValues values, String where, String[] whereArgs) {
+ int count = 0;
+ String table = TABLE_SMS;
+ String extraWhere = null;
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+ switch (sURLMatcher.match(url)) {
+ case SMS_RAW_MESSAGE:
+ table = TABLE_RAW;
+ break;
+
+ case SMS_STATUS_PENDING:
+ table = TABLE_SR_PENDING;
+ break;
+
+ case SMS_ALL:
+ case SMS_FAILED:
+ case SMS_QUEUED:
+ case SMS_INBOX:
+ case SMS_SENT:
+ case SMS_DRAFT:
+ case SMS_OUTBOX:
+ case SMS_CONVERSATIONS:
+ break;
+
+ case SMS_ALL_ID:
+ extraWhere = "_id=" + url.getPathSegments().get(0);
+ break;
+
+ case SMS_INBOX_ID:
+ case SMS_FAILED_ID:
+ case SMS_SENT_ID:
+ case SMS_DRAFT_ID:
+ case SMS_OUTBOX_ID:
+ extraWhere = "_id=" + url.getPathSegments().get(1);
+ break;
+
+ case SMS_CONVERSATIONS_ID: {
+ String threadId = url.getPathSegments().get(1);
+
+ try {
+ Integer.parseInt(threadId);
+ } catch (Exception ex) {
+ Log.e(TAG, "Bad conversation thread id: " + threadId);
+ break;
+ }
+
+ extraWhere = "thread_id=" + threadId;
+ break;
+ }
+
+ case SMS_STATUS_ID:
+ extraWhere = "_id=" + url.getPathSegments().get(1);
+ break;
+
+ default:
+ throw new UnsupportedOperationException(
+ "URI " + url + " not supported");
+ }
+
+ where = DatabaseUtils.concatenateWhere(where, extraWhere);
+ count = db.update(table, values, where, whereArgs);
+
+ if (count > 0) {
+ notifyChange(url);
+ }
+ return count;
+ }
+
+ private void notifyChange(Uri uri) {
+ ContentResolver cr = getContext().getContentResolver();
+ cr.notifyChange(uri, null);
+ cr.notifyChange(MmsSms.CONTENT_URI, null);
+ cr.notifyChange(Uri.parse("content://mms-sms/conversations/"), null);
+ }
+
+ private SQLiteOpenHelper mOpenHelper;
+
+ private final static String TAG = "SmsProvider";
+ private final static String VND_ANDROID_SMS = "vnd.android.cursor.item/sms";
+ private final static String VND_ANDROID_SMSCHAT =
+ "vnd.android.cursor.item/sms-chat";
+ private final static String VND_ANDROID_DIR_SMS =
+ "vnd.android.cursor.dir/sms";
+
+ private static final HashMap<String, String> sConversationProjectionMap =
+ new HashMap<String, String>();
+ private static final String[] sIDProjection = new String[] { "_id" };
+
+ private static final int SMS_ALL = 0;
+ private static final int SMS_ALL_ID = 1;
+ private static final int SMS_INBOX = 2;
+ private static final int SMS_INBOX_ID = 3;
+ private static final int SMS_SENT = 4;
+ private static final int SMS_SENT_ID = 5;
+ private static final int SMS_DRAFT = 6;
+ private static final int SMS_DRAFT_ID = 7;
+ private static final int SMS_OUTBOX = 8;
+ private static final int SMS_OUTBOX_ID = 9;
+ private static final int SMS_CONVERSATIONS = 10;
+ private static final int SMS_CONVERSATIONS_ID = 11;
+ private static final int SMS_RAW_MESSAGE = 15;
+ private static final int SMS_ATTACHMENT = 16;
+ private static final int SMS_ATTACHMENT_ID = 17;
+ private static final int SMS_NEW_THREAD_ID = 18;
+ private static final int SMS_QUERY_THREAD_ID = 19;
+ private static final int SMS_STATUS_ID = 20;
+ private static final int SMS_STATUS_PENDING = 21;
+ private static final int SMS_ALL_SIM = 22;
+ private static final int SMS_SIM = 23;
+ private static final int SMS_FAILED = 24;
+ private static final int SMS_FAILED_ID = 25;
+ private static final int SMS_QUEUED = 26;
+ private static final int SMS_UNDELIVERED = 27;
+
+ private static final UriMatcher sURLMatcher =
+ new UriMatcher(UriMatcher.NO_MATCH);
+
+ static {
+ sURLMatcher.addURI("sms", null, SMS_ALL);
+ sURLMatcher.addURI("sms", "#", SMS_ALL_ID);
+ sURLMatcher.addURI("sms", "inbox", SMS_INBOX);
+ sURLMatcher.addURI("sms", "inbox/#", SMS_INBOX_ID);
+ sURLMatcher.addURI("sms", "sent", SMS_SENT);
+ sURLMatcher.addURI("sms", "sent/#", SMS_SENT_ID);
+ sURLMatcher.addURI("sms", "draft", SMS_DRAFT);
+ sURLMatcher.addURI("sms", "draft/#", SMS_DRAFT_ID);
+ sURLMatcher.addURI("sms", "outbox", SMS_OUTBOX);
+ sURLMatcher.addURI("sms", "outbox/#", SMS_OUTBOX_ID);
+ sURLMatcher.addURI("sms", "undelivered", SMS_UNDELIVERED);
+ sURLMatcher.addURI("sms", "failed", SMS_FAILED);
+ sURLMatcher.addURI("sms", "failed/#", SMS_FAILED_ID);
+ sURLMatcher.addURI("sms", "queued", SMS_QUEUED);
+ sURLMatcher.addURI("sms", "conversations", SMS_CONVERSATIONS);
+ sURLMatcher.addURI("sms", "conversations/*", SMS_CONVERSATIONS_ID);
+ sURLMatcher.addURI("sms", "raw", SMS_RAW_MESSAGE);
+ sURLMatcher.addURI("sms", "attachments", SMS_ATTACHMENT);
+ sURLMatcher.addURI("sms", "attachments/#", SMS_ATTACHMENT_ID);
+ sURLMatcher.addURI("sms", "threadID", SMS_NEW_THREAD_ID);
+ sURLMatcher.addURI("sms", "threadID/*", SMS_QUERY_THREAD_ID);
+ sURLMatcher.addURI("sms", "status/#", SMS_STATUS_ID);
+ sURLMatcher.addURI("sms", "sr_pending", SMS_STATUS_PENDING);
+ sURLMatcher.addURI("sms", "sim", SMS_ALL_SIM);
+ sURLMatcher.addURI("sms", "sim/#", SMS_SIM);
+
+ sConversationProjectionMap.put(Sms.Conversations.SNIPPET,
+ "body AS snippet");
+ sConversationProjectionMap.put("delta", null);
+ }
+}
diff --git a/src/com/android/providers/telephony/TelephonyProvider.java b/src/com/android/providers/telephony/TelephonyProvider.java
new file mode 100644
index 0000000..324d007
--- /dev/null
+++ b/src/com/android/providers/telephony/TelephonyProvider.java
@@ -0,0 +1,516 @@
+/* //device/content/providers/telephony/TelephonyProvider.java
+**
+** Copyright 2006, 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.providers.telephony;
+
+import android.content.*;
+import android.content.res.Resources;
+import android.content.res.XmlResourceParser;
+import android.database.Cursor;
+import android.database.sqlite.SQLiteDatabase;
+import android.database.sqlite.SQLiteOpenHelper;
+import android.database.sqlite.SQLiteQueryBuilder;
+import android.net.Uri;
+import android.os.Environment;
+import android.provider.Telephony;
+import android.util.Config;
+import android.util.Log;
+import android.util.Xml;
+import com.android.internal.util.XmlUtils;
+
+import org.xmlpull.v1.XmlPullParser;
+import org.xmlpull.v1.XmlPullParserException;
+
+import java.io.File;
+import java.io.FileNotFoundException;
+import java.io.FileReader;
+import java.io.IOException;
+
+public class TelephonyProvider extends ContentProvider
+{
+ private static final String DATABASE_NAME = "telephony.db";
+ // DATABASE_VERSION needs to be in-sync with version in apns.xml.
+ private static final int DATABASE_VERSION = 4 << 16;
+ private static final int URL_TELEPHONY = 1;
+ private static final int URL_CURRENT = 2;
+ private static final int URL_ID = 3;
+ private static final int URL_RESTOREAPN = 4;
+
+ private static final String TAG = "TelephonyProvider";
+ private static final String CARRIERS_TABLE = "carriers";
+ private static final String PARTNER_APNS_PATH = "etc/apns-conf.xml";
+
+ private static final UriMatcher s_urlMatcher = new UriMatcher(UriMatcher.NO_MATCH);
+
+ private static final ContentValues s_currentNullMap;
+ private static final ContentValues s_currentSetMap;
+
+ static {
+ s_urlMatcher.addURI("telephony", "carriers", URL_TELEPHONY);
+ s_urlMatcher.addURI("telephony", "carriers/current", URL_CURRENT);
+ s_urlMatcher.addURI("telephony", "carriers/#", URL_ID);
+ s_urlMatcher.addURI("telephony", "carriers/restore", URL_RESTOREAPN);
+
+ s_currentNullMap = new ContentValues(1);
+ s_currentNullMap.put("current", (Long) null);
+
+ s_currentSetMap = new ContentValues(1);
+ s_currentSetMap.put("current", "1");
+ }
+
+ private static class DatabaseHelper extends SQLiteOpenHelper {
+ // Context to access resources with
+ private Context mContext;
+
+ /**
+ * DatabaseHelper helper class for loading apns into a database.
+ *
+ * @param parser the system-default parser for apns.xml
+ * @param confidential an optional parser for confidential APNS (stored separately)
+ */
+ public DatabaseHelper(Context context) {
+ super(context, DATABASE_NAME, null, getVersion(context));
+ mContext = context;
+ }
+
+ private static int getVersion(Context context) {
+ // Get the database version, combining a static schema version and the XML version
+ Resources r = context.getResources();
+ XmlResourceParser parser = r.getXml(com.android.internal.R.xml.apns);
+ try {
+ XmlUtils.beginDocument(parser, "apns");
+ int publicversion = Integer.parseInt(parser.getAttributeValue(null, "version"));
+ return DATABASE_VERSION | publicversion;
+ } catch (Exception e) {
+ Log.e(TAG, "Can't get version of APN database", e);
+ return DATABASE_VERSION;
+ } finally {
+ parser.close();
+ }
+ }
+
+ @Override
+ public void onCreate(SQLiteDatabase db) {
+ // Set up the database schema
+ db.execSQL("CREATE TABLE " + CARRIERS_TABLE +
+ "(_id INTEGER PRIMARY KEY," +
+ "name TEXT," +
+ "numeric TEXT," +
+ "mcc TEXT," +
+ "mnc TEXT," +
+ "apn TEXT," +
+ "user TEXT," +
+ "server TEXT," +
+ "password TEXT," +
+ "proxy TEXT," +
+ "port TEXT," +
+ "mmsproxy TEXT," +
+ "mmsport TEXT," +
+ "mmsc TEXT," +
+ "type TEXT," +
+ "current INTEGER);");
+
+ initDatabase(db);
+ }
+
+ private void initDatabase(SQLiteDatabase db) {
+ // Read internal APNS data
+ Resources r = mContext.getResources();
+ XmlResourceParser parser = r.getXml(com.android.internal.R.xml.apns);
+ int publicversion = -1;
+ try {
+ XmlUtils.beginDocument(parser, "apns");
+ publicversion = Integer.parseInt(parser.getAttributeValue(null, "version"));
+ loadApns(db, parser);
+ } catch (Exception e) {
+ Log.e(TAG, "Got execption while loading APN database.", e);
+ } finally {
+ parser.close();
+ }
+
+ // Read external APNS data (partner-provided)
+ XmlPullParser confparser = null;
+ // Environment.getRootDirectory() is a fancy way of saying ANDROID_ROOT or "/system".
+ File confFile = new File(Environment.getRootDirectory(), PARTNER_APNS_PATH);
+ FileReader confreader = null;
+ try {
+ confreader = new FileReader(confFile);
+ confparser = Xml.newPullParser();
+ confparser.setInput(confreader);
+ XmlUtils.beginDocument(confparser, "apns");
+
+ // Sanity check. Force internal version and confidential versions to agree
+ int confversion = Integer.parseInt(confparser.getAttributeValue(null, "version"));
+ if (publicversion != confversion) {
+ throw new IllegalStateException("Internal APNS file version doesn't match "
+ + confFile.getAbsolutePath());
+ }
+
+ loadApns(db, confparser);
+ } catch (FileNotFoundException e) {
+ // It's ok if the file isn't found. It means there isn't a confidential file
+ // Log.e(TAG, "File not found: '" + confFile.getAbsolutePath() + "'");
+ } catch (Exception e) {
+ Log.e(TAG, "Exception while parsing '" + confFile.getAbsolutePath() + "'", e);
+ } finally {
+ try { if (confreader != null) confreader.close(); } catch (IOException e) { }
+ }
+ }
+
+ @Override
+ public void onUpgrade(SQLiteDatabase db, int oldVersion, int newVersion) {
+ db.execSQL("DROP TABLE IF EXISTS " + CARRIERS_TABLE + ";");
+ onCreate(db);
+ }
+
+ /**
+ * Gets the next row of apn values.
+ *
+ * @param parser the parser
+ * @return the row or null if it's not an apn
+ */
+ private ContentValues getRow(XmlPullParser parser) {
+ if (!"apn".equals(parser.getName())) {
+ return null;
+ }
+
+ ContentValues map = new ContentValues();
+
+ String mcc = parser.getAttributeValue(null, "mcc");
+ String mnc = parser.getAttributeValue(null, "mnc");
+ String numeric = mcc + mnc;
+
+ map.put(Telephony.Carriers.NUMERIC,numeric);
+ map.put(Telephony.Carriers.MCC, mcc);
+ map.put(Telephony.Carriers.MNC, mnc);
+ map.put(Telephony.Carriers.NAME, parser.getAttributeValue(null, "carrier"));
+ map.put(Telephony.Carriers.APN, parser.getAttributeValue(null, "apn"));
+ map.put(Telephony.Carriers.USER, parser.getAttributeValue(null, "user"));
+ map.put(Telephony.Carriers.SERVER, parser.getAttributeValue(null, "server"));
+ map.put(Telephony.Carriers.PASSWORD, parser.getAttributeValue(null, "password"));
+
+ // do not add NULL to the map so that insert() will set the default value
+ String proxy = parser.getAttributeValue(null, "proxy");
+ if (proxy != null) {
+ map.put(Telephony.Carriers.PROXY, proxy);
+ }
+ String port = parser.getAttributeValue(null, "port");
+ if (port != null) {
+ map.put(Telephony.Carriers.PORT, port);
+ }
+ String mmsproxy = parser.getAttributeValue(null, "mmsproxy");
+ if (mmsproxy != null) {
+ map.put(Telephony.Carriers.MMSPROXY, mmsproxy);
+ }
+ String mmsport = parser.getAttributeValue(null, "mmsport");
+ if (mmsport != null) {
+ map.put(Telephony.Carriers.MMSPORT, mmsport);
+ }
+ map.put(Telephony.Carriers.MMSC, parser.getAttributeValue(null, "mmsc"));
+ String type = parser.getAttributeValue(null, "type");
+ if (type != null) {
+ map.put(Telephony.Carriers.TYPE, type);
+ }
+
+ return map;
+ }
+
+ /*
+ * Loads apns from xml file into the database
+ *
+ * @param db the sqlite database to write to
+ * @param parser the xml parser
+ *
+ */
+ private void loadApns(SQLiteDatabase db, XmlPullParser parser) {
+ if (parser != null) {
+ try {
+ while (true) {
+ XmlUtils.nextElement(parser);
+ ContentValues row = getRow(parser);
+ if (row != null) {
+ db.insert(CARRIERS_TABLE, null, row);
+ } else {
+ break; // do we really want to skip the rest of the file?
+ }
+ }
+ } catch (XmlPullParserException e) {
+ Log.e(TAG, "Got execption while getting perferred time zone.", e);
+ } catch (IOException e) {
+ Log.e(TAG, "Got execption while getting perferred time zone.", e);
+ }
+ }
+ }
+ }
+
+ @Override
+ public boolean onCreate() {
+ mOpenHelper = new DatabaseHelper(getContext());
+ return true;
+ }
+
+ @Override
+ public Cursor query(Uri url, String[] projectionIn, String selection,
+ String[] selectionArgs, String sort) {
+ SQLiteQueryBuilder qb = new SQLiteQueryBuilder();
+ qb.setTables("carriers");
+
+ int match = s_urlMatcher.match(url);
+ switch (match) {
+ // do nothing
+ case URL_TELEPHONY: {
+ break;
+ }
+
+
+ case URL_CURRENT: {
+ qb.appendWhere("current IS NOT NULL");
+ break;
+ }
+
+ case URL_ID: {
+ qb.appendWhere("_id = " + url.getPathSegments().get(1));
+ break;
+ }
+
+ default: {
+ return null;
+ }
+ }
+
+ SQLiteDatabase db = mOpenHelper.getReadableDatabase();
+ Cursor ret = qb.query(db, projectionIn, selection, selectionArgs, null, null, sort);
+ ret.setNotificationUri(getContext().getContentResolver(), url);
+ return ret;
+ }
+
+ @Override
+ public String getType(Uri url)
+ {
+ switch (s_urlMatcher.match(url)) {
+ case URL_TELEPHONY:
+ return "vnd.android.cursor.dir/telephony-carrier";
+
+ case URL_ID:
+ return "vnd.android.cursor.item/telephony-carrier";
+
+ default:
+ throw new IllegalArgumentException("Unknown URL " + url);
+ }
+ }
+
+ @Override
+ public Uri insert(Uri url, ContentValues initialValues)
+ {
+ Uri result = null;
+
+ checkPermission();
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int match = s_urlMatcher.match(url);
+ boolean notify = false;
+ switch (match)
+ {
+ case URL_TELEPHONY:
+ {
+ ContentValues values;
+ if (initialValues != null) {
+ values = new ContentValues(initialValues);
+ } else {
+ values = new ContentValues();
+ }
+
+ // TODO Review this. This code should probably not bet here.
+ // It is valid for the database to return a null string.
+ if (values.containsKey(Telephony.Carriers.NAME) == false) {
+ values.put(Telephony.Carriers.NAME, "");
+ }
+ if (values.containsKey(Telephony.Carriers.APN) == false) {
+ values.put(Telephony.Carriers.APN, "");
+ }
+ if (values.containsKey(Telephony.Carriers.PORT) == false) {
+ values.put(Telephony.Carriers.PORT, "");
+ }
+ if (values.containsKey(Telephony.Carriers.PROXY) == false) {
+ values.put(Telephony.Carriers.PROXY, "");
+ }
+ if (values.containsKey(Telephony.Carriers.USER) == false) {
+ values.put(Telephony.Carriers.USER, "");
+ }
+ if (values.containsKey(Telephony.Carriers.SERVER) == false) {
+ values.put(Telephony.Carriers.SERVER, "");
+ }
+ if (values.containsKey(Telephony.Carriers.PASSWORD) == false) {
+ values.put(Telephony.Carriers.PASSWORD, "");
+ }
+ if (values.containsKey(Telephony.Carriers.MMSPORT) == false) {
+ values.put(Telephony.Carriers.MMSPORT, "");
+ }
+ if (values.containsKey(Telephony.Carriers.MMSPROXY) == false) {
+ values.put(Telephony.Carriers.MMSPROXY, "");
+ }
+
+ long rowID = db.insert(CARRIERS_TABLE, null, values);
+ if (rowID > 0)
+ {
+ result = ContentUris.withAppendedId(Telephony.Carriers.CONTENT_URI, rowID);
+ notify = true;
+ }
+
+ if (Config.LOGD) Log.d(TAG, "inserted " + values.toString() + " rowID = " + rowID);
+ break;
+ }
+
+ case URL_CURRENT:
+ {
+ // null out the previous operator
+ db.update("carriers", s_currentNullMap, "current IS NOT NULL", null);
+
+ String numeric = initialValues.getAsString("numeric");
+ int updated = db.update("carriers", s_currentSetMap,
+ "numeric = '" + numeric + "'", null);
+
+ if (updated > 0)
+ {
+ if (Config.LOGD) {
+ Log.d(TAG, "Setting numeric '" + numeric + "' to be the current operator");
+ }
+ }
+ else
+ {
+ Log.e(TAG, "Failed setting numeric '" + numeric + "' to the current operator");
+ }
+ break;
+ }
+ }
+
+ if (notify) {
+ getContext().getContentResolver().notifyChange(Telephony.Carriers.CONTENT_URI, null);
+ }
+
+ return result;
+ }
+
+ @Override
+ public int delete(Uri url, String where, String[] whereArgs)
+ {
+ int count;
+
+ checkPermission();
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int match = s_urlMatcher.match(url);
+ switch (match)
+ {
+ case URL_TELEPHONY:
+ {
+ count = db.delete(CARRIERS_TABLE, where, whereArgs);
+ break;
+ }
+
+ case URL_CURRENT:
+ {
+ count = db.delete(CARRIERS_TABLE, where, whereArgs);
+ break;
+ }
+
+ case URL_ID:
+ {
+ count = db.delete(CARRIERS_TABLE, Telephony.Carriers._ID + "=?",
+ new String[] { url.getLastPathSegment() });
+ break;
+ }
+
+ case URL_RESTOREAPN: {
+ count = 1;
+ restoreDefaultAPN();
+ break;
+ }
+
+ default: {
+ throw new UnsupportedOperationException("Cannot delete that URL: " + url);
+ }
+ }
+
+ if (count > 0) {
+ getContext().getContentResolver().notifyChange(Telephony.Carriers.CONTENT_URI, null);
+ }
+
+ return count;
+ }
+
+ @Override
+ public int update(Uri url, ContentValues values, String where, String[] whereArgs)
+ {
+ int count;
+
+ checkPermission();
+
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+ int match = s_urlMatcher.match(url);
+ switch (match)
+ {
+ case URL_TELEPHONY:
+ {
+ count = db.update(CARRIERS_TABLE, values, where, whereArgs);
+ break;
+ }
+
+ case URL_CURRENT:
+ {
+ count = db.update(CARRIERS_TABLE, values, where, whereArgs);
+ break;
+ }
+
+ case URL_ID:
+ {
+ if (where != null || whereArgs != null) {
+ throw new UnsupportedOperationException(
+ "Cannot update URL " + url + " with a where clause");
+ }
+ count = db.update(CARRIERS_TABLE, values, Telephony.Carriers._ID + "=?",
+ new String[] { url.getLastPathSegment() });
+ break;
+ }
+
+ default: {
+ throw new UnsupportedOperationException("Cannot update that URL: " + url);
+ }
+ }
+
+ if (count > 0) {
+ getContext().getContentResolver().notifyChange(Telephony.Carriers.CONTENT_URI, null);
+ }
+
+ return count;
+ }
+
+ private void checkPermission() {
+ // Check the permissions
+ getContext().enforceCallingOrSelfPermission("android.permission.WRITE_APN_SETTINGS",
+ "No permission to write APN settings");
+ }
+
+ private SQLiteOpenHelper mOpenHelper;
+
+ private void restoreDefaultAPN() {
+ SQLiteDatabase db = mOpenHelper.getWritableDatabase();
+
+ db.delete(CARRIERS_TABLE, null, null);
+ ((DatabaseHelper) mOpenHelper).initDatabase(db);
+ }
+}
