mozilla
/
gecko-dev
зеркало из https://github.com/mozilla/gecko-dev.git
1
0
Форкнуть 0
Код Задачи Пакеты Проекты Релизы Вики Активность
gecko-dev/dom/mobilemessage/gonk/MobileMessageDB.jsm

5207 строки
189 KiB
JavaScript
Исходник Ответственный История

Этот файл содержит неоднозначные символы Юникода!

Этот файл содержит неоднозначные символы Юникода, которые могут быть перепутаны с другими в текущей локали. Если это намеренно, можете спокойно проигнорировать это предупреждение. Используйте кнопку Экранировать, чтобы подсветить эти символы.

/* This Source Code Form is subject to the terms of the Mozilla Public
* License, v. 2.0. If a copy of the MPL was not distributed with this file,
* You can obtain one at http://mozilla.org/MPL/2.0/. */
/*
* This file is documented in JSDoc format. To generate the document:
*
* 1. Follow the instruction of JSDoc project to install it. See
* https://github.com/jsdoc3/jsdoc for details.
*
* 2. Since JSDoc does not recognize ES6 syntax and XPCOM components, you should
* enable the "commentsOnly" plugin in your conf.json to strip all code out
* before generating the document. You'll need to change source.includePattern
* as well to include "*.jsm" since it's not included by default. Here's a
* minimal example of conf.json you need:
*
* {
* "source": {
* "includePattern": ".+\\.js(m)?$"
* },
* "plugins": ["plugins/commentsOnly"]
* }
*
* 3. Run jsdoc:
*
* $ jsdoc -c <path-to-conf-json> -d <output-directory> MobileMessageDB.jsm
*/
"use strict";
const {classes: Cc, interfaces: Ci, utils: Cu, results: Cr} = Components;
Cu.import("resource://gre/modules/XPCOMUtils.jsm");
Cu.import("resource://gre/modules/Services.jsm");
Cu.import("resource://gre/modules/PhoneNumberUtils.jsm");
Cu.importGlobalProperties(["indexedDB"]);
XPCOMUtils.defineLazyGetter(this, "RIL", function () {
let obj = {};
Cu.import("resource://gre/modules/ril_consts.js", obj);
return obj;
});
const RIL_GETMESSAGESCURSOR_CID =
Components.ID("{484d1ad8-840e-4782-9dc4-9ebc4d914937}");
const RIL_GETTHREADSCURSOR_CID =
Components.ID("{95ee7c3e-d6f2-4ec4-ade5-0c453c036d35}");
const DEBUG = false;
const DISABLE_MMS_GROUPING_FOR_RECEIVING = true;
const DB_VERSION = 23;
/**
* @typedef {string} MobileMessageDB.MESSAGE_STORE_NAME
*
* The name of the object store for messages.
*/
const MESSAGE_STORE_NAME = "sms";
/**
* @typedef {string} MobileMessageDB.THREAD_STORE_NAME
*
* The name of the object store for threads.
*/
const THREAD_STORE_NAME = "thread";
/**
* @typedef {string} MobileMessageDB.PARTICIPANT_STORE_NAME
*
* The name of the object store for participants.
*/
const PARTICIPANT_STORE_NAME = "participant";
/**
* @typedef {string} MobileMessageDB.MOST_RECENT_STORE_NAME
* @deprecated
*/
const MOST_RECENT_STORE_NAME = "most-recent";
/**
* @typedef {string} MobileMessageDB.SMS_SEGMENT_STORE_NAME
*
* The name of the object store for incoming SMS segments.
*/
const SMS_SEGMENT_STORE_NAME = "sms-segment";
const DELIVERY_SENDING = "sending";
const DELIVERY_SENT = "sent";
const DELIVERY_RECEIVED = "received";
const DELIVERY_NOT_DOWNLOADED = "not-downloaded";
const DELIVERY_ERROR = "error";
const DELIVERY_STATUS_NOT_APPLICABLE = "not-applicable";
const DELIVERY_STATUS_SUCCESS = "success";
const DELIVERY_STATUS_PENDING = "pending";
const DELIVERY_STATUS_ERROR = "error";
const MESSAGE_CLASS_NORMAL = "normal";
const FILTER_TIMESTAMP = "timestamp";
const FILTER_NUMBERS = "numbers";
const FILTER_DELIVERY = "delivery";
const FILTER_READ = "read";
// We can´t create an IDBKeyCursor with a boolean, so we need to use numbers
// instead.
const FILTER_READ_UNREAD = 0;
const FILTER_READ_READ = 1;
const READ_ONLY = "readonly";
const READ_WRITE = "readwrite";
const PREV = "prev";
const NEXT = "next";
const COLLECT_ID_END = 0;
const COLLECT_ID_ERROR = -1;
const COLLECT_TIMESTAMP_UNUSED = 0;
// Default value for integer preference "dom.sms.maxReadAheadEntries".
const DEFAULT_READ_AHEAD_ENTRIES = 7;
XPCOMUtils.defineLazyServiceGetter(this, "gMobileMessageService",
"@mozilla.org/mobilemessage/mobilemessageservice;1",
"nsIMobileMessageService");
XPCOMUtils.defineLazyServiceGetter(this, "gMMSService",
"@mozilla.org/mms/gonkmmsservice;1",
"nsIMmsService");
XPCOMUtils.defineLazyGetter(this, "MMS", function() {
let MMS = {};
Cu.import("resource://gre/modules/MmsPduHelper.jsm", MMS);
return MMS;
});
/**
* @typedef {Object} MobileMessageDB.MessageRecord
*
* Represents a SMS or MMS message.
*
* <pre>
* +--------------------------------------------------------------------------+
* | MessageRecord |
* +--------------------------------------------------------------------------+
* | id: Number (primary-key) |
* | |
* | [SMS / MMS Common] |
* | type: String |
* | read: Number // Works as boolean, only use 0 or 1. |
* | iccId: String |
* | sender: String |
* | delivery: String |
* | timestamp: Number |
* | sentTimestamp: Number |
* | |
* | [Database Foreign Keys] |
* | threadId: Number |
* | |
* | [Common Indices] |
* | threadIdIndex: Array // [threadId, timestamp] |
* | deliveryIndex: Array // [delivery, timestamp] |
* | readIndex: Array // [read, timpstamp] |
* | participantIdsIndex: Array of Array // [[participantId, timestamp], ...] |
* | |
* | [SMS / Common Fields] |
* | pid: Number |
* | SMSC: String |
* | receiver: String |
* | encoding: Number |
* | messageType: Number |
* | teleservice: Number |
* | messageClass: String |
* | deliveryStatus: String |
* | deliveryTimestamp: Number |
* | |
* | [SMS / Application Port Info] |
* | originatorPort: Number |
* | destinationPort: Number |
* | |
* | [SMS / MWI status] |
* | mwiPresent: Boolean |
* | mwiDiscard: Boolean |
* | mwiMsgCount: Number |
* | mwiActive: Boolean |
* | |
* | [SMS / Message Body] |
* | data: Array of Uint8 (available if it's 8bit encoding) |
* | body: String (normal text body) |
* | fullBody: String |
* | |
* | [SMS / CDMA Cellbroadcast Related] |
* | serviceCategory: Number |
* | language: String |
* | |
* | [MMS Info] |
* | receivers: Array of String |
* | phoneNumber: String |
* | transactionIdIndex: String |
* | envelopeIdIndex: String |
* | isReadReportSent: Boolean |
* | deliveryInfo: Array of { |
* | receiver: String |
* | deliveryStatus: String |
* | deliveryTimestamp: Number |
* | readStatus: String |
* | readTimestamp: Number |
* | } |
* | headers: { |
* | x-mms-message-type: Number |
* | x-mms-transaction-id: String |
* | x-mms-mms-version: Number |
* | from: { |
* | address: String |
* | type: String |
* | } |
* | subject: String |
* | x-mms-message-class: String |
* | x-mms-message-size: Number |
* | x-mms-expiry: Number |
* | x-mms-content-location: { |
* | uri: String |
* | } |
* | to: Array of { |
* | address: String |
* | type: String |
* | } |
* | x-mms-read-report: Boolean |
* | x-mms-priority: Number |
* | message-id: String |
* | date: String |
* | x-mms-delivery-report: Boolean |
* | content-type: { |
* | media: String |
* | params: { |
* | type: String |
* | start: String |
* | } |
* | } |
* | } |
* | parts: Array of { |
* | index: Number |
* | headers: { |
* | content-type: { |
* | media: String |
* | params: { |
* | name: String |
* | charset: { |
* | charset: String |
* | } |
* | } |
* | content-length: Number |
* | content-location: String |
* | content-id: String |
* | } |
* | content: String |
* | } |
* +--------------------------------------------------------------------------+
* </pre>
*/
/**
* @typedef {Object} MobileMessageDB.ThreadRecord
*
* Represents a message thread.
*
* <pre>
* +---------------------------------------+
* | ThreadRecord |
* +---------------------------------------+
* | id: Number (primary-key) |
* | participantIds: Array of Number |
* | participantAddresses: Array of String |
* | lastMessageId: Number |
* | lastTimestamp: Number |
* | unreadCount: Number |
* | lastMessageType: String |
* | |
* | [SMS Only] |
* | body: String |
* | |
* | [MMS Only] |
* | lastMessageSubject: String |
* +---------------------------------------+
* </pre>
*/
/**
* @typedef {Object} MobileMessageDB.ParticipantRecord
*
* Represents the mapping of a participant and one or multiple addresses.
* (National and Int'l numbers)
*
* <pre>
* +----------------------------+
* | ParticipantRecord |
* +----------------------------+
* | id: Number (primary-key) |
* | addresses: Array of String |
* +----------------------------+
* </pre>
*/
/**
* @typedef {Object} MobileMessageDB.SmsSegmentRecord
*
* Represents a SMS segment.
*
* <pre>
* +---------------------------------------------------------------+
* | SmsSegmentRecord |
* +---------------------------------------------------------------+
* | [Common Fields in SMS segment] |
* | messageType: Number |
* | teleservice: Number |
* | SMSC: String |
* | sentTimestamp: Number |
* | timestamp: Number |
* | sender: String |
* | pid: Number |
* | encoding: Number |
* | messageClass: String |
* | iccId: String |
* | |
* | [Concatenation Info] |
* | segmentRef: Number |
* | segmentSeq: Number |
* | segmentMaxSeq: Number |
* | |
* | [Application Port Info] |
* | originatorPort: Number |
* | destinationPort: Number |
* | |
* | [MWI Status] |
* | mwiPresent: Boolean |
* | mwiDiscard: Boolean |
* | mwiMsgCount: Number |
* | mwiActive: Boolean |
* | |
* | [CDMA Cell Broadcast Related Fields] |
* | serviceCategory: Number |
* | language: String |
* | |
* | [Message Body] |
* | data: Array of Uint8 (available if it's 8bit encoding) |
* | body: String (normal text body) |
* | |
* | [Handy Fields Created by DB for Concatenation] |
* | id: Number (primary-key) |
* | hash: String // Use to identify the segments to the same SMS. |
* | receivedSegments: Number |
* | segments: Array |
* +---------------------------------------------------------------+
* </pre>
*/
/**
* @class MobileMessageDB
* @classdesc
*
* <p>
* MobileMessageDB is used to store all SMS / MMS messages, as well as the
* threads those messages belong to, and the participants of those messages.
* </p>
*
* <p>
* The relations between threads, messages and participants can be described as
* the following ERD -- each thread consists of one or many messages, and
* consists of one or many participants. A participant resolves to one or many
* (usually up to 2) addresses -- which represent different formats of the same
* address, for example a national number and an international number.
* </p>
*
* <pre>
* X
* / \
* +-----------+ / \ +-----------+
* | | / \ /| |
* | thread |-|--|consist|--|--|participant|
* | | \ of / \| |
* +-----------+ \ / +-----------+
* | \ / |
* - V -
* | |
* | |
* X X
* / \ / \
* / \ / \
* / \ / \
* |consist| |resolve|
* \ of / \ to /
* \ / \ /
* \ / \ /
* V V
* | |
* | |
* - -
* | |
* /|\ /|\
* +-----------+ +-----------+
* | | | |
* | message | | address |
* | | | |
* +-----------+ +-----------+
* </pre>
*
* <p>
* There are 4 object stores in use: </br>
* 1. MESSAGE_STORE: stores {@link MobileMessageDB.MessageRecord}. </br>
* 2. THREAD_STORE: stores {@link MobileMessageDB.ThreadRecord}. </br>
* 3. PARTICIPANT_STORE: stores {@link MobileMessageDB.ParticipantRecord}. </br>
* 4. SMS_SEGMENT_STORE: stores partial incoming SMS segments defined in
* {@link MobileMessageDB.SmsSegmentRecord}. The records are deleted as soon as
* it's enough to compose a complete SMS message.
* </p>
*
* <p>
* Besides all object stores mentioned above, there was a MOST_RECENT_STORE
* which is deprecated and no longer in use.
* </p>
*/
this.MobileMessageDB = function() {};
MobileMessageDB.prototype = {
dbName: null,
dbVersion: null,
/**
* Cache the DB instance.
*
* @member {IDBDatabase} MobileMessageDB.db
* @private
*/
db: null,
/**
* Last sms/mms object store key value in the database.
*
* @member {number} MobileMessageDB.lastMessageId
* @private
*/
lastMessageId: 0,
/**
* @callback MobileMessageDB.EnsureDBCallback
* @param {number} aErrorCode
* The error code on failure, or <code>null</code> on success.
* @param {IDBDatabase} aDatabase
* The ready-to-use database object on success.
*/
/**
* Prepare the database. This may include opening the database and upgrading
* it to the latest schema version.
*
* @function MobileMessageDB.ensureDB
* @param {MobileMessageDB.EnsureDBCallback} callback
* Function that takes an error and db argument. It is called when
* the database is ready to use or if an error occurs while preparing
* the database.
*/
ensureDB: function(callback) {
if (this.db) {
if (DEBUG) debug("ensureDB: already have a database, returning early.");
callback(null, this.db);
return;
}
let self = this;
function gotDB(db) {
self.db = db;
callback(null, db);
}
let request = indexedDB.open(this.dbName, this.dbVersion);
request.onsuccess = function(event) {
if (DEBUG) debug("Opened database:", self.dbName, self.dbVersion);
gotDB(event.target.result);
};
request.onupgradeneeded = function(event) {
if (DEBUG) {
debug("Database needs upgrade:", self.dbName,
event.oldVersion, event.newVersion);
debug("Correct new database version:", event.newVersion == self.dbVersion);
}
let db = event.target.result;
let currentVersion = event.oldVersion;
function update(currentVersion) {
if (currentVersion >= self.dbVersion) {
if (DEBUG) debug("Upgrade finished.");
return;
}
let next = update.bind(self, currentVersion + 1);
switch (currentVersion) {
case 0:
if (DEBUG) debug("New database");
self.createSchema(db, next);
break;
case 1:
if (DEBUG) debug("Upgrade to version 2. Including `read` index");
self.upgradeSchema(event.target.transaction, next);
break;
case 2:
if (DEBUG) debug("Upgrade to version 3. Fix existing entries.");
self.upgradeSchema2(event.target.transaction, next);
break;
case 3:
if (DEBUG) debug("Upgrade to version 4. Add quick threads view.");
self.upgradeSchema3(db, event.target.transaction, next);
break;
case 4:
if (DEBUG) debug("Upgrade to version 5. Populate quick threads view.");
self.upgradeSchema4(event.target.transaction, next);
break;
case 5:
if (DEBUG) debug("Upgrade to version 6. Use PhonenumberJS.");
self.upgradeSchema5(event.target.transaction, next);
break;
case 6:
if (DEBUG) debug("Upgrade to version 7. Use multiple entry indexes.");
self.upgradeSchema6(event.target.transaction, next);
break;
case 7:
if (DEBUG) debug("Upgrade to version 8. Add participant/thread stores.");
self.upgradeSchema7(db, event.target.transaction, next);
break;
case 8:
if (DEBUG) debug("Upgrade to version 9. Add transactionId index for incoming MMS.");
self.upgradeSchema8(event.target.transaction, next);
break;
case 9:
if (DEBUG) debug("Upgrade to version 10. Upgrade type if it's not existing.");
self.upgradeSchema9(event.target.transaction, next);
break;
case 10:
if (DEBUG) debug("Upgrade to version 11. Add last message type into threadRecord.");
self.upgradeSchema10(event.target.transaction, next);
break;
case 11:
if (DEBUG) debug("Upgrade to version 12. Add envelopeId index for outgoing MMS.");
self.upgradeSchema11(event.target.transaction, next);
break;
case 12:
if (DEBUG) debug("Upgrade to version 13. Replaced deliveryStatus by deliveryInfo.");
self.upgradeSchema12(event.target.transaction, next);
break;
case 13:
if (DEBUG) debug("Upgrade to version 14. Fix the wrong participants.");
// A workaround to check if we need to re-upgrade the DB schema 12. We missed this
// because we didn't properly uplift that logic to b2g_v1.2 and errors could happen
// when migrating b2g_v1.2 to b2g_v1.3. Please see Bug 960741 for details.
self.needReUpgradeSchema12(event.target.transaction, function(isNeeded) {
if (isNeeded) {
self.upgradeSchema12(event.target.transaction, function() {
self.upgradeSchema13(event.target.transaction, next);
});
} else {
self.upgradeSchema13(event.target.transaction, next);
}
});
break;
case 14:
if (DEBUG) debug("Upgrade to version 15. Add deliveryTimestamp.");
self.upgradeSchema14(event.target.transaction, next);
break;
case 15:
if (DEBUG) debug("Upgrade to version 16. Add ICC ID for each message.");
self.upgradeSchema15(event.target.transaction, next);
break;
case 16:
if (DEBUG) debug("Upgrade to version 17. Add isReadReportSent for incoming MMS.");
self.upgradeSchema16(event.target.transaction, next);
break;
case 17:
if (DEBUG) debug("Upgrade to version 18. Add last message subject into threadRecord.");
self.upgradeSchema17(event.target.transaction, next);
break;
case 18:
if (DEBUG) debug("Upgrade to version 19. Add pid for incoming SMS.");
self.upgradeSchema18(event.target.transaction, next);
break;
case 19:
if (DEBUG) debug("Upgrade to version 20. Add readStatus and readTimestamp.");
self.upgradeSchema19(event.target.transaction, next);
break;
case 20:
if (DEBUG) debug("Upgrade to version 21. Add sentTimestamp.");
self.upgradeSchema20(event.target.transaction, next);
break;
case 21:
if (DEBUG) debug("Upgrade to version 22. Add sms-segment store.");
self.upgradeSchema21(db, event.target.transaction, next);
break;
case 22:
if (DEBUG) debug("Upgrade to version 23. Add type information to receivers and to");
self.upgradeSchema22(event.target.transaction, next);
break;
default:
event.target.transaction.abort();
if (DEBUG) debug("unexpected db version: " + event.oldVersion);
callback(Cr.NS_ERROR_FAILURE, null);
break;
}
}
update(currentVersion);
};
request.onerror = function(event) {
// TODO look at event.target.Code and change error constant accordingly.
if (DEBUG) debug("Error opening database!");
callback(Cr.NS_ERROR_FAILURE, null);
};
request.onblocked = function(event) {
if (DEBUG) debug("Opening database request is blocked.");
callback(Cr.NS_ERROR_FAILURE, null);
};
},
/**
* @callback MobileMessageDB.NewTxnCallback
* @param {number} aErrorCode
* The error code on failure, or <code>null</code> on success.
* @param {IDBTransaction} aTransaction
* The transaction object to operate the indexedDB on success.
* @param {IDBObjectStore|IDBObjectStore[]} aObjectStores
* The object store(s) on success. If only one object store is passed,
* it's passed as an <code>IDBObjectStore</code>; Otherwise, it's
* <code>IDBObjectStore[]</code>.
*/
/**
* Start a new transaction.
*
* @function MobileMessageDB.newTxn
* @param {string} txn_type
* Type of transaction (e.g. READ_WRITE)
* @param {MobileMessageDB.NewTxnCallback} callback
* Function to call when the transaction is available. It will
* be invoked with the transaction and opened object stores.
* @param {string[]} [storeNames=[{@link MobileMessageDB.MESSAGE_STORE_NAME}]]
* Names of the stores to open.
*/
newTxn: function(txn_type, callback, storeNames) {
if (!storeNames) {
storeNames = [MESSAGE_STORE_NAME];
}
if (DEBUG) debug("Opening transaction for object stores: " + storeNames);
let self = this;
this.ensureDB(function(error, db) {
if (error) {
if (DEBUG) debug("Could not open database: " + error);
callback(error);
return;
}
let txn = db.transaction(storeNames, txn_type);
if (DEBUG) debug("Started transaction " + txn + " of type " + txn_type);
if (DEBUG) {
txn.oncomplete = function(event) {
debug("Transaction " + txn + " completed.");
};
txn.onerror = function(event) {
// TODO check event.target.error.name and show an appropiate error
// message according to it.
debug("Error occurred during transaction: " + event.target.error.name);
};
}
let stores;
if (storeNames.length == 1) {
if (DEBUG) debug("Retrieving object store " + storeNames[0]);
stores = txn.objectStore(storeNames[0]);
} else {
stores = [];
for (let storeName of storeNames) {
if (DEBUG) debug("Retrieving object store " + storeName);
stores.push(txn.objectStore(storeName));
}
}
callback(null, txn, stores);
});
},
/**
* @callback MobileMessageDB.InitCallback
* @param {number} aErrorCode
* The error code on failure, or <code>null</code> on success.
*/
/**
* Initialize this MobileMessageDB.
*
* @function MobileMessageDB.init
* @param {string} aDbName
* A string name for that database.
* @param {number} aDbVersion
* The version that mmdb should upgrade to. 0 for the latest version.
* @param {MobileMessageDB.InitCallback} aCallback
* A function when either the initialization transaction is completed
* or any error occurs. Should take only one argument -- null when
* initialized with success or the error object otherwise.
*/
init: function(aDbName, aDbVersion, aCallback) {
this.dbName = aDbName;
this.dbVersion = aDbVersion || DB_VERSION;
let self = this;
this.newTxn(READ_ONLY, function(error, txn, messageStore){
if (error) {
if (aCallback) {
aCallback(error);
}
return;
}
if (aCallback) {
txn.oncomplete = function() {
aCallback(null);
};
}
// In order to get the highest key value, we open a key cursor in reverse
// order and get only the first pointed value.
let request = messageStore.openCursor(null, PREV);
request.onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
if (DEBUG) {
debug("Could not get the last key from mobile message database. " +
"Probably empty database");
}
return;
}
self.lastMessageId = cursor.key || 0;
if (DEBUG) debug("Last assigned message ID was " + self.lastMessageId);
};
request.onerror = function(event) {
if (DEBUG) {
debug("Could not get the last key from mobile message database " +
event.target.error.name);
}
};
});
},
/**
* Close the MobileMessageDB.
*
* @function MobileMessageDB.close
*/
close: function() {
if (!this.db) {
return;
}
this.db.close();
this.db = null;
this.lastMessageId = 0;
},
/**
* Sometimes user might reboot or remove battery while sending/receiving
* message. This function set the status of message records to error. The
* function can be used as the callback of {@link MobileMessageDB.init}.
*
* @function MobileMessageDB.updatePendingTransactionToError
* @param {number} aError
* The function does nothing if <code>aError</code> is not
* <code>null</code>.
*/
updatePendingTransactionToError: function(aError) {
if (aError) {
return;
}
this.newTxn(READ_WRITE, function(error, txn, messageStore) {
if (error) {
return;
}
let deliveryIndex = messageStore.index("delivery");
// Set all 'delivery: sending' records to 'delivery: error' and 'deliveryStatus:
// error'.
let keyRange = IDBKeyRange.bound([DELIVERY_SENDING, 0], [DELIVERY_SENDING, ""]);
let cursorRequestSending = deliveryIndex.openCursor(keyRange);
cursorRequestSending.onsuccess = function(event) {
let messageCursor = event.target.result;
if (!messageCursor) {
return;
}
let messageRecord = messageCursor.value;
// Set delivery to error.
messageRecord.delivery = DELIVERY_ERROR;
messageRecord.deliveryIndex = [DELIVERY_ERROR, messageRecord.timestamp];
if (messageRecord.type == "sms") {
messageRecord.deliveryStatus = DELIVERY_STATUS_ERROR;
} else {
// Set delivery status to error.
for (let i = 0; i < messageRecord.deliveryInfo.length; i++) {
messageRecord.deliveryInfo[i].deliveryStatus = DELIVERY_STATUS_ERROR;
}
}
messageCursor.update(messageRecord);
messageCursor.continue();
};
// Set all 'delivery: not-downloaded' and 'deliveryStatus: pending'
// records to 'delivery: not-downloaded' and 'deliveryStatus: error'.
keyRange = IDBKeyRange.bound([DELIVERY_NOT_DOWNLOADED, 0], [DELIVERY_NOT_DOWNLOADED, ""]);
let cursorRequestNotDownloaded = deliveryIndex.openCursor(keyRange);
cursorRequestNotDownloaded.onsuccess = function(event) {
let messageCursor = event.target.result;
if (!messageCursor) {
return;
}
let messageRecord = messageCursor.value;
// We have no "not-downloaded" SMS messages.
if (messageRecord.type == "sms") {
messageCursor.continue();
return;
}
// Set delivery status to error.
let deliveryInfo = messageRecord.deliveryInfo;
if (deliveryInfo.length == 1 &&
deliveryInfo[0].deliveryStatus == DELIVERY_STATUS_PENDING) {
deliveryInfo[0].deliveryStatus = DELIVERY_STATUS_ERROR;
}
messageCursor.update(messageRecord);
messageCursor.continue();
};
});
},
/**
* Create the initial database schema.
*
* TODO need to worry about number normalization somewhere...
* TODO full text search on body???
*/
createSchema: function(db, next) {
// This messageStore holds the main mobile message data.
let messageStore = db.createObjectStore(MESSAGE_STORE_NAME, { keyPath: "id" });
messageStore.createIndex("timestamp", "timestamp", { unique: false });
if (DEBUG) debug("Created object stores and indexes");
next();
},
/**
* Upgrade to the corresponding database schema version.
*/
upgradeSchema: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.createIndex("read", "read", { unique: false });
next();
},
upgradeSchema2: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
messageRecord.messageClass = MESSAGE_CLASS_NORMAL;
messageRecord.deliveryStatus = DELIVERY_STATUS_NOT_APPLICABLE;
cursor.update(messageRecord);
cursor.continue();
};
},
upgradeSchema3: function(db, transaction, next) {
// Delete redundant "id" index.
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
if (messageStore.indexNames.contains("id")) {
messageStore.deleteIndex("id");
}
/**
* This mostRecentStore can be used to quickly construct a thread view of
* the mobile message database. Each entry looks like this:
*
* { senderOrReceiver: <String> (primary key),
* id: <Number>,
* timestamp: <Date>,
* body: <String>,
* unreadCount: <Number> }
*
*/
let mostRecentStore = db.createObjectStore(MOST_RECENT_STORE_NAME,
{ keyPath: "senderOrReceiver" });
mostRecentStore.createIndex("timestamp", "timestamp");
next();
},
upgradeSchema4: function(transaction, next) {
let threads = {};
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
let mostRecentStore = transaction.objectStore(MOST_RECENT_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
for (let thread in threads) {
mostRecentStore.put(threads[thread]);
}
next();
return;
}
let messageRecord = cursor.value;
let contact = messageRecord.sender || messageRecord.receiver;
if (contact in threads) {
let thread = threads[contact];
if (!messageRecord.read) {
thread.unreadCount++;
}
if (messageRecord.timestamp > thread.timestamp) {
thread.id = messageRecord.id;
thread.body = messageRecord.body;
thread.timestamp = messageRecord.timestamp;
}
} else {
threads[contact] = {
senderOrReceiver: contact,
id: messageRecord.id,
timestamp: messageRecord.timestamp,
body: messageRecord.body,
unreadCount: messageRecord.read ? 0 : 1
};
}
cursor.continue();
};
},
upgradeSchema5: function(transaction, next) {
// Don't perform any upgrade. See Bug 819560.
next();
},
upgradeSchema6: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Delete "delivery" index.
if (messageStore.indexNames.contains("delivery")) {
messageStore.deleteIndex("delivery");
}
// Delete "sender" index.
if (messageStore.indexNames.contains("sender")) {
messageStore.deleteIndex("sender");
}
// Delete "receiver" index.
if (messageStore.indexNames.contains("receiver")) {
messageStore.deleteIndex("receiver");
}
// Delete "read" index.
if (messageStore.indexNames.contains("read")) {
messageStore.deleteIndex("read");
}
// Create new "delivery", "number" and "read" indexes.
messageStore.createIndex("delivery", "deliveryIndex");
messageStore.createIndex("number", "numberIndex", { multiEntry: true });
messageStore.createIndex("read", "readIndex");
// Populate new "deliverIndex", "numberIndex" and "readIndex" attributes.
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
let timestamp = messageRecord.timestamp;
messageRecord.deliveryIndex = [messageRecord.delivery, timestamp];
messageRecord.numberIndex = [
[messageRecord.sender, timestamp],
[messageRecord.receiver, timestamp]
];
messageRecord.readIndex = [messageRecord.read, timestamp];
cursor.update(messageRecord);
cursor.continue();
};
},
/**
* Add participant/thread stores.
*
* The message store now saves original phone numbers/addresses input from
* content to message records. No normalization is made.
*
* For filtering messages by phone numbers, it first looks up corresponding
* participant IDs from participant table and fetch message records with
* matching keys defined in per record "participantIds" field.
*
* For message threading, messages with the same participant ID array are put
* in the same thread. So updating "unreadCount", "lastMessageId" and
* "lastTimestamp" are through the "threadId" carried by per message record.
* Fetching threads list is now simply walking through the thread sotre. The
* "mostRecentStore" is dropped.
*/
upgradeSchema7: function(db, transaction, next) {
/**
* This "participant" object store keeps mappings of multiple phone numbers
* of the same recipient to an integer participant id. Each entry looks
* like:
*
* { id: <Number> (primary key),
* addresses: <Array of strings> }
*/
let participantStore = db.createObjectStore(PARTICIPANT_STORE_NAME,
{ keyPath: "id",
autoIncrement: true });
participantStore.createIndex("addresses", "addresses", { multiEntry: true });
/**
* This "threads" object store keeps mappings from an integer thread id to
* ids of the participants of that message thread. Each entry looks like:
*
* { id: <Number> (primary key),
* participantIds: <Array of participant IDs>,
* participantAddresses: <Array of the first addresses of the participants>,
* lastMessageId: <Number>,
* lastTimestamp: <Date>,
* subject: <String>,
* unreadCount: <Number> }
*
*/
let threadStore = db.createObjectStore(THREAD_STORE_NAME,
{ keyPath: "id",
autoIncrement: true });
threadStore.createIndex("participantIds", "participantIds");
threadStore.createIndex("lastTimestamp", "lastTimestamp");
/**
* Replace "numberIndex" with "participantIdsIndex" and create an additional
* "threadId". "numberIndex" will be removed later.
*/
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.createIndex("threadId", "threadIdIndex");
messageStore.createIndex("participantIds", "participantIdsIndex",
{ multiEntry: true });
// Now populate participantStore & threadStore.
let mostRecentStore = transaction.objectStore(MOST_RECENT_STORE_NAME);
let self = this;
let mostRecentRequest = mostRecentStore.openCursor();
mostRecentRequest.onsuccess = function(event) {
let mostRecentCursor = event.target.result;
if (!mostRecentCursor) {
db.deleteObjectStore(MOST_RECENT_STORE_NAME);
// No longer need the "number" index in messageStore, use
// "participantIds" index instead.
messageStore.deleteIndex("number");
next();
return;
}
let mostRecentRecord = mostRecentCursor.value;
// Each entry in mostRecentStore is supposed to be a unique thread, so we
// retrieve the records out and insert its "senderOrReceiver" column as a
// new record in participantStore.
let number = mostRecentRecord.senderOrReceiver;
self.findParticipantRecordByPlmnAddress(participantStore, number, true,
function(participantRecord) {
// Also create a new record in threadStore.
let threadRecord = {
participantIds: [participantRecord.id],
participantAddresses: [number],
lastMessageId: mostRecentRecord.id,
lastTimestamp: mostRecentRecord.timestamp,
subject: mostRecentRecord.body,
unreadCount: mostRecentRecord.unreadCount,
};
let addThreadRequest = threadStore.add(threadRecord);
addThreadRequest.onsuccess = function(event) {
threadRecord.id = event.target.result;
let numberRange = IDBKeyRange.bound([number, 0], [number, ""]);
let messageRequest = messageStore.index("number")
.openCursor(numberRange, NEXT);
messageRequest.onsuccess = function(event) {
let messageCursor = event.target.result;
if (!messageCursor) {
// No more message records, check next most recent record.
mostRecentCursor.continue();
return;
}
let messageRecord = messageCursor.value;
// Check whether the message really belongs to this thread.
let matchSenderOrReceiver = false;
if (messageRecord.delivery == DELIVERY_RECEIVED) {
if (messageRecord.sender == number) {
matchSenderOrReceiver = true;
}
} else if (messageRecord.receiver == number) {
matchSenderOrReceiver = true;
}
if (!matchSenderOrReceiver) {
// Check next message record.
messageCursor.continue();
return;
}
messageRecord.threadId = threadRecord.id;
messageRecord.threadIdIndex = [threadRecord.id,
messageRecord.timestamp];
messageRecord.participantIdsIndex = [
[participantRecord.id, messageRecord.timestamp]
];
messageCursor.update(messageRecord);
// Check next message record.
messageCursor.continue();
};
messageRequest.onerror = function() {
// Error in fetching message records, check next most recent record.
mostRecentCursor.continue();
};
};
addThreadRequest.onerror = function() {
// Error in fetching message records, check next most recent record.
mostRecentCursor.continue();
};
});
};
},
/**
* Add transactionId index for MMS.
*/
upgradeSchema8: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Delete "transactionId" index.
if (messageStore.indexNames.contains("transactionId")) {
messageStore.deleteIndex("transactionId");
}
// Create new "transactionId" indexes.
messageStore.createIndex("transactionId", "transactionIdIndex", { unique: true });
// Populate new "transactionIdIndex" attributes.
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if ("mms" == messageRecord.type &&
(DELIVERY_NOT_DOWNLOADED == messageRecord.delivery ||
DELIVERY_RECEIVED == messageRecord.delivery)) {
messageRecord.transactionIdIndex =
messageRecord.headers["x-mms-transaction-id"];
cursor.update(messageRecord);
}
cursor.continue();
};
},
upgradeSchema9: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Update type attributes.
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == undefined) {
messageRecord.type = "sms";
cursor.update(messageRecord);
}
cursor.continue();
};
},
upgradeSchema10: function(transaction, next) {
let threadStore = transaction.objectStore(THREAD_STORE_NAME);
// Add 'lastMessageType' to each thread record.
threadStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let threadRecord = cursor.value;
let lastMessageId = threadRecord.lastMessageId;
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
let request = messageStore.mozGetAll(lastMessageId);
request.onsuccess = function() {
let messageRecord = request.result[0];
if (!messageRecord) {
if (DEBUG) debug("Message ID " + lastMessageId + " not found");
return;
}
if (messageRecord.id != lastMessageId) {
if (DEBUG) {
debug("Requested message ID (" + lastMessageId + ") is different from" +
" the one we got");
}
return;
}
threadRecord.lastMessageType = messageRecord.type;
cursor.update(threadRecord);
cursor.continue();
};
request.onerror = function(event) {
if (DEBUG) {
if (event.target) {
debug("Caught error on transaction", event.target.error.name);
}
}
cursor.continue();
};
};
},
/**
* Add envelopeId index for MMS.
*/
upgradeSchema11: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Delete "envelopeId" index.
if (messageStore.indexNames.contains("envelopeId")) {
messageStore.deleteIndex("envelopeId");
}
// Create new "envelopeId" indexes.
messageStore.createIndex("envelopeId", "envelopeIdIndex", { unique: true });
// Populate new "envelopeIdIndex" attributes.
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "mms" &&
messageRecord.delivery == DELIVERY_SENT) {
messageRecord.envelopeIdIndex = messageRecord.headers["message-id"];
cursor.update(messageRecord);
}
cursor.continue();
};
},
/**
* Replace deliveryStatus by deliveryInfo.
*/
upgradeSchema12: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "mms") {
messageRecord.deliveryInfo = [];
if (messageRecord.deliveryStatus.length == 1 &&
(messageRecord.delivery == DELIVERY_NOT_DOWNLOADED ||
messageRecord.delivery == DELIVERY_RECEIVED)) {
messageRecord.deliveryInfo.push({
receiver: null,
deliveryStatus: messageRecord.deliveryStatus[0] });
} else {
for (let i = 0; i < messageRecord.deliveryStatus.length; i++) {
messageRecord.deliveryInfo.push({
receiver: messageRecord.receivers[i],
deliveryStatus: messageRecord.deliveryStatus[i] });
}
}
delete messageRecord.deliveryStatus;
cursor.update(messageRecord);
}
cursor.continue();
};
},
/**
* Check if we need to re-upgrade the DB schema 12.
*/
needReUpgradeSchema12: function(transaction, callback) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
callback(false);
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "mms" &&
messageRecord.deliveryInfo === undefined) {
callback(true);
return;
}
cursor.continue();
};
},
/**
* Fix the wrong participants.
*/
upgradeSchema13: function(transaction, next) {
let participantStore = transaction.objectStore(PARTICIPANT_STORE_NAME);
let threadStore = transaction.objectStore(THREAD_STORE_NAME);
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
let self = this;
let isInvalid = function(participantRecord) {
let entries = [];
for (let addr of participantRecord.addresses) {
entries.push({
normalized: addr,
parsed: PhoneNumberUtils.parseWithMCC(addr, null)
})
}
for (let ix = 0 ; ix < entries.length - 1; ix++) {
let entry1 = entries[ix];
for (let iy = ix + 1 ; iy < entries.length; iy ++) {
let entry2 = entries[iy];
if (!self.matchPhoneNumbers(entry1.normalized, entry1.parsed,
entry2.normalized, entry2.parsed)) {
return true;
}
}
}
return false;
};
let invalidParticipantIds = [];
participantStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (cursor) {
let participantRecord = cursor.value;
// Check if this participant record is valid
if (isInvalid(participantRecord)) {
invalidParticipantIds.push(participantRecord.id);
cursor.delete();
}
cursor.continue();
return;
}
// Participant store cursor iteration done.
if (!invalidParticipantIds.length) {
next();
return;
}
// Find affected thread.
let wrongThreads = [];
threadStore.openCursor().onsuccess = function(event) {
let threadCursor = event.target.result;
if (threadCursor) {
let threadRecord = threadCursor.value;
let participantIds = threadRecord.participantIds;
let foundInvalid = false;
for (let invalidParticipantId of invalidParticipantIds) {
if (participantIds.indexOf(invalidParticipantId) != -1) {
foundInvalid = true;
break;
}
}
if (foundInvalid) {
wrongThreads.push(threadRecord.id);
threadCursor.delete();
}
threadCursor.continue();
return;
}
if (!wrongThreads.length) {
next();
return;
}
// Use recursive function to avoid we add participant twice.
(function createUpdateThreadAndParticipant(ix) {
let threadId = wrongThreads[ix];
let range = IDBKeyRange.bound([threadId, 0], [threadId, ""]);
messageStore.index("threadId").openCursor(range).onsuccess = function(event) {
let messageCursor = event.target.result;
if (!messageCursor) {
ix++;
if (ix === wrongThreads.length) {
next();
return;
}
createUpdateThreadAndParticipant(ix);
return;
}
let messageRecord = messageCursor.value;
let timestamp = messageRecord.timestamp;
let threadParticipants = [];
// Recaculate the thread participants of received message.
if (messageRecord.delivery === DELIVERY_RECEIVED ||
messageRecord.delivery === DELIVERY_NOT_DOWNLOADED) {
threadParticipants.push(messageRecord.sender);
if (messageRecord.type == "mms") {
this.fillReceivedMmsThreadParticipants(messageRecord, threadParticipants);
}
}
// Recaculate the thread participants of sent messages and error
// messages. In error sms messages, we don't have error received sms.
// In received MMS, we don't update the error to deliver field but
// deliverStatus. So we only consider sent message in DELIVERY_ERROR.
else if (messageRecord.delivery === DELIVERY_SENT ||
messageRecord.delivery === DELIVERY_ERROR) {
if (messageRecord.type == "sms") {
threadParticipants = [messageRecord.receiver];
} else if (messageRecord.type == "mms") {
threadParticipants = messageRecord.receivers;
}
}
self.findThreadRecordByPlmnAddresses(threadStore, participantStore,
threadParticipants, true,
function(threadRecord,
participantIds) {
if (!participantIds) {
debug("participantIds is empty!");
return;
}
let timestamp = messageRecord.timestamp;
// Setup participantIdsIndex.
messageRecord.participantIdsIndex = [];
for (let id of participantIds) {
messageRecord.participantIdsIndex.push([id, timestamp]);
}
if (threadRecord) {
let needsUpdate = false;
if (threadRecord.lastTimestamp <= timestamp) {
threadRecord.lastTimestamp = timestamp;
threadRecord.subject = messageRecord.body;
threadRecord.lastMessageId = messageRecord.id;
threadRecord.lastMessageType = messageRecord.type;
needsUpdate = true;
}
if (!messageRecord.read) {
threadRecord.unreadCount++;
needsUpdate = true;
}
if (needsUpdate) {
threadStore.put(threadRecord);
}
messageRecord.threadId = threadRecord.id;
messageRecord.threadIdIndex = [threadRecord.id, timestamp];
messageCursor.update(messageRecord);
messageCursor.continue();
return;
}
threadRecord = {
participantIds: participantIds,
participantAddresses: threadParticipants,
lastMessageId: messageRecord.id,
lastTimestamp: timestamp,
subject: messageRecord.body,
unreadCount: messageRecord.read ? 0 : 1,
lastMessageType: messageRecord.type
};
threadStore.add(threadRecord).onsuccess = function(event) {
let threadId = event.target.result;
// Setup threadId & threadIdIndex.
messageRecord.threadId = threadId;
messageRecord.threadIdIndex = [threadId, timestamp];
messageCursor.update(messageRecord);
messageCursor.continue();
};
});
};
})(0);
};
};
},
/**
* Add deliveryTimestamp.
*/
upgradeSchema14: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "sms") {
messageRecord.deliveryTimestamp = 0;
} else if (messageRecord.type == "mms") {
let deliveryInfo = messageRecord.deliveryInfo;
for (let i = 0; i < deliveryInfo.length; i++) {
deliveryInfo[i].deliveryTimestamp = 0;
}
}
cursor.update(messageRecord);
cursor.continue();
};
},
/**
* Add ICC ID.
*/
upgradeSchema15: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
messageRecord.iccId = null;
cursor.update(messageRecord);
cursor.continue();
};
},
/**
* Add isReadReportSent for incoming MMS.
*/
upgradeSchema16: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Update type attributes.
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "mms") {
messageRecord.isReadReportSent = false;
cursor.update(messageRecord);
}
cursor.continue();
};
},
upgradeSchema17: function(transaction, next) {
let threadStore = transaction.objectStore(THREAD_STORE_NAME);
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
// Add 'lastMessageSubject' to each thread record.
threadStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let threadRecord = cursor.value;
// We have defined 'threadRecord.subject' in upgradeSchema7(), but it
// actually means 'threadRecord.body'. Swap the two values first.
threadRecord.body = threadRecord.subject;
delete threadRecord.subject;
// Only MMS supports subject so assign null for non-MMS one.
if (threadRecord.lastMessageType != "mms") {
threadRecord.lastMessageSubject = null;
cursor.update(threadRecord);
cursor.continue();
return;
}
messageStore.get(threadRecord.lastMessageId).onsuccess = function(event) {
let messageRecord = event.target.result;
let subject = messageRecord.headers.subject;
threadRecord.lastMessageSubject = subject || null;
cursor.update(threadRecord);
cursor.continue();
};
};
},
/**
* Add pid for incoming SMS.
*/
upgradeSchema18: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "sms") {
messageRecord.pid = RIL.PDU_PID_DEFAULT;
cursor.update(messageRecord);
}
cursor.continue();
};
},
/**
* Add readStatus and readTimestamp.
*/
upgradeSchema19: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
if (messageRecord.type == "sms") {
cursor.continue();
return;
}
// We can always retrieve transaction id from
// |messageRecord.headers["x-mms-transaction-id"]|.
if (messageRecord.hasOwnProperty("transactionId")) {
delete messageRecord.transactionId;
}
// xpconnect gives "undefined" for an unassigned argument of an interface
// method.
if (messageRecord.envelopeIdIndex === "undefined") {
delete messageRecord.envelopeIdIndex;
}
// Convert some header fields that were originally decoded as BooleanValue
// to numeric enums.
for (let field of ["x-mms-cancel-status",
"x-mms-sender-visibility",
"x-mms-read-status"]) {
let value = messageRecord.headers[field];
if (value !== undefined) {
messageRecord.headers[field] = value ? 128 : 129;
}
}
// For all sent and received MMS messages, we have to add their
// |readStatus| and |readTimestamp| attributes in |deliveryInfo| array.
let readReportRequested =
messageRecord.headers["x-mms-read-report"] || false;
for (let element of messageRecord.deliveryInfo) {
element.readStatus = readReportRequested
? MMS.DOM_READ_STATUS_PENDING
: MMS.DOM_READ_STATUS_NOT_APPLICABLE;
element.readTimestamp = 0;
}
cursor.update(messageRecord);
cursor.continue();
};
},
/**
* Add sentTimestamp.
*/
upgradeSchema20: function(transaction, next) {
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
messageStore.openCursor().onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
next();
return;
}
let messageRecord = cursor.value;
messageRecord.sentTimestamp = 0;
// We can still have changes to assign |sentTimestamp| for the existing
// MMS message records.
if (messageRecord.type == "mms" && messageRecord.headers["date"]) {
messageRecord.sentTimestamp = messageRecord.headers["date"].getTime();
}
cursor.update(messageRecord);
cursor.continue();
};
},
/**
* Add smsSegmentStore to store uncomplete SMS segments.
*/
upgradeSchema21: function(db, transaction, next) {
/**
* This smsSegmentStore is used to store uncomplete SMS segments.
* Each entry looks like this:
*
* {
* [Common fields in SMS segment]
* messageType: <Number>,
* teleservice: <Number>,
* SMSC: <String>,
* sentTimestamp: <Number>,
* timestamp: <Number>,
* sender: <String>,
* pid: <Number>,
* encoding: <Number>,
* messageClass: <String>,
* iccId: <String>,
*
* [Concatenation Info]
* segmentRef: <Number>,
* segmentSeq: <Number>,
* segmentMaxSeq: <Number>,
*
* [Application Port Info]
* originatorPort: <Number>,
* destinationPort: <Number>,
*
* [MWI status]
* mwiPresent: <Boolean>,
* mwiDiscard: <Boolean>,
* mwiMsgCount: <Number>,
* mwiActive: <Boolean>,
*
* [CDMA Cellbroadcast related fields]
* serviceCategory: <Number>,
* language: <String>,
*
* [Message Body]
* data: <Uint8Array>, (available if it's 8bit encoding)
* body: <String>, (normal text body)
*
* [Handy fields created by DB for concatenation]
* id: <Number>, keypath of this objectStore.
* hash: <String>, Use to identify the segments to the same SMS.
* receivedSegments: <Number>,
* segments: []
* }
*
*/
let smsSegmentStore = db.createObjectStore(SMS_SEGMENT_STORE_NAME,
{ keyPath: "id",
autoIncrement: true });
smsSegmentStore.createIndex("hash", "hash", { unique: true });
next();
},
/**
* Change receivers format to address and type.
*/
upgradeSchema22: function(transaction, next) {
// Since bug 871433 (DB_VERSION 11), we normalize addresses before really
// diving into participant store in findParticipantRecordByPlmnAddress.
// This also follows that all addresses stored in participant store are
// normalized phone numbers, although they might not be phone numbers at the
// first place. So addresses in participant store are not reliable.
//
// |participantAddresses| in a thread record are reliable, but several
// distinct threads can be wrongly mapped into one. For example, an IPv4
// address "55.252.255.54" was normalized as US phone number "5525225554".
// So beginning with thread store is not really a good idea.
//
// The only correct way is to begin with all messages records and check if
// the findThreadRecordByTypedAddresses() call using a message record's
// thread participants returns the same thread record with the one it
// currently belong to.
function getThreadParticipantsFromMessageRecord(aMessageRecord) {
let threadParticipants;
if (aMessageRecord.type == "sms") {
let address;
if (aMessageRecord.delivery == DELIVERY_RECEIVED) {
address = aMessageRecord.sender;
} else {
address = aMessageRecord.receiver;
}
threadParticipants = [{
address: address,
type: MMS.Address.resolveType(address)
}];
} else { // MMS
if ((aMessageRecord.delivery == DELIVERY_RECEIVED) ||
(aMessageRecord.delivery == DELIVERY_NOT_DOWNLOADED)) {
// DISABLE_MMS_GROUPING_FOR_RECEIVING is set to true at the time, so
// we consider only |aMessageRecord.sender|.
threadParticipants = [{
address: aMessageRecord.sender,
type: MMS.Address.resolveType(aMessageRecord.sender)
}];
} else {
threadParticipants = aMessageRecord.headers.to;
}
}
return threadParticipants;
}
let participantStore = transaction.objectStore(PARTICIPANT_STORE_NAME);
let threadStore = transaction.objectStore(THREAD_STORE_NAME);
let messageStore = transaction.objectStore(MESSAGE_STORE_NAME);
let invalidThreadIds = [];
let self = this;
let messageCursorReq = messageStore.openCursor();
messageCursorReq.onsuccess = function(aEvent) {
let messageCursor = aEvent.target.result;
if (messageCursor) {
let messageRecord = messageCursor.value;
let threadParticipants =
getThreadParticipantsFromMessageRecord(messageRecord);
// 1. If thread ID of this message record has been marked as invalid,
// skip further checks and go ahead for the next one.
if (invalidThreadIds.indexOf(messageRecord.threadId) >= 0) {
messageCursor.continue();
return;
}
// 2. Check if the thread record found with the new algorithm matches
// the original one.
self.findThreadRecordByTypedAddresses(threadStore, participantStore,
threadParticipants, true,
function(aThreadRecord,
aParticipantIds) {
if (!aThreadRecord || aThreadRecord.id !== messageRecord.threadId) {
invalidThreadIds.push(messageRecord.threadId);
}
messageCursor.continue();
});
// Only calls |messageCursor.continue()| inside the callback of
// findThreadRecordByTypedAddresses() because that may inserts new
// participant records and hurt concurrency.
return;
} // End of |if (messageCursor)|.
// 3. If there is no any mis-grouped message found, go on to next upgrade.
if (!invalidThreadIds.length) {
next();
return;
}
// 4. Remove invalid thread records first, so that we don't have
// unexpected match in findThreadRecordByTypedAddresses().
invalidThreadIds.forEach(function(aInvalidThreadId) {
threadStore.delete(aInvalidThreadId);
});
// 5. For each affected thread, re-create a valid thread record for it.
(function redoThreading(aInvalidThreadId) {
// 5-1. For each message record originally belongs to this thread, find
// a new home for it.
let range = IDBKeyRange.bound([aInvalidThreadId, 0],
[aInvalidThreadId, ""]);
let threadMessageCursorReq = messageStore.index("threadId")
.openCursor(range, NEXT);
threadMessageCursorReq.onsuccess = function(aEvent) {
let messageCursor = aEvent.target.result;
// 5-2. If no more message records to process in this invalid thread,
// go on to next invalid thread if available, or pass to next
// upgradeSchema function.
if (!messageCursor) {
if (invalidThreadIds.length) {
redoThreading(invalidThreadIds.shift());
} else {
next();
}
return;
}
let messageRecord = messageCursor.value;
let threadParticipants =
getThreadParticipantsFromMessageRecord(messageRecord);
// 5-3. Assign a thread record for this message record. Basically
// copied from |realSaveRecord|, but we don't have to worry
// about |updateThreadByMessageChange| because we've removed
// affected threads.
self.findThreadRecordByTypedAddresses(threadStore, participantStore,
threadParticipants, true,
function(aThreadRecord,
aParticipantIds) {
// Setup participantIdsIndex.
messageRecord.participantIdsIndex =
aParticipantIds.map(function(aParticipantId) {
return [aParticipantId, messageRecord.timestamp];
});
let threadExists = aThreadRecord ? true : false;
if (!threadExists) {
aThreadRecord = {
participantIds: aParticipantIds,
participantAddresses:
threadParticipants.map(function(aTypedAddress) {
return aTypedAddress.address;
}),
unreadCount: 0,
lastTimestamp: -1
};
}
let needsUpdate = false;
if (aThreadRecord.lastTimestamp <= messageRecord.timestamp) {
let lastMessageSubject;
if (messageRecord.type == "mms") {
lastMessageSubject = messageRecord.headers.subject;
}
aThreadRecord.lastMessageSubject = lastMessageSubject || null;
aThreadRecord.lastTimestamp = messageRecord.timestamp;
aThreadRecord.body = messageRecord.body;
aThreadRecord.lastMessageId = messageRecord.id;
aThreadRecord.lastMessageType = messageRecord.type;
needsUpdate = true;
}
if (!messageRecord.read) {
aThreadRecord.unreadCount++;
needsUpdate = true;
}
let updateMessageRecordThreadId = function(aThreadId) {
// Setup threadId & threadIdIndex.
messageRecord.threadId = aThreadId;
messageRecord.threadIdIndex = [aThreadId, messageRecord.timestamp];
messageCursor.update(messageRecord);
messageCursor.continue();
};
if (threadExists) {
if (needsUpdate) {
threadStore.put(aThreadRecord);
}
updateMessageRecordThreadId(aThreadRecord.id);
} else {
threadStore.add(aThreadRecord).onsuccess = function(aEvent) {
let threadId = aEvent.target.result;
updateMessageRecordThreadId(threadId);
};
}
}); // End of findThreadRecordByTypedAddresses().
}; // End of threadMessageCursorReq.onsuccess.
})(invalidThreadIds.shift()); // End of function redoThreading.
}; // End of messageStore.openCursor().onsuccess
},
/**
* Check if <code>addr1</code> matches <code>addr2</code>.
*
* @function MobileMessageDB.matchParsedPhoneNumbers
* @param {string} addr1
* Normalized address 1.
* @param {Object} parsedAddr1
* Parsed address 1.
* @param {string} addr2
* Normalized address 2.
* @param {Object} parsedAddr2
* Parsed address 2.
* @return {boolean}
* <code>true</code> if the 2 addresses match.
*/
matchParsedPhoneNumbers: function(addr1, parsedAddr1, addr2, parsedAddr2) {
if ((parsedAddr1.internationalNumber &&
parsedAddr1.internationalNumber === parsedAddr2.internationalNumber) ||
(parsedAddr1.nationalNumber &&
parsedAddr1.nationalNumber === parsedAddr2.nationalNumber)) {
return true;
}
if (parsedAddr1.countryName != parsedAddr2.countryName) {
return false;
}
let ssPref = "dom.phonenumber.substringmatching." + parsedAddr1.countryName;
if (Services.prefs.getPrefType(ssPref) != Ci.nsIPrefBranch.PREF_INT) {
return false;
}
let val = Services.prefs.getIntPref(ssPref);
return addr1.length > val &&
addr2.length > val &&
addr1.slice(-val) === addr2.slice(-val);
},
/**
* Check if <code>addr1</code> matches <code>addr2</code>.
*
* @function MobileMessageDB.matchPhoneNumbers
* @param {string} addr1
* Normalized address 1.
* @param {Object} parsedAddr1
* Parsed address 1. Try to parse from <code>addr1</code> if not given.
* @param {string} addr2
* Normalized address 2.
* @param {Object} parsedAddr2
* Parsed address 2. Try to parse from <code>addr2</code> if not given.
* @return {boolean}
* <code>true</code> if the 2 addresses match.
*/
matchPhoneNumbers: function(addr1, parsedAddr1, addr2, parsedAddr2) {
if (parsedAddr1 && parsedAddr2) {
return this.matchParsedPhoneNumbers(addr1, parsedAddr1, addr2, parsedAddr2);
}
if (parsedAddr1) {
parsedAddr2 = PhoneNumberUtils.parseWithCountryName(addr2, parsedAddr1.countryName);
if (parsedAddr2) {
return this.matchParsedPhoneNumbers(addr1, parsedAddr1, addr2, parsedAddr2);
}
return false;
}
if (parsedAddr2) {
parsedAddr1 = PhoneNumberUtils.parseWithCountryName(addr1, parsedAddr2.countryName);
if (parsedAddr1) {
return this.matchParsedPhoneNumbers(addr1, parsedAddr1, addr2, parsedAddr2);
}
}
return false;
},
/**
* Generate a <code>nsISmsMessage</code> or
* <code>nsIMmsMessage</code> instance from a stored message record.
*
* @function MobileMessageDB.createDomMessageFromRecord
* @param {MobileMessageDB.MessageRecord} aMessageRecord
* The stored message record.
* @return {nsISmsMessage|nsIMmsMessage}
*/
createDomMessageFromRecord: function(aMessageRecord) {
if (DEBUG) {
debug("createDomMessageFromRecord: " + JSON.stringify(aMessageRecord));
}
if (aMessageRecord.type == "sms") {
return gMobileMessageService.createSmsMessage(aMessageRecord.id,
aMessageRecord.threadId,
aMessageRecord.iccId,
aMessageRecord.delivery,
aMessageRecord.deliveryStatus,
aMessageRecord.sender,
aMessageRecord.receiver,
aMessageRecord.body,
aMessageRecord.messageClass,
aMessageRecord.timestamp,
aMessageRecord.sentTimestamp,
aMessageRecord.deliveryTimestamp,
aMessageRecord.read);
} else if (aMessageRecord.type == "mms") {
let headers = aMessageRecord["headers"];
if (DEBUG) {
debug("MMS: headers: " + JSON.stringify(headers));
}
let subject = headers["subject"];
if (subject == undefined) {
subject = "";
}
let smil = "";
let attachments = [];
let parts = aMessageRecord.parts;
if (parts) {
for (let i = 0; i < parts.length; i++) {
let part = parts[i];
if (DEBUG) {
debug("MMS: part[" + i + "]: " + JSON.stringify(part));
}
// Sometimes the part is incomplete because the device reboots when
// downloading MMS. Don't need to expose this part to the content.
if (!part) {
continue;
}
let partHeaders = part["headers"];
let partContent = part["content"];
// Don't need to make the SMIL part if it's present.
if (partHeaders["content-type"]["media"] == "application/smil") {
smil = partContent;
continue;
}
attachments.push({
"id": partHeaders["content-id"],
"location": partHeaders["content-location"],
"content": partContent
});
}
}
let expiryDate = 0;
if (headers["x-mms-expiry"] != undefined) {
expiryDate = aMessageRecord.timestamp + headers["x-mms-expiry"] * 1000;
}
let readReportRequested = headers["x-mms-read-report"] || false;
return gMobileMessageService.createMmsMessage(aMessageRecord.id,
aMessageRecord.threadId,
aMessageRecord.iccId,
aMessageRecord.delivery,
aMessageRecord.deliveryInfo,
aMessageRecord.sender,
aMessageRecord.receivers,
aMessageRecord.timestamp,
aMessageRecord.sentTimestamp,
aMessageRecord.read,
subject,
smil,
attachments,
expiryDate,
readReportRequested);
}
},
/**
* @callback MobileMessageDB.ParticipantRecordCallback
* @param {MobileMessageDB.ParticipantRecord} aParticipantRecord
* The stored participant record.
*/
/**
* Create a participant record with the given addresses, and add it into the
* participant object store immediately.
*
* @function MobileMessageDB.createParticipantRecord
* @param {IDBObjectStore} aParticipantStore
* Object store for participants.
* @param {string[]} aAddresses
* The addresses associated to the participant.
* @param {MobileMessageDB.ParticipantRecordCallback} aCallback
* The callback function to invoke when the request finishes.
*/
createParticipantRecord: function(aParticipantStore, aAddresses, aCallback) {
let participantRecord = { addresses: aAddresses };
let addRequest = aParticipantStore.add(participantRecord);
addRequest.onsuccess = function(event) {
participantRecord.id = event.target.result;
if (DEBUG) {
debug("createParticipantRecord: " + JSON.stringify(participantRecord));
}
aCallback(participantRecord);
};
},
/**
* Find or create the participant record associated to the given PLMN address.
*
* @function MobileMessageDB.findParticipantRecordByPlmnAddress
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {string} aAddress
* The PLMN address to look up with.
* @param {boolean} aCreate
* <code>true</code> to create a new participant record if not exists
* yet, otherwise return <code>null</code> to the callback if record
* not found.
* @param {MobileMessageDB.ParticipantRecordCallback} aCallback
* The callback function to invoke when the request finishes.
*/
findParticipantRecordByPlmnAddress: function(aParticipantStore, aAddress,
aCreate, aCallback) {
if (DEBUG) {
debug("findParticipantRecordByPlmnAddress("
+ JSON.stringify(aAddress) + ", " + aCreate + ")");
}
// Two types of input number to match here, international(+886987654321),
// and local(0987654321) types. The "nationalNumber" parsed from
// phonenumberutils will be "987654321" in this case.
// Normalize address before searching for participant record.
let normalizedAddress = PhoneNumberUtils.normalize(aAddress, false);
let allPossibleAddresses = [normalizedAddress];
let parsedAddress = PhoneNumberUtils.parse(normalizedAddress);
if (parsedAddress && parsedAddress.internationalNumber &&
allPossibleAddresses.indexOf(parsedAddress.internationalNumber) < 0) {
// We only stores international numbers into participant store because
// the parsed national number doesn't contain country info and may
// duplicate in different country.
allPossibleAddresses.push(parsedAddress.internationalNumber);
}
if (DEBUG) {
debug("findParticipantRecordByPlmnAddress: allPossibleAddresses = " +
JSON.stringify(allPossibleAddresses));
}
// Make a copy here because we may need allPossibleAddresses again.
let needles = allPossibleAddresses.slice(0);
let request = aParticipantStore.index("addresses").get(needles.pop());
request.onsuccess = (function onsuccess(event) {
let participantRecord = event.target.result;
// 1) First try matching through "addresses" index of participant store.
// If we're lucky, return the fetched participant record.
if (participantRecord) {
if (DEBUG) {
debug("findParticipantRecordByPlmnAddress: got "
+ JSON.stringify(participantRecord));
}
aCallback(participantRecord);
return;
}
// Try next possible address again.
if (needles.length) {
let request = aParticipantStore.index("addresses").get(needles.pop());
request.onsuccess = onsuccess.bind(this);
return;
}
// 2) Traverse throught all participants and check all alias addresses.
aParticipantStore.openCursor().onsuccess = (function(event) {
let cursor = event.target.result;
if (!cursor) {
// Have traversed whole object store but still in vain.
if (!aCreate) {
aCallback(null);
return;
}
this.createParticipantRecord(aParticipantStore, [normalizedAddress],
aCallback);
return;
}
let participantRecord = cursor.value;
for (let storedAddress of participantRecord.addresses) {
let parsedStoredAddress = PhoneNumberUtils.parseWithMCC(storedAddress, null);
let match = this.matchPhoneNumbers(normalizedAddress, parsedAddress,
storedAddress, parsedStoredAddress);
if (!match) {
// 3) Else we fail to match current stored participant record.
continue;
}
// Match!
if (aCreate) {
// In a READ-WRITE transaction, append one more possible address for
// this participant record.
participantRecord.addresses =
participantRecord.addresses.concat(allPossibleAddresses);
cursor.update(participantRecord);
}
if (DEBUG) {
debug("findParticipantRecordByPlmnAddress: match "
+ JSON.stringify(cursor.value));
}
aCallback(participantRecord);
return;
}
// Check next participant record if available.
cursor.continue();
}).bind(this);
}).bind(this);
},
/**
* Find or create the participant record associated to the given address other
* than PLMN address.
*
* @function MobileMessageDB.findParticipantRecordByOtherAddress
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {string} aAddress
* The address to look up with.
* @param {boolean} aCreate
* <code>true</code> to create a new participant record if not exists
* yet, otherwise return <code>null</code> to the callback if record
* not found.
* @param {MobileMessageDB.ParticipantRecordCallback} aCallback
* The callback function to invoke when the request finishes.
*/
findParticipantRecordByOtherAddress: function(aParticipantStore, aAddress,
aCreate, aCallback) {
if (DEBUG) {
debug("findParticipantRecordByOtherAddress(" +
JSON.stringify(aAddress) + ", " + aCreate + ")");
}
// Go full match.
let request = aParticipantStore.index("addresses").get(aAddress);
request.onsuccess = (function(event) {
let participantRecord = event.target.result;
if (participantRecord) {
if (DEBUG) {
debug("findParticipantRecordByOtherAddress: got "
+ JSON.stringify(participantRecord));
}
aCallback(participantRecord);
return;
}
if (aCreate) {
this.createParticipantRecord(aParticipantStore, [aAddress], aCallback);
return;
}
aCallback(null);
}).bind(this);
},
/**
* @typedef {Object} MobileMessageDB.TypedAddress
* @property {string} address Address
* @property {string} type Type of the address, such as "PLMN", "IPv4",
* "IPv6", "email" or "Others"
*/
/**
* Find or create the participant record associated to the given address.
*
* @function MobileMessageDB.findParticipantRecordByTypedAddress
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {MobileMessageDB.TypedAddress} aTypedAddress
* The address to look up with.
* @param {boolean} aCreate
* <code>true</code> to create a new participant record if not exists
* yet, otherwise return <code>null</code> to the callback if record
* not found.
* @param {MobileMessageDB.ParticipantRecordCallback} aCallback
* The callback function to invoke when the request finishes.
*/
findParticipantRecordByTypedAddress: function(aParticipantStore,
aTypedAddress, aCreate,
aCallback) {
if (aTypedAddress.type == "PLMN") {
this.findParticipantRecordByPlmnAddress(aParticipantStore,
aTypedAddress.address, aCreate,
aCallback);
} else {
this.findParticipantRecordByOtherAddress(aParticipantStore,
aTypedAddress.address, aCreate,
aCallback);
}
},
// For upgradeSchema13 usage.
findParticipantIdsByPlmnAddresses: function(aParticipantStore, aAddresses,
aCreate, aSkipNonexistent, aCallback) {
if (DEBUG) {
debug("findParticipantIdsByPlmnAddresses("
+ JSON.stringify(aAddresses) + ", "
+ aCreate + ", " + aSkipNonexistent + ")");
}
if (!aAddresses || !aAddresses.length) {
if (DEBUG) debug("findParticipantIdsByPlmnAddresses: returning null");
aCallback(null);
return;
}
let self = this;
(function findParticipantId(index, result) {
if (index >= aAddresses.length) {
// Sort numerically.
result.sort(function(a, b) {
return a - b;
});
if (DEBUG) debug("findParticipantIdsByPlmnAddresses: returning " + result);
aCallback(result);
return;
}
self.findParticipantRecordByPlmnAddress(aParticipantStore,
aAddresses[index++], aCreate,
function(participantRecord) {
if (!participantRecord) {
if (!aSkipNonexistent) {
if (DEBUG) debug("findParticipantIdsByPlmnAddresses: returning null");
aCallback(null);
return;
}
} else if (result.indexOf(participantRecord.id) < 0) {
result.push(participantRecord.id);
}
findParticipantId(index, result);
});
}) (0, []);
},
/**
* @callback MobileMessageDB.ParticipantIdsCallback
* @param {number[]} aParticipantIds
* An array of participant IDs. May be <code>null</code>.
*/
/**
* Find or create participant records associated to the given addresses, and
* return the IDs of the participant records to the caller through the
* callback.
*
* @function MobileMessageDB.findParticipantIdsByTypedAddresses
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {MobileMessageDB.TypedAddress[]} aTypedAddresses
* Addresses to look up with.
* @param {boolean} aCreate
* <code>true</code> to create a new participant record associates to
* the given addresses if not exists yet, otherwise return
* <code>null</code> to the callback if no record found.
* @param {boolean} aSkipNonexistent
* <code>true</code> to skip the addresses not exist in the participant
* store, otherwise return <code>null</code> to the callback when one
* or more addresses not found.
* @param {MobileMessageDB.ParticipantIdsCallback} aCallback
* The callback function to invoke when the request finishes.
*/
findParticipantIdsByTypedAddresses: function(aParticipantStore,
aTypedAddresses, aCreate,
aSkipNonexistent, aCallback) {
if (DEBUG) {
debug("findParticipantIdsByTypedAddresses(" +
JSON.stringify(aTypedAddresses) + ", " +
aCreate + ", " + aSkipNonexistent + ")");
}
if (!aTypedAddresses || !aTypedAddresses.length) {
if (DEBUG) debug("findParticipantIdsByTypedAddresses: returning null");
aCallback(null);
return;
}
let self = this;
(function findParticipantId(index, result) {
if (index >= aTypedAddresses.length) {
// Sort numerically.
result.sort(function(a, b) {
return a - b;
});
if (DEBUG) {
debug("findParticipantIdsByTypedAddresses: returning " + result);
}
aCallback(result);
return;
}
self.findParticipantRecordByTypedAddress(aParticipantStore,
aTypedAddresses[index++],
aCreate,
function(participantRecord) {
if (!participantRecord) {
if (!aSkipNonexistent) {
if (DEBUG) {
debug("findParticipantIdsByTypedAddresses: returning null");
}
aCallback(null);
return;
}
} else if (result.indexOf(participantRecord.id) < 0) {
result.push(participantRecord.id);
}
findParticipantId(index, result);
});
}) (0, []);
},
// For upgradeSchema13 usage.
findThreadRecordByPlmnAddresses: function(aThreadStore, aParticipantStore,
aAddresses, aCreateParticipants,
aCallback) {
if (DEBUG) {
debug("findThreadRecordByPlmnAddresses(" + JSON.stringify(aAddresses)
+ ", " + aCreateParticipants + ")");
}
this.findParticipantIdsByPlmnAddresses(aParticipantStore, aAddresses,
aCreateParticipants, false,
function(participantIds) {
if (!participantIds) {
if (DEBUG) debug("findThreadRecordByPlmnAddresses: returning null");
aCallback(null, null);
return;
}
// Find record from thread store.
let request = aThreadStore.index("participantIds").get(participantIds);
request.onsuccess = function(event) {
let threadRecord = event.target.result;
if (DEBUG) {
debug("findThreadRecordByPlmnAddresses: return "
+ JSON.stringify(threadRecord));
}
aCallback(threadRecord, participantIds);
};
});
},
/**
* @callback MobileMessageDB.ThreadRecordCallback
* @param {MobileMessageDB.ThreadRecord} aThreadRecord
* The stored thread record.
* @param {number[]} aParticipantIds
* IDs of participants of the thread.
*/
/**
* Find the thread record associated to the given address.
*
* @function MobileMessageDB.findThreadRecordByTypedAddresses
* @param {IDBObjectStore} aThreadStore
* The object store for threads.
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {MobileMessageDB.TypedAddress[]} aTypedAddresses
* Addresses to look up with.
* @param {boolean} aCreateParticipants
* <code>true</code> to create participant record associated to the
* addresses if not exist yet.
* @param {MobileMessageDB.ThreadRecordCallback} aCallback
* The callback function to invoke when the request finishes.
*/
findThreadRecordByTypedAddresses: function(aThreadStore, aParticipantStore,
aTypedAddresses,
aCreateParticipants, aCallback) {
if (DEBUG) {
debug("findThreadRecordByTypedAddresses(" +
JSON.stringify(aTypedAddresses) + ", " + aCreateParticipants + ")");
}
this.findParticipantIdsByTypedAddresses(aParticipantStore, aTypedAddresses,
aCreateParticipants, false,
function(participantIds) {
if (!participantIds) {
if (DEBUG) debug("findThreadRecordByTypedAddresses: returning null");
aCallback(null, null);
return;
}
// Find record from thread store.
let request = aThreadStore.index("participantIds").get(participantIds);
request.onsuccess = function(event) {
let threadRecord = event.target.result;
if (DEBUG) {
debug("findThreadRecordByTypedAddresses: return " +
JSON.stringify(threadRecord));
}
aCallback(threadRecord, participantIds);
};
});
},
/**
* @callback MobileMessageDB.TransactionResultCallback
* @param {number} aErrorCode
* The error code on failure, or <code>NS_OK</code> on success.
* @param {nsISmsMessage|nsIMmsMessage} aDomMessage
* The DOM message instance of the transaction result.
*/
/**
* @callback MobileMessageDB.NewTxnWithCallbackRequestCallback
* @param {Object} aCapture
* An output parameter. The <code>messageRecord</code> property will be
* set on transaction finishes.
* @param {MobileMessageDB.MessageRecord} aCapture.messageRecord
* The stored message record. The property presents if the transaction
* finished successfully.
* @param {IDBObjectStore|IDBObjectStore[]} aObjectStores
* The object store(s) on success. If only one object store is passed,
* it's passed as an <code>IDBObjectStore</code>; Otherwise, it's
* <code>IDBObjectStore[]</code>.
*/
/**
* Start a new transaction with default <code>oncomplete</code> /
* <code>onabort</code> implementation on the <code>IDBTransaction</code>
* object which redirects the error / result to <code>aCallback</code>.
*
* @function MobileMessageDB.newTxnWithCallback
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.TransactionResultCallback} aCallback.notify
* The callback function to invoke when the transaction finishes.
* @param {MobileMessageDB.NewTxnWithCallbackRequestCallback} aFunc
* The callback function to invoke when the request finishes.
* @param {string[]} [aStoreNames=[{@link MobileMessageDB.MESSAGE_STORE_NAME}]]
* Names of the stores to open.
*/
newTxnWithCallback: function(aCallback, aFunc, aStoreNames) {
let self = this;
this.newTxn(READ_WRITE, function(aError, aTransaction, aStores) {
let notifyResult = function(aRv, aMessageRecord) {
if (!aCallback) {
return;
}
let domMessage =
aMessageRecord && self.createDomMessageFromRecord(aMessageRecord);
aCallback.notify(aRv, domMessage);
};
if (aError) {
notifyResult(aError, null);
return;
}
let capture = {};
aTransaction.oncomplete = function(event) {
notifyResult(Cr.NS_OK, capture.messageRecord);
};
aTransaction.onabort = function(event) {
if (DEBUG) debug("transaction abort due to " + event.target.error.name);
let error = (event.target.error.name === 'QuotaExceededError')
? Cr.NS_ERROR_FILE_NO_DEVICE_SPACE
: Cr.NS_ERROR_FAILURE;
notifyResult(error, null);
};
aFunc(capture, aStores);
}, aStoreNames);
},
/**
* Save a message record.
*
* @function MobileMessageDB.saveRecord
* @param {MobileMessageDB.MessageRecord} aMessageRecord
* Message record to store.
* @param {MobileMessageDB.TypedAddress[]} aThreadParticipants
* Participants of the thread of the message.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.TransactionResultCallback} aCallback.notify
* The callback function to invoke when the transaction finishes.
*/
saveRecord: function(aMessageRecord, aThreadParticipants, aCallback) {
if (DEBUG) debug("Going to store " + JSON.stringify(aMessageRecord));
let self = this;
this.newTxn(READ_WRITE, function(error, txn, stores) {
let notifyResult = function(aRv, aMessageRecord) {
if (!aCallback) {
return;
}
let domMessage =
aMessageRecord && self.createDomMessageFromRecord(aMessageRecord);
aCallback.notify(aRv, domMessage);
};
if (error) {
notifyResult(error, null);
return;
}
let deletedInfo = { messageIds: [], threadIds: [] };
txn.oncomplete = function(event) {
if (aMessageRecord.id > self.lastMessageId) {
self.lastMessageId = aMessageRecord.id;
}
notifyResult(Cr.NS_OK, aMessageRecord);
self.notifyDeletedInfo(deletedInfo);
};
txn.onabort = function(event) {
if (DEBUG) debug("transaction abort due to " + event.target.error.name);
let error = (event.target.error.name === 'QuotaExceededError')
? Cr.NS_ERROR_FILE_NO_DEVICE_SPACE
: Cr.NS_ERROR_FAILURE;
notifyResult(error, null);
};
let messageStore = stores[0];
let participantStore = stores[1];
let threadStore = stores[2];
self.replaceShortMessageOnSave(txn, messageStore, participantStore,
threadStore, aMessageRecord,
aThreadParticipants, deletedInfo);
}, [MESSAGE_STORE_NAME, PARTICIPANT_STORE_NAME, THREAD_STORE_NAME]);
},
/**
* @typedef {Object} MobileMessageDB.DeletedInfo
* @property {number[]} messageIds
* IDs of deleted messages.
* @property {number[]} threadIds
* IDs of deleted threads, which indicates all messages within the
* threads have been deleted.
*/
/**
* According to <i>3GPP 23.040 - subclause 9.2.3.9 TP-Protocol-Identifier (TP-PID)</i>,
* if the Protocol Identifier contains a <i>Replace Short Message Type</i> or
* <i>Return Call Message</i> code, it should replace any existing stored
* message having the same Protocol Identifier code and originating address.
*
* This function checks the Protocol Identifier before saving the message
* record to fulfill the feature.
*
* @function MobileMessageDB.replaceShortMessageOnSave
* @param {IDBTransaction} aTransaction
* The transaction object.
* @param {IDBObjectStore} aMessageStore
* The object store for messages.
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {IDBObjectStore} aThreadStore
* The object store for threads.
* @param {MobileMessageDB.MessageRecord} aMessageRecord
* The message record to store.
* @param {MobileMessageDB.TypedAddress[]} aThreadParticipants
* Participants of the thread of the message.
* @param {MobileMessageDB.DeletedInfo} aDeletedInfo
* An out parameter indicating which messages have been deleted due to
* the replacement.
*/
replaceShortMessageOnSave: function(aTransaction, aMessageStore,
aParticipantStore, aThreadStore,
aMessageRecord, aThreadParticipants,
aDeletedInfo) {
let isReplaceTypePid = (aMessageRecord.pid) &&
((aMessageRecord.pid >= RIL.PDU_PID_REPLACE_SHORT_MESSAGE_TYPE_1 &&
aMessageRecord.pid <= RIL.PDU_PID_REPLACE_SHORT_MESSAGE_TYPE_7) ||
aMessageRecord.pid == RIL.PDU_PID_RETURN_CALL_MESSAGE);
if (aMessageRecord.type != "sms" ||
aMessageRecord.delivery != DELIVERY_RECEIVED ||
!isReplaceTypePid) {
this.realSaveRecord(aTransaction, aMessageStore, aParticipantStore,
aThreadStore, aMessageRecord, aThreadParticipants,
aDeletedInfo);
return;
}
// 3GPP TS 23.040 subclause 9.2.3.9 "TP-Protocol-Identifier (TP-PID)":
//
// ... the MS shall check the originating address and replace any
// existing stored message having the same Protocol Identifier code
// and originating address with the new short message and other
// parameter values. If there is no message to be replaced, the MS
// shall store the message in the normal way. ... it is recommended
// that the SC address should not be checked by the MS."
let self = this;
let typedSender = {
address: aMessageRecord.sender,
type: MMS.Address.resolveType(aMessageRecord.sender)
};
this.findParticipantRecordByTypedAddress(aParticipantStore, typedSender,
false,
function(participantRecord) {
if (!participantRecord) {
self.realSaveRecord(aTransaction, aMessageStore, aParticipantStore,
aThreadStore, aMessageRecord, aThreadParticipants,
aDeletedInfo);
return;
}
let participantId = participantRecord.id;
let range = IDBKeyRange.bound([participantId, 0], [participantId, ""]);
let request = aMessageStore.index("participantIds").openCursor(range);
request.onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
self.realSaveRecord(aTransaction, aMessageStore, aParticipantStore,
aThreadStore, aMessageRecord, aThreadParticipants,
aDeletedInfo);
return;
}
// A message record with same participantId found.
// Verify matching criteria.
let foundMessageRecord = cursor.value;
if (foundMessageRecord.type != "sms" ||
foundMessageRecord.sender != aMessageRecord.sender ||
foundMessageRecord.pid != aMessageRecord.pid) {
cursor.continue();
return;
}
// Match! Now replace that found message record with current one.
aMessageRecord.id = foundMessageRecord.id;
self.realSaveRecord(aTransaction, aMessageStore, aParticipantStore,
aThreadStore, aMessageRecord, aThreadParticipants,
aDeletedInfo);
};
});
},
/**
* The function where object store manipulations actually occur.
*
* @function MobileMessageDB.realSaveRecord
* @param {IDBTransaction} aTransaction
* The transaction object.
* @param {IDBObjectStore} aMessageStore
* The object store for messages.
* @param {IDBObjectStore} aParticipantStore
* The object store for participants.
* @param {IDBObjectStore} aThreadStore
* The object store for threads.
* @param {MobileMessageDB.MessageRecord} aMessageRecord
* The message record to store.
* @param {MobileMessageDB.TypedAddress[]} aThreadParticipants
* Participants of the thread of the message.
* @param {MobileMessageDB.DeletedInfo} aDeletedInfo
* An out parameter indicating which messages have been deleted due to
* the replacement.
*/
realSaveRecord: function(aTransaction, aMessageStore, aParticipantStore,
aThreadStore, aMessageRecord, aThreadParticipants,
aDeletedInfo) {
let self = this;
this.findThreadRecordByTypedAddresses(aThreadStore, aParticipantStore,
aThreadParticipants, true,
function(threadRecord,
participantIds) {
if (!participantIds) {
aTransaction.abort();
return;
}
let isOverriding = (aMessageRecord.id !== undefined);
if (!isOverriding) {
// |self.lastMessageId| is only updated in |txn.oncomplete|.
aMessageRecord.id = self.lastMessageId + 1;
}
let timestamp = aMessageRecord.timestamp;
let insertMessageRecord = function(threadId) {
// Setup threadId & threadIdIndex.
aMessageRecord.threadId = threadId;
aMessageRecord.threadIdIndex = [threadId, timestamp];
// Setup participantIdsIndex.
aMessageRecord.participantIdsIndex = [];
for (let id of participantIds) {
aMessageRecord.participantIdsIndex.push([id, timestamp]);
}
if (!isOverriding) {
// Really add to message store.
aMessageStore.put(aMessageRecord);
return;
}
// If we're going to override an old message, we need to update the
// info of the original thread containing the overridden message.
// To get the original thread ID and read status of the overridden
// message record, we need to retrieve it before overriding it.
aMessageStore.get(aMessageRecord.id).onsuccess = function(event) {
let oldMessageRecord = event.target.result;
aMessageStore.put(aMessageRecord);
if (oldMessageRecord) {
self.updateThreadByMessageChange(aMessageStore,
aThreadStore,
oldMessageRecord.threadId,
[aMessageRecord.id],
oldMessageRecord.read ? 0 : 1,
aDeletedInfo);
}
};
};
if (threadRecord) {
let needsUpdate = false;
if (threadRecord.lastTimestamp <= timestamp) {
let lastMessageSubject;
if (aMessageRecord.type == "mms") {
lastMessageSubject = aMessageRecord.headers.subject;
}
threadRecord.lastMessageSubject = lastMessageSubject || null;
threadRecord.lastTimestamp = timestamp;
threadRecord.body = aMessageRecord.body;
threadRecord.lastMessageId = aMessageRecord.id;
threadRecord.lastMessageType = aMessageRecord.type;
needsUpdate = true;
}
if (!aMessageRecord.read) {
threadRecord.unreadCount++;
needsUpdate = true;
}
if (needsUpdate) {
aThreadStore.put(threadRecord);
}
insertMessageRecord(threadRecord.id);
return;
}
let lastMessageSubject;
if (aMessageRecord.type == "mms") {
lastMessageSubject = aMessageRecord.headers.subject;
}
threadRecord = {
participantIds: participantIds,
participantAddresses: aThreadParticipants.map(function(typedAddress) {
return typedAddress.address;
}),
lastMessageId: aMessageRecord.id,
lastTimestamp: timestamp,
lastMessageSubject: lastMessageSubject || null,
body: aMessageRecord.body,
unreadCount: aMessageRecord.read ? 0 : 1,
lastMessageType: aMessageRecord.type,
};
aThreadStore.add(threadRecord).onsuccess = function(event) {
let threadId = event.target.result;
insertMessageRecord(threadId);
};
});
},
/**
* @typedef {Object} MobileMessageDB.MmsDeliveryInfoElement
* @property {string} receiver
* @property {string} deliveryStatus
* @property {number} deliveryTimestamp
* @property {string} readStatus
* @property {number} readTimestamp
*/
/**
* @callback MobileMessageDB.ForEachMatchedMmsDeliveryInfoCallback
* @param {MobileMessageDB.MmsDeliveryInfoElement} aElement
* An element of the MMS <code>deliverInfo</code> of a message record.
*/
/**
* Iterate all elements of <code>aDeliveryInfo</code>, check if the receiver
* address matches <code>aNeedle</code> and invoke <code>aCallback</code> on
* each matched element.
*
* @function MobileMessageDB.forEachMatchedMmsDeliveryInfo
* @param {MobileMessageDB.MmsDeliveryInfoElement[]} aDeliveryInfo
* The MMS <code>deliverInfo</code> of a message record.
* @param {string} aNeedle
* The receiver address to look up with.
* @param {MobileMessageDB.ForEachMatchedMmsDeliveryInfoCallback} aCallback
* The callback function to invoke on each match.
*/
forEachMatchedMmsDeliveryInfo: function(aDeliveryInfo, aNeedle, aCallback) {
let typedAddress = {
type: MMS.Address.resolveType(aNeedle),
address: aNeedle
};
let normalizedAddress, parsedAddress;
if (typedAddress.type === "PLMN") {
normalizedAddress = PhoneNumberUtils.normalize(aNeedle, false);
parsedAddress = PhoneNumberUtils.parse(normalizedAddress);
}
for (let element of aDeliveryInfo) {
let typedStoredAddress = {
type: MMS.Address.resolveType(element.receiver),
address: element.receiver
};
if (typedAddress.type !== typedStoredAddress.type) {
// Not even my type. Skip.
continue;
}
if (typedAddress.address == typedStoredAddress.address) {
// Have a direct match.
aCallback(element);
continue;
}
if (typedAddress.type !== "PLMN") {
// Address type other than "PLMN" must have direct match. Or, skip.
continue;
}
// Both are of "PLMN" type.
let normalizedStoredAddress =
PhoneNumberUtils.normalize(element.receiver, false);
let parsedStoredAddress =
PhoneNumberUtils.parseWithMCC(normalizedStoredAddress, null);
if (this.matchPhoneNumbers(normalizedAddress, parsedAddress,
normalizedStoredAddress, parsedStoredAddress)) {
aCallback(element);
}
}
},
/**
* Find the message of a given message ID or envelope ID. Update its
* <code>delivery</code>, <code>deliveryStatus</code>, and
* <code>envelopeId</code> accordingly.
*
* @function MobileMessageDB.updateMessageDeliveryById
* @param {string} id
* If <code>type</code> is "messageId", it represents the message ID;
* If <code>type</code> is "envelopeId", it represents the envelope ID,
* which is the "x-mms-transaction-id" in the header of an MMS message.
* @param {string} type
* Either "messageId" or "envelopeId".
* @param {string} receiver
* The receiver address.
* @param {string} delivery
* If given, it will be used to update the <code>deliveryIndex</code>
* property of a stored message record.
* @param {string} deliveryStatus
* If given, it will be used to update the <code>deliveryStatus</code>
* property of a stored message record.
* @param {string} envelopeId
* If given, it will be used to update the <code>envelopeIdIndex</code>
* property of a stored message record.
* @param {Object} callback
* The object passed as <code>aCallback</code> to
* {@link MobileMessageDB.newTxnWithCallback}.
*/
updateMessageDeliveryById: function(id, type, receiver, delivery,
deliveryStatus, envelopeId, callback) {
if (DEBUG) {
debug("Setting message's delivery by " + type + " = "+ id
+ " receiver: " + receiver
+ " delivery: " + delivery
+ " deliveryStatus: " + deliveryStatus
+ " envelopeId: " + envelopeId);
}
let self = this;
this.newTxnWithCallback(callback, function(aCapture, aMessageStore) {
let getRequest;
if (type === "messageId") {
getRequest = aMessageStore.get(id);
} else if (type === "envelopeId") {
getRequest = aMessageStore.index("envelopeId").get(id);
}
getRequest.onsuccess = function(event) {
let messageRecord = event.target.result;
if (!messageRecord) {
if (DEBUG) debug("type = " + id + " is not found");
throw Cr.NS_ERROR_FAILURE;
}
let isRecordUpdated = false;
// Update |messageRecord.delivery| if needed.
if (delivery && messageRecord.delivery != delivery) {
messageRecord.delivery = delivery;
messageRecord.deliveryIndex = [delivery, messageRecord.timestamp];
isRecordUpdated = true;
// When updating an message's delivey state to 'sent', we also update
// its |sentTimestamp| by the current device timestamp to represent
// when the message is successfully sent.
if (delivery == DELIVERY_SENT) {
messageRecord.sentTimestamp = Date.now();
}
}
// Attempt to update |deliveryStatus| and |deliveryTimestamp| of:
// - the |messageRecord| for SMS.
// - the element(s) in |messageRecord.deliveryInfo| for MMS.
if (deliveryStatus) {
// A callback for updating the deliveyStatus/deliveryTimestamp of
// each target.
let updateFunc = function(aTarget) {
if (aTarget.deliveryStatus == deliveryStatus) {
return;
}
aTarget.deliveryStatus = deliveryStatus;
// Update |deliveryTimestamp| if it's successfully delivered.
if (deliveryStatus == DELIVERY_STATUS_SUCCESS) {
aTarget.deliveryTimestamp = Date.now();
}
isRecordUpdated = true;
};
if (messageRecord.type == "sms") {
updateFunc(messageRecord);
} else if (messageRecord.type == "mms") {
if (!receiver) {
// If the receiver is specified, we only need to update the
// element(s) in deliveryInfo that match the same receiver.
messageRecord.deliveryInfo.forEach(updateFunc);
} else {
self.forEachMatchedMmsDeliveryInfo(messageRecord.deliveryInfo,
receiver, updateFunc);
}
}
}
// Update |messageRecord.envelopeIdIndex| if needed.
if (envelopeId) {
if (messageRecord.envelopeIdIndex != envelopeId) {
messageRecord.envelopeIdIndex = envelopeId;
isRecordUpdated = true;
}
}
aCapture.messageRecord = messageRecord;
if (!isRecordUpdated) {
if (DEBUG) {
debug("The values of delivery, deliveryStatus and envelopeId " +
"don't need to be updated.");
}
return;
}
if (DEBUG) {
debug("The delivery, deliveryStatus or envelopeId are updated.");
}
aMessageStore.put(messageRecord);
};
});
},
/**
* Map receivers of a MMS message record to the thread participant list if MMS
* grouping is enabled.
*
* @function MobileMessageDB.fillReceivedMmsThreadParticipants
* @param {MobileMessageDB.MessageRecord} aMessage
* The MMS message.
* @param {MobileMessageDB.TypedAddress[]} threadParticipants
* Participants to add.
*/
fillReceivedMmsThreadParticipants: function(aMessage, threadParticipants) {
let receivers = aMessage.receivers;
// If we don't want to disable the MMS grouping for receiving, we need to
// add the receivers (excluding the user's own number) to the participants
// for creating the thread. Some cases might be investigated as below:
//
// 1. receivers.length == 0
// This usually happens when receiving an MMS notification indication
// which doesn't carry any receivers.
// 2. receivers.length == 1
// If the receivers contain single phone number, we don't need to
// add it into participants because we know that number is our own.
// 3. receivers.length >= 2
// If the receivers contain multiple phone numbers, we need to add all
// of them but not the user's own number into participants.
if (DISABLE_MMS_GROUPING_FOR_RECEIVING || receivers.length < 2) {
return;
}
let isSuccess = false;
let slicedReceivers = receivers.slice();
if (aMessage.msisdn) {
let found = slicedReceivers.indexOf(aMessage.msisdn);
if (found !== -1) {
isSuccess = true;
slicedReceivers.splice(found, 1);
}
}
if (!isSuccess) {
// For some SIMs we cannot retrieve the valid MSISDN (i.e. the user's
// own phone number), so we cannot correctly exclude the user's own
// number from the receivers, thus wrongly building the thread index.
if (DEBUG) debug("Error! Cannot strip out user's own phone number!");
}
threadParticipants =
threadParticipants.concat(slicedReceivers).map(function(aAddress) {
return {
address: aAddress,
type: MMS.Address.resolveType(aAddress)
};
});
},
/**
* Update the thread when one or more messages are deleted / replaced.
*
* @function MobileMessageDB.updateThreadByMessageChange
* @param {IDBObjectStore} messageStore
* The object store for messages.
* @param {IDBObjectStore} threadStore
* The object store for threads.
* @param {number} threadId
* The thread ID.
* @param {number[]} removedMsgIds
* The IDs of removed messages.
* @param {number} ignoredUnreadCount
* Negative offset for <code>unreadCount</code>. For example, if the
* <code>unreadCount</code> was 5, given
* <code>ignoredUnreadCount</code> to 3 causes <code>unreadCount</code>
* becomes 2.
* @param {MobileMessageDB.DeletedInfo} deletedInfo
* An out parameter indicating if the thread is deleted after the
* operation.
*/
updateThreadByMessageChange: function(messageStore, threadStore, threadId,
removedMsgIds, ignoredUnreadCount, deletedInfo) {
let self = this;
threadStore.get(threadId).onsuccess = function(event) {
// This must exist.
let threadRecord = event.target.result;
if (DEBUG) debug("Updating thread record " + JSON.stringify(threadRecord));
if (ignoredUnreadCount > 0) {
if (DEBUG) {
debug("Updating unread count : " + threadRecord.unreadCount +
" -> " + (threadRecord.unreadCount - ignoredUnreadCount));
}
threadRecord.unreadCount -= ignoredUnreadCount;
}
if (removedMsgIds.indexOf(threadRecord.lastMessageId) >= 0) {
if (DEBUG) debug("MRU entry was deleted.");
// Check most recent sender/receiver.
let range = IDBKeyRange.bound([threadId, 0], [threadId, ""]);
let request = messageStore.index("threadId")
.openCursor(range, PREV);
request.onsuccess = function(event) {
let cursor = event.target.result;
if (!cursor) {
if (DEBUG) {
debug("All messages were deleted. Delete this thread.");
}
threadStore.delete(threadId);
if (deletedInfo) {
deletedInfo.threadIds.push(threadId);
}
return;
}
let nextMsg = cursor.value;
let lastMessageSubject;
if (nextMsg.type == "mms") {
lastMessageSubject = nextMsg.headers.subject;
}
threadRecord.lastMessageSubject = lastMessageSubject || null;
threadRecord.lastMessageId = nextMsg.id;
threadRecord.lastTimestamp = nextMsg.timestamp;
threadRecord.body = nextMsg.body;
threadRecord.lastMessageType = nextMsg.type;
if (DEBUG) {
debug("Updating mru entry: " +
JSON.stringify(threadRecord));
}
threadStore.put(threadRecord);
};
} else if (ignoredUnreadCount > 0) {
if (DEBUG) debug("Shortcut, just update the unread count.");
threadStore.put(threadRecord);
}
};
},
/**
* Notify the observers that one or more messages are deleted.
*
* @function MobileMessageDB.notifyDeletedInfo
* @param {MobileMessageDB.DeletedInfo} info
* The IDs of deleted messages and threads.
*/
notifyDeletedInfo: function(info) {
if (!info ||
(info.messageIds.length === 0 && info.threadIds.length === 0)) {
return;
}
let deletedInfo =
gMobileMessageService
.createDeletedMessageInfo(info.messageIds,
info.messageIds.length,
info.threadIds,
info.threadIds.length);
Services.obs.notifyObservers(deletedInfo, "sms-deleted", null);
},
/**
* nsIGonkMobileMessageDatabaseService API
*/
/**
* Store an incoming message.
*
* @function MobileMessageDB.saveReceivedMessage
* @param {MobileMessageDB.MessageRecord} aMessage
* The message record to store.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.TransactionResultCallback} aCallback.notify
* The callback function to invoke when the transaction finishes.
*/
saveReceivedMessage: function(aMessage, aCallback) {
if ((aMessage.type != "sms" && aMessage.type != "mms") ||
(aMessage.type == "sms" && (aMessage.messageClass == undefined ||
aMessage.sender == undefined)) ||
(aMessage.type == "mms" && (aMessage.delivery == undefined ||
aMessage.deliveryStatus == undefined ||
!Array.isArray(aMessage.receivers))) ||
aMessage.timestamp == undefined) {
if (aCallback) {
aCallback.notify(Cr.NS_ERROR_FAILURE, null);
}
return;
}
let threadParticipants;
if (aMessage.type == "mms") {
if (aMessage.headers.from) {
aMessage.sender = aMessage.headers.from.address;
} else {
aMessage.sender = "";
}
threadParticipants = [{
address: aMessage.sender,
type: MMS.Address.resolveType(aMessage.sender)
}];
this.fillReceivedMmsThreadParticipants(aMessage, threadParticipants);
} else { // SMS
threadParticipants = [{
address: aMessage.sender,
type: MMS.Address.resolveType(aMessage.sender)
}];
}
let timestamp = aMessage.timestamp;
// Adding needed indexes and extra attributes for internal use.
// threadIdIndex & participantIdsIndex are filled in saveRecord().
aMessage.readIndex = [FILTER_READ_UNREAD, timestamp];
aMessage.read = FILTER_READ_UNREAD;
// If |sentTimestamp| is not specified, use 0 as default.
if (aMessage.sentTimestamp == undefined) {
aMessage.sentTimestamp = 0;
}
if (aMessage.type == "mms") {
aMessage.transactionIdIndex = aMessage.headers["x-mms-transaction-id"];
aMessage.isReadReportSent = false;
// As a receiver, we don't need to care about the delivery status of
// others, so we put a single element with self's phone number in the
// |deliveryInfo| array.
aMessage.deliveryInfo = [{
receiver: aMessage.phoneNumber,
deliveryStatus: aMessage.deliveryStatus,
deliveryTimestamp: 0,
readStatus: MMS.DOM_READ_STATUS_NOT_APPLICABLE,
readTimestamp: 0,
}];
delete aMessage.deliveryStatus;
}
if (aMessage.type == "sms") {
aMessage.delivery = DELIVERY_RECEIVED;
aMessage.deliveryStatus = DELIVERY_STATUS_SUCCESS;
aMessage.deliveryTimestamp = 0;
if (aMessage.pid == undefined) {
aMessage.pid = RIL.PDU_PID_DEFAULT;
}
}
aMessage.deliveryIndex = [aMessage.delivery, timestamp];
this.saveRecord(aMessage, threadParticipants, aCallback);
},
/**
* Store an outgoing message.
*
* @function MobileMessageDB.saveSendingMessage
* @param {MobileMessageDB.MessageRecord} aMessage
* The message record to store.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.TransactionResultCallback} aCallback.notify
* The callback function to invoke when the transaction finishes.
*/
saveSendingMessage: function(aMessage, aCallback) {
if ((aMessage.type != "sms" && aMessage.type != "mms") ||
(aMessage.type == "sms" && aMessage.receiver == undefined) ||
(aMessage.type == "mms" && !Array.isArray(aMessage.receivers)) ||
aMessage.deliveryStatusRequested == undefined ||
aMessage.timestamp == undefined) {
if (aCallback) {
aCallback.notify(Cr.NS_ERROR_FAILURE, null);
}
return;
}
// Set |aMessage.deliveryStatus|. Note that for MMS record
// it must be an array of strings; For SMS, it's a string.
let deliveryStatus = aMessage.deliveryStatusRequested
? DELIVERY_STATUS_PENDING
: DELIVERY_STATUS_NOT_APPLICABLE;
if (aMessage.type == "sms") {
aMessage.deliveryStatus = deliveryStatus;
// If |deliveryTimestamp| is not specified, use 0 as default.
if (aMessage.deliveryTimestamp == undefined) {
aMessage.deliveryTimestamp = 0;
}
} else if (aMessage.type == "mms") {
let receivers = aMessage.receivers;
let readStatus = aMessage.headers["x-mms-read-report"]
? MMS.DOM_READ_STATUS_PENDING
: MMS.DOM_READ_STATUS_NOT_APPLICABLE;
aMessage.deliveryInfo = [];
for (let i = 0; i < receivers.length; i++) {
aMessage.deliveryInfo.push({
receiver: receivers[i],
deliveryStatus: deliveryStatus,
deliveryTimestamp: 0,
readStatus: readStatus,
readTimestamp: 0,
});
}
}
let timestamp = aMessage.timestamp;
// Adding needed indexes and extra attributes for internal use.
// threadIdIndex & participantIdsIndex are filled in saveRecord().
aMessage.deliveryIndex = [DELIVERY_SENDING, timestamp];
aMessage.readIndex = [FILTER_READ_READ, timestamp];
aMessage.delivery = DELIVERY_SENDING;
aMessage.messageClass = MESSAGE_CLASS_NORMAL;
aMessage.read = FILTER_READ_READ;
// |sentTimestamp| is not available when the message is still sedning.
aMessage.sentTimestamp = 0;
let threadParticipants;
if (aMessage.type == "sms") {
threadParticipants = [{
address: aMessage.receiver,
type :MMS.Address.resolveType(aMessage.receiver)
}];
} else if (aMessage.type == "mms") {
threadParticipants = aMessage.headers.to;
}
this.saveRecord(aMessage, threadParticipants, aCallback);
},
/**
* Update the <code>delivery</code>, <code>deliveryStatus</code>, and
* <code>envelopeId</code> of a stored message record matching the given
* message ID.
*
* @function MobileMessageDB.setMessageDeliveryByMessageId
* @param {number} messageId
* The message ID.
* @param {string} receiver
* The receiver address.
* @param {string} delivery
* If given, it will be used to update the <code>deliveryIndex</code>
* property of a stored message record.
* @param {string} deliveryStatus
* If given, it will be used to update the <code>deliveryStatus</code>
* property of a stored message record.
* @param {string} envelopeId
* If given, it will be used to update the <code>envelopeIdIndex</code>
* property of a stored message record.
* @param {Object} callback
* The object passed as <code>aCallback</code> to
* {@link MobileMessageDB.newTxnWithCallback}.
*/
setMessageDeliveryByMessageId: function(messageId, receiver, delivery,
deliveryStatus, envelopeId, callback) {
this.updateMessageDeliveryById(messageId, "messageId",
receiver, delivery, deliveryStatus,
envelopeId, callback);
},
/**
* Update the <code>deliveryStatus</code> of the specified
* <code>aReceiver</code> within the <code>deliveryInfo</code> of the message
* record retrieved by the given <code>envelopeId</code>.
*
* @function MobileMessageDB.setMessageDeliveryStatusByEnvelopeId
* @param {string} aEnvelopeId
* The envelope ID, which is the "x-mms-transaction-id" in the header
* of an MMS message.
* @param {string} aReceiver
* The receiver address.
* @param {string} aDeliveryStatus
* If given, it will be used to update the <code>deliveryStatus</code>
* property of a stored message record.
* @param {Object} aCallback
* The object passed as <code>aCallback</code> to
* {@link MobileMessageDB.newTxnWithCallback}.
*/
setMessageDeliveryStatusByEnvelopeId: function(aEnvelopeId, aReceiver,
aDeliveryStatus, aCallback) {
this.updateMessageDeliveryById(aEnvelopeId, "envelopeId", aReceiver, null,
aDeliveryStatus, null, aCallback);
},
/**
* Update the <code>readStatus</code> of the specified <code>aReceiver</code>
* within the <code>deliveryInfo</code> of the message record retrieved by the
* given <code>envelopeId</code>.
*
* @function MobileMessageDB.setMessageReadStatusByEnvelopeId
* @param {string} aEnvelopeId
* The envelope ID, which is the "x-mms-transaction-id" in the header
* of an MMS message.
* @param {string} aReceiver
* The receiver address.
* @param {string} aReadStatus
* The updated read status.
* @param {Object} aCallback
* The object passed as <code>aCallback</code> to
* {@link MobileMessageDB.newTxnWithCallback}.
*/
setMessageReadStatusByEnvelopeId: function(aEnvelopeId, aReceiver,
aReadStatus, aCallback) {
if (DEBUG) {
debug("Setting message's read status by envelopeId = " + aEnvelopeId +
", receiver: " + aReceiver + ", readStatus: " + aReadStatus);
}
let self = this;
this.newTxnWithCallback(aCallback, function(aCapture, aMessageStore) {
let getRequest = aMessageStore.index("envelopeId").get(aEnvelopeId);
getRequest.onsuccess = function(event) {
let messageRecord = event.target.result;
if (!messageRecord) {
if (DEBUG) debug("envelopeId '" + aEnvelopeId + "' not found");
throw Cr.NS_ERROR_FAILURE;
}
aCapture.messageRecord = messageRecord;
let isRecordUpdated = false;
self.forEachMatchedMmsDeliveryInfo(messageRecord.deliveryInfo,
aReceiver, function(aEntry) {
if (aEntry.readStatus == aReadStatus) {
return;
}
aEntry.readStatus = aReadStatus;
if (aReadStatus == MMS.DOM_READ_STATUS_SUCCESS) {
aEntry.readTimestamp = Date.now();
} else {
aEntry.readTimestamp = 0;
}
isRecordUpdated = true;
});
if (!isRecordUpdated) {
if (DEBUG) {
debug("The values of readStatus don't need to be updated.");
}
return;
}
if (DEBUG) {
debug("The readStatus is updated.");
}
aMessageStore.put(messageRecord);
};
});
},
/**
* @callback MobileMessageDB.GetMessageRecordCallback
* @param {number} aErrorCode
* The error code on failure, or <code>NS_OK</code> on success.
* @param {MobileMessageDB.MessageRecord} aMessageRecord
* The stored message record.
* @param {nsISmsMessage|nsIMmsMessage} aDomMessage
* The DOM message instance of the message record.
*/
/**
* Get the message record with given transaction ID.
*
* @function MobileMessageDB.getMessageRecordByTransactionId
* @param {string} aTransactionId
* The transaction ID.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.GetMessageRecordCallback} aCallback.notify
* The callback function to invoke when the request finishes.
*/
getMessageRecordByTransactionId: function(aTransactionId, aCallback) {
if (DEBUG) debug("Retrieving message with transaction ID " + aTransactionId);
let self = this;
this.newTxn(READ_ONLY, function(error, txn, messageStore) {
if (error) {
if (DEBUG) debug(error);
aCallback.notify(error, null, null);
return;
}
let request = messageStore.index("transactionId").get(aTransactionId);
txn.oncomplete = function(event) {
if (DEBUG) debug("Transaction " + txn + " completed.");
let messageRecord = request.result;
if (!messageRecord) {
if (DEBUG) debug("Transaction ID " + aTransactionId + " not found");
aCallback.notify(Cr.NS_ERROR_FILE_NOT_FOUND, null, null);
return;
}
// In this case, we don't need a dom message. Just pass null to the
// third argument.
aCallback.notify(Cr.NS_OK, messageRecord, null);
};
txn.onerror = function(event) {
if (DEBUG) {
if (event.target) {
debug("Caught error on transaction", event.target.error.name);
}
}
aCallback.notify(Cr.NS_ERROR_FAILURE, null, null);
};
});
},
/**
* Get the message record with given message ID.
*
* @function MobileMessageDB.getMessageRecordById
* @param {string} aMessageID
* The message ID.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.GetMessageRecordCallback} aCallback.notify
* The callback function to invoke when the request finishes.
*/
getMessageRecordById: function(aMessageId, aCallback) {
if (DEBUG) debug("Retrieving message with ID " + aMessageId);
let self = this;
this.newTxn(READ_ONLY, function(error, txn, messageStore) {
if (error) {
if (DEBUG) debug(error);
aCallback.notify(error, null, null);
return;
}
let request = messageStore.mozGetAll(aMessageId);
txn.oncomplete = function() {
if (DEBUG) debug("Transaction " + txn + " completed.");
if (request.result.length > 1) {
if (DEBUG) debug("Got too many results for id " + aMessageId);
aCallback.notify(Cr.NS_ERROR_UNEXPECTED, null, null);
return;
}
let messageRecord = request.result[0];
if (!messageRecord) {
if (DEBUG) debug("Message ID " + aMessageId + " not found");
aCallback.notify(Cr.NS_ERROR_FILE_NOT_FOUND, null, null);
return;
}
if (messageRecord.id != aMessageId) {
if (DEBUG) {
debug("Requested message ID (" + aMessageId + ") is " +
"different from the one we got");
}
aCallback.notify(Cr.NS_ERROR_UNEXPECTED, null, null);
return;
}
let domMessage = self.createDomMessageFromRecord(messageRecord);
aCallback.notify(Cr.NS_OK, messageRecord, domMessage);
};
txn.onerror = function(event) {
if (DEBUG) {
if (event.target) {
debug("Caught error on transaction", event.target.error.name);
}
}
aCallback.notify(Cr.NS_ERROR_FAILURE, null, null);
};
});
},
/**
* Helper to translate NS errors to the error causes defined in
* <code>nsIMobileMessageCallback</code>.
*
* @function MobileMessageDB.translateCrErrorToMessageCallbackError
* @param {number} aCrError
* The error code defined in <code>Components.result</code>
* @return {number}
* The error code defined in <code>nsIMobileMessageCallback</code>
*/
translateCrErrorToMessageCallbackError: function(aCrError) {
switch(aCrError) {
case Cr.NS_OK:
return Ci.nsIMobileMessageCallback.SUCCESS_NO_ERROR;
case Cr.NS_ERROR_UNEXPECTED:
return Ci.nsIMobileMessageCallback.UNKNOWN_ERROR;
case Cr.NS_ERROR_FILE_NOT_FOUND:
return Ci.nsIMobileMessageCallback.NOT_FOUND_ERROR;
case Cr.NS_ERROR_FILE_NO_DEVICE_SPACE:
return Ci.nsIMobileMessageCallback.STORAGE_FULL_ERROR;
default:
return Ci.nsIMobileMessageCallback.INTERNAL_ERROR;
}
},
/**
* @callback MobileMessageDB.SaveSmsSegmentCallback
* @param {number} aErrorCode
* The error code on failure, or <code>NS_OK</code> on success.
* @param {MobileMessageDB.SmsSegmentRecord} aCompleteMessage
* The composing message. It becomes a complete message once the last
* segment is stored.
*/
/**
* Store a single SMS segment.
*
* @function MobileMessageDB.saveSmsSegment
* @param {MobileMessageDB.SmsSegmentRecord} aSmsSegment
* Single SMS segment.
* @param {Object} aCallback
* The object which includes a callback function.
* @param {MobileMessageDB.SaveSmsSegmentCallback} aCallback.notify
* The callback function to invoke when the request finishes.
*/
saveSmsSegment: function(aSmsSegment, aCallback) {
let completeMessage = null;
this.newTxn(READ_WRITE, function(error, txn, segmentStore) {
if (error) {
if (DEBUG) debug(error);
aCallback.notify(error, null);
return;
}
txn.oncomplete = function(event) {
if (DEBUG) debug("Transaction " + txn + " completed.");
if (completeMessage) {
// Rebuild full body
if (completeMessage.encoding == RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
// Uint8Array doesn't have `concat`, so
// we have to merge all segments by hand.
let fullDataLen = 0;
for (let i = 1; i <= completeMessage.segmentMaxSeq; i++) {
fullDataLen += completeMessage.segments[i].length;
}
completeMessage.fullData = new Uint8Array(fullDataLen);
for (let d = 0, i = 1; i <= completeMessage.segmentMaxSeq; i++) {
let data = completeMessage.segments[i];
for (let j = 0; j < data.length; j++) {
completeMessage.fullData[d++] = data[j];
}
}
} else {
completeMessage.fullBody = completeMessage.segments.join("");
}
// Remove handy fields after completing the concatenation.
delete completeMessage.id;
delete completeMessage.hash;
delete completeMessage.receivedSegments;
delete completeMessage.segments;
}
aCallback.notify(Cr.NS_OK, completeMessage);
};
txn.onabort = function(event) {
if (DEBUG) debug("transaction abort due to " + event.target.error.name);
let error = (event.target.error.name === 'QuotaExceededError')
? Cr.NS_ERROR_FILE_NO_DEVICE_SPACE
: Cr.NS_ERROR_FAILURE;
aCallback.notify(error, null);
};
aSmsSegment.hash = aSmsSegment.sender + ":" +
aSmsSegment.segmentRef + ":" +
aSmsSegment.segmentMaxSeq + ":" +
aSmsSegment.iccId;
let seq = aSmsSegment.segmentSeq;
if (DEBUG) {
debug("Saving SMS Segment: " + aSmsSegment.hash + ", seq: " + seq);
}
let getRequest = segmentStore.index("hash").get(aSmsSegment.hash);
getRequest.onsuccess = function(event) {
let segmentRecord = event.target.result;
if (!segmentRecord) {
if (DEBUG) {
debug("Not found! Create a new record to store the segments.");
}
aSmsSegment.receivedSegments = 1;
aSmsSegment.segments = [];
if (aSmsSegment.encoding == RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
aSmsSegment.segments[seq] = aSmsSegment.data;
} else {
aSmsSegment.segments[seq] = aSmsSegment.body;
}
segmentStore.add(aSmsSegment);
return;
}
if (DEBUG) {
debug("Append SMS Segment into existed message object: " + segmentRecord.id);
}
if (segmentRecord.segments[seq]) {
if (segmentRecord.encoding == RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET &&
segmentRecord.encoding == aSmsSegment.encoding &&
segmentRecord.segments[seq].length == aSmsSegment.data.length &&
segmentRecord.segments[seq].every(function(aElement, aIndex) {
return aElement == aSmsSegment.data[aIndex];
})) {
if (DEBUG) {
debug("Got duplicated binary segment no: " + seq);
}
return;
}
if (segmentRecord.encoding != RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET &&
aSmsSegment.encoding != RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET &&
segmentRecord.segments[seq] == aSmsSegment.body) {
if (DEBUG) {
debug("Got duplicated text segment no: " + seq);
}
return;
}
// Update mandatory properties to ensure that the segments could be
// concatenated properly.
segmentRecord.encoding = aSmsSegment.encoding;
segmentRecord.originatorPort = aSmsSegment.originatorPort;
segmentRecord.destinationPort = aSmsSegment.destinationPort;
segmentRecord.teleservice = aSmsSegment.teleservice;
// Decrease the counter for this collided segment.
segmentRecord.receivedSegments--;
}
segmentRecord.timestamp = aSmsSegment.timestamp;
if (segmentRecord.encoding == RIL.PDU_DCS_MSG_CODING_8BITS_ALPHABET) {
segmentRecord.segments[seq] = aSmsSegment.data;
} else {
segmentRecord.segments[seq] = aSmsSegment.body;
}
segmentRecord.receivedSegments++;
// The port information is only available in 1st segment for CDMA WAP Push.
// If the segments of a WAP Push are not received in sequence
// (e.g., SMS with seq == 1 is not the 1st segment received by the device),
// we have to retrieve the port information from 1st segment and
// save it into the segmentRecord.
if (aSmsSegment.teleservice === RIL.PDU_CDMA_MSG_TELESERIVCIE_ID_WAP
&& seq === 1) {
if (aSmsSegment.originatorPort !== Ci.nsIGonkSmsService.SMS_APPLICATION_PORT_INVALID) {
segmentRecord.originatorPort = aSmsSegment.originatorPort;
}
if (aSmsSegment.destinationPort !== Ci.nsIGonkSmsService.SMS_APPLICATION_PORT_INVALID) {
segmentRecord.destinationPort = aSmsSegment.destinationPort;
}
}
if (segmentRecord.receivedSegments < segmentRecord.segmentMaxSeq) {
if (DEBUG) debug("Message is incomplete.");
segmentStore.put(segmentRecord);
return;
}
completeMessage = segmentRecord;
// Delete Record in DB
segmentStore.delete(segmentRecord.id);
};
}, [SMS_SEGMENT_STORE_NAME]);
},
/**
* nsIMobileMessageDatabaseService API
*/
/**
* Get the message record with given message ID.
*
* @function MobileMessageDB.getMessage
* @param {string} aMessageID
* The message ID.
* @param {nsIMobileMessageCallback} aRequest
* The callback object.
*/
getMessage: function(aMessageId, aRequest) {
if (DEBUG) debug("Retrieving message with ID " + aMessageId);
let self = this;
let notifyCallback = {
notify: function(aRv, aMessageRecord, aDomMessage) {
if (Cr.NS_OK == aRv) {
aRequest.notifyMessageGot(aDomMessage);
return;
}
aRequest.notifyGetMessageFailed(
self.translateCrErrorToMessageCallbackError(aRv), null);
}
};
this.getMessageRecordById(aMessageId, notifyCallback);
},
/**
* Delete the message record with given message IDs.
*
* @function MobileMessageDB.deleteMessage
* @param {number[]} messageIds
* The IDs of messages to delete.
* @param {number} length
* The length of the <code>messageIds</code> array.
* @param {nsIMobileMessageCallback} aRequest
* The callback object.
*/
deleteMessage: function(messageIds, length, aRequest) {
if (DEBUG) debug("deleteMessage: message ids " + JSON.stringify(messageIds));
let deleted = [];
let self = this;
this.newTxn(READ_WRITE, function(error, txn, stores) {
if (error) {
if (DEBUG) debug("deleteMessage: failed to open transaction");
aRequest.notifyDeleteMessageFailed(
self.translateCrErrorToMessageCallbackError(error));
return;
}
let deletedInfo = { messageIds: [], threadIds: [] };
txn.onabort = function(event) {
if (DEBUG) debug("transaction abort due to " + event.target.error.name);
let error = (event.target.error.name === 'QuotaExceededError')
? Ci.nsIMobileMessageCallback.STORAGE_FULL_ERROR
: Ci.nsIMobileMessageCallback.INTERNAL_ERROR;
aRequest.notifyDeleteMessageFailed(error);
};
const messageStore = stores[0];
const threadStore = stores[1];
txn.oncomplete = function(event) {
if (DEBUG) debug("Transaction " + txn + " completed.");
aRequest.notifyMessageDeleted(deleted, length);
self.notifyDeletedInfo(deletedInfo);
};
let threadsToUpdate = {};
let numOfMessagesToDelete = length;
let updateThreadInfo = function() {
for (let threadId in threadsToUpdate) {
let threadInfo = threadsToUpdate[threadId];
self.updateThreadByMessageChange(messageStore,
threadStore,
threadInfo.threadId,
threadInfo.removedMsgIds,
threadInfo.ignoredUnreadCount,
deletedInfo);
}
};
for (let i = 0; i < length; i++) {
let messageId = messageIds[i];
deleted[i] = false;
messageStore.get(messageId).onsuccess = function(messageIndex, event) {
let messageRecord = event.target.result;
let messageId = messageIds[messageIndex];
if (messageRecord) {
if (DEBUG) debug("Deleting message id " + messageId);
// First actually delete the message.
messageStore.delete(messageId).onsuccess = function(event) {
if (DEBUG) debug("Message id " + messageId + " deleted");
numOfMessagesToDelete--;
deleted[messageIndex] = true;
deletedInfo.messageIds.push(messageId);
// Cache thread info to be updated.
let threadId = messageRecord.threadId;
if (!threadsToUpdate[threadId]) {
threadsToUpdate[threadId] = {
threadId: threadId,
removedMsgIds: [messageId],
ignoredUnreadCount: (!messageRecord.read) ? 1 : 0
};
} else {
let threadInfo = threadsToUpdate[threadId];
threadInfo.removedMsgIds.push(messageId);
if (!messageRecord.read) {
threadInfo.ignoredUnreadCount++;
}
}
// After all messsages are deleted, update unread count and most
// recent message of related threads at once.
if (!numOfMessagesToDelete) {
updateThreadInfo();
}
};
} else {
if (DEBUG) debug("Message id " + messageId + " does not exist");
numOfMessagesToDelete--;
if (!numOfMessagesToDelete) {
updateThreadInfo();
}
}
}.bind(null, i);
}
}, [MESSAGE_STORE_NAME, THREAD_STORE_NAME]);
},
/**
* Create a cursor to iterate on stored message records.
*
* @function MobileMessageDB.createMessageCursor
* @param {boolean} aHasStartDate
* <code>true</code> to query only messages starts with
* <code>aStartDate</code>
* @param {number} aStartDate
* The timestamp of start date in milliseconds.
* @param {boolean} aHasEndDate
* <code>true</code> to query only messages before the
* <code>aEndDate</code>
* @param {number} aEndDate
* The timestamp of end date in milliseconds.
* @param {string[]} aNumbers
* If not <code>null</code>, query only messages with sender or
* receiver who's number matches one of the numbers listed in the array.
* @param {number} aNumbersCount
* The length of <code>aNumbers</code> array.
* @param {string} aDelivery
* If not <code>null</code>, query only messages matching the delivery
* value.
* @param {boolean} aHasRead
* <code>true</code> to query only messages match the read value
* specified by <code>aRead</code>
* @param {boolean} aRead
* Specify the <code>read</code> query condition.
* @param {number} aThreadId
* If not <code>null</code>, query only messages in the given thread.
* @param {boolean} aReverse
* <code>true</code> to reverse the order.
* @param {nsIMobileMessageCursorCallback} aCallback
* The callback object used by GetMessagesCursor
* @return {GetMessagesCursor}
* The cursor to iterate on messages.
*/
createMessageCursor: function(aHasStartDate, aStartDate, aHasEndDate,
aEndDate, aNumbers, aNumbersCount, aDelivery,
aHasRead, aRead, aHasThreadId, aThreadId,
aReverse, aCallback) {
if (DEBUG) {
debug("Creating a message cursor. Filters:" +
" startDate: " + (aHasStartDate ? aStartDate : "(null)") +
" endDate: " + (aHasEndDate ? aEndDate : "(null)") +
" delivery: " + aDelivery +
" numbers: " + (aNumbersCount ? aNumbers : "(null)") +
" read: " + (aHasRead ? aRead : "(null)") +
" threadId: " + (aHasThreadId ? aThreadId : "(null)") +
" reverse: " + aReverse);
}
let filter = {};
if (aHasStartDate) {
filter.startDate = aStartDate;
}
if (aHasEndDate) {
filter.endDate = aEndDate;
}
if (aNumbersCount) {
filter.numbers = aNumbers.slice();
}
if (aDelivery !== null) {
filter.delivery = aDelivery;
}
if (aHasRead) {
filter.read = aRead;
}
if (aHasThreadId) {
filter.threadId = aThreadId;
}
let cursor = new GetMessagesCursor(this, aCallback);
let self = this;
self.newTxn(READ_ONLY, function(error, txn, stores) {
let collector = cursor.collector.idCollector;
let collect = collector.collect.bind(collector);
FilterSearcherHelper.transact(self, txn, error, filter, aReverse, collect);
}, [MESSAGE_STORE_NAME, PARTICIPANT_STORE_NAME]);
return cursor;
},
/**
* Change the <code>read</code> property of a stored message record.
*
* @function MobileMessageDB.markMessageRead
* @param {number} messageId
* The message ID.
* @param {boolean} value
* The updated <code>read</code> value.
* @param {boolean} aSendReadReport
* <code>true</code> to reply the read report of an incoming MMS
* message whose <code>isReadReportSent</code> is 'false'.
* Note: <code>isReadReportSent</code> will be set to 'true' no
* matter aSendReadReport is true or not when a message was marked
* from UNREAD to READ. See bug 1180470 for the new UX policy.
* @param {nsIMobileMessageCallback} aRequest
* The callback object.
*/
markMessageRead: function(messageId, value, aSendReadReport, aRequest) {
if (DEBUG) debug("Setting message " + messageId + " read to " + value);
let self = this;
this.newTxn(READ_WRITE, function(error, txn, stores) {
if (error) {
if (DEBUG) debug(error);
aRequest.notifyMarkMessageReadFailed(
self.translateCrErrorToMessageCallbackError(error));
return;
}
txn.onabort = function(event) {
if (DEBUG) debug("transaction abort due to " + event.target.error.name);
let error = (event.target.error.name === 'QuotaExceededError')
? Ci.nsIMobileMessageCallback.STORAGE_FULL_ERROR
: Ci.nsIMobileMessageCallback.INTERNAL_ERROR;
aRequest.notifyMarkMessageReadFailed(error);
};
let messageStore = stores[0];
let threadStore = stores[1];
messageStore.get(messageId).onsuccess = function(event) {
let messageRecord = event.target.result;
if (!messageRecord) {
if (DEBUG) debug("Message ID " + messageId + " not found");
aRequest.notifyMarkMessageReadFailed(Ci.nsIMobileMessageCallback.NOT_FOUND_ERROR);
return;
}
if (messageRecord.id != messageId) {
if (DEBUG) {
debug("Retrieve message ID (" + messageId + ") is " +
"different from the one we got");
}
aRequest.notifyMarkMessageReadFailed(Ci.nsIMobileMessageCallback.UNKNOWN_ERROR);
return;
}
// If the value to be set is the same as the current message `read`
// value, we just notify successfully.
if (messageRecord.read == value) {
if (DEBUG) debug("The value of messageRecord.read is already " + value);
aRequest.notifyMessageMarkedRead(messageRecord.read);
return;
}
messageRecord.read = value ? FILTER_READ_READ : FILTER_READ_UNREAD;
messageRecord.readIndex = [messageRecord.read, messageRecord.timestamp];
let readReportMessageId, readReportTo;
if (messageRecord.type == "mms" &&
messageRecord.delivery == DELIVERY_RECEIVED &&
messageRecord.read == FILTER_READ_READ &&
messageRecord.headers["x-mms-read-report"] &&
!messageRecord.isReadReportSent) {
messageRecord.isReadReportSent = true;
if (aSendReadReport) {
let from = messageRecord.headers["from"];
readReportTo = from && from.address;
readReportMessageId = messageRecord.headers["message-id"];
}
}
if (DEBUG) debug("Message.read set to: " + value);
messageStore.put(messageRecord).onsuccess = function(event) {
if (DEBUG) {
debug("Update successfully completed. Message: " +
JSON.stringify(event.target.result));
}
// Now update the unread count.
let threadId = messageRecord.threadId;
threadStore.get(threadId).onsuccess = function(event) {
let threadRecord = event.target.result;
threadRecord.unreadCount += value ? -1 : 1;
if (DEBUG) {
debug("Updating unreadCount for thread id " + threadId + ": " +
(value ?
threadRecord.unreadCount + 1 :
threadRecord.unreadCount - 1) +
" -> " + threadRecord.unreadCount);
}
threadStore.put(threadRecord).onsuccess = function(event) {
if(readReportMessageId && readReportTo) {
gMMSService.sendReadReport(readReportMessageId,
readReportTo,
messageRecord.iccId);
}
aRequest.notifyMessageMarkedRead(messageRecord.read);
};
};
};
};
}, [MESSAGE_STORE_NAME, THREAD_STORE_NAME]);
},
/**
* Create a cursor to iterate on stored threads.
*
* @function MobileMessageDB.createThreadCursor
* @param {nsIMobileMessageCursorCallback} callback
* The callback object used by GetMessagesCursor
* @return {GetThreadsCursor}
* The cursor to iterate on threads.
*/
createThreadCursor: function(callback) {
if (DEBUG) debug("Getting thread list");
let cursor = new GetThreadsCursor(this, callback);
this.newTxn(READ_ONLY, function(error, txn, threadStore) {
let collector = cursor.collector.idCollector;
if (error) {
collector.collect(null, COLLECT_ID_ERROR, COLLECT_TIMESTAMP_UNUSED);
return;
}
txn.onerror = function(event) {
if (DEBUG) debug("Caught error on transaction ", event.target.error.name);
collector.collect(null, COLLECT_ID_ERROR, COLLECT_TIMESTAMP_UNUSED);
};
let request = threadStore.index("lastTimestamp").openKeyCursor(null, PREV);
request.onsuccess = function(event) {
let cursor = event.target.result;
if (cursor) {
if (collector.collect(txn, cursor.primaryKey, cursor.key)) {
cursor.continue();
}
} else {
collector.collect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
}
};
}, [THREAD_STORE_NAME]);
return cursor;
}
};
var FilterSearcherHelper = {
/**
* @param index
* The name of a message store index to filter on.
* @param range
* A IDBKeyRange.
* @param direction
* NEXT or PREV.
* @param txn
* Ongoing IDBTransaction context object.
* @param collect
* Result colletor function. It takes three parameters -- txn, message
* id, and message timestamp.
*/
filterIndex: function(index, range, direction, txn, collect) {
let messageStore = txn.objectStore(MESSAGE_STORE_NAME);
let request = messageStore.index(index).openKeyCursor(range, direction);
request.onsuccess = function(event) {
let cursor = event.target.result;
// Once the cursor has retrieved all keys that matches its key range,
// the filter search is done.
if (cursor) {
let timestamp = Array.isArray(cursor.key) ? cursor.key[1] : cursor.key;
if (collect(txn, cursor.primaryKey, timestamp)) {
cursor.continue();
}
} else {
collect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
}
};
request.onerror = function(event) {
if (DEBUG && event) debug("IDBRequest error " + event.target.error.name);
collect(txn, COLLECT_ID_ERROR, COLLECT_TIMESTAMP_UNUSED);
};
},
/**
* Explicitly filter message on the timestamp index.
*
* @param startDate
* Timestamp of the starting date.
* @param endDate
* Timestamp of the ending date.
* @param direction
* NEXT or PREV.
* @param txn
* Ongoing IDBTransaction context object.
* @param collect
* Result colletor function. It takes three parameters -- txn, message
* id, and message timestamp.
*/
filterTimestamp: function(startDate, endDate, direction, txn, collect) {
let range = null;
if (startDate != null && endDate != null) {
range = IDBKeyRange.bound(startDate, endDate);
} else if (startDate != null) {
range = IDBKeyRange.lowerBound(startDate);
} else if (endDate != null) {
range = IDBKeyRange.upperBound(endDate);
}
this.filterIndex("timestamp", range, direction, txn, collect);
},
/**
* Initiate a filtering transaction.
*
* @param mmdb
* A MobileMessageDB.
* @param txn
* Ongoing IDBTransaction context object.
* @param error
* Previous error while creating the transaction.
* @param filter
* A MobileMessageFilter dictionary.
* @param reverse
* A boolean value indicating whether we should filter message in
* reversed order.
* @param collect
* Result collector function. It takes three parameters -- txn, message
* id, and message timestamp.
*/
transact: function(mmdb, txn, error, filter, reverse, collect) {
if (error) {
// TODO look at event.target.error.name, pick appropriate error constant.
if (DEBUG) debug("IDBRequest error " + event.target.error.name);
collect(txn, COLLECT_ID_ERROR, COLLECT_TIMESTAMP_UNUSED);
return;
}
let direction = reverse ? PREV : NEXT;
// We support filtering by date range only (see `else` block below) or by
// number/delivery status/read status with an optional date range.
if (filter.delivery == null &&
filter.numbers == null &&
filter.read == null &&
filter.threadId == null) {
// Filtering by date range only.
if (DEBUG) {
debug("filter.timestamp " + filter.startDate + ", " + filter.endDate);
}
this.filterTimestamp(filter.startDate, filter.endDate, direction, txn,
collect);
return;
}
// Numeric 0 is smaller than any time stamp, and empty string is larger
// than all numeric values.
let startDate = 0, endDate = "";
if (filter.startDate != null) {
startDate = filter.startDate;
}
if (filter.endDate != null) {
endDate = filter.endDate;
}
let single, intersectionCollector;
{
let num = 0;
if (filter.delivery) num++;
if (filter.numbers) num++;
if (filter.read != undefined) num++;
if (filter.threadId != undefined) num++;
single = (num == 1);
}
if (!single) {
intersectionCollector = new IntersectionResultsCollector(collect, reverse);
}
// Retrieve the keys from the 'delivery' index that matches the value of
// filter.delivery.
if (filter.delivery) {
if (DEBUG) debug("filter.delivery " + filter.delivery);
let delivery = filter.delivery;
let range = IDBKeyRange.bound([delivery, startDate], [delivery, endDate]);
this.filterIndex("delivery", range, direction, txn,
single ? collect : intersectionCollector.newContext());
}
// Retrieve the keys from the 'read' index that matches the value of
// filter.read.
if (filter.read != undefined) {
if (DEBUG) debug("filter.read " + filter.read);
let read = filter.read ? FILTER_READ_READ : FILTER_READ_UNREAD;
let range = IDBKeyRange.bound([read, startDate], [read, endDate]);
this.filterIndex("read", range, direction, txn,
single ? collect : intersectionCollector.newContext());
}
// Retrieve the keys from the 'threadId' index that matches the value of
// filter.threadId.
if (filter.threadId != undefined) {
if (DEBUG) debug("filter.threadId " + filter.threadId);
let threadId = filter.threadId;
let range = IDBKeyRange.bound([threadId, startDate], [threadId, endDate]);
this.filterIndex("threadId", range, direction, txn,
single ? collect : intersectionCollector.newContext());
}
// Retrieve the keys from the 'sender' and 'receiver' indexes that
// match the values of filter.numbers
if (filter.numbers) {
if (DEBUG) debug("filter.numbers " + filter.numbers.join(", "));
if (!single) {
collect = intersectionCollector.newContext();
}
let participantStore = txn.objectStore(PARTICIPANT_STORE_NAME);
let typedAddresses = filter.numbers.map(function(number) {
return {
address: number,
type: MMS.Address.resolveType(number)
};
});
mmdb.findParticipantIdsByTypedAddresses(participantStore, typedAddresses,
false, true,
(function(participantIds) {
if (!participantIds || !participantIds.length) {
// Oops! No such participant at all.
collect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
return;
}
if (participantIds.length == 1) {
let id = participantIds[0];
let range = IDBKeyRange.bound([id, startDate], [id, endDate]);
this.filterIndex("participantIds", range, direction, txn, collect);
return;
}
let unionCollector = new UnionResultsCollector(collect);
this.filterTimestamp(filter.startDate, filter.endDate, direction, txn,
unionCollector.newTimestampContext());
for (let i = 0; i < participantIds.length; i++) {
let id = participantIds[i];
let range = IDBKeyRange.bound([id, startDate], [id, endDate]);
this.filterIndex("participantIds", range, direction, txn,
unionCollector.newContext());
}
}).bind(this));
}
}
};
/**
* Collector class for read-ahead result objects. Mmdb may now try to fetch
* message/thread records before it's requested explicitly.
*
* The read ahead behavior can be controlled by an integer mozSettings entry
* "ril.sms.maxReadAheadEntries" as well as an integer holding preference
* "dom.sms.maxReadAheadEntries". The meanings are:
*
* positive: finite read-ahead entries,
* 0: don't read ahead unless explicitly requested, (default)
* negative: read ahead all IDs if possible.
*
* The order of ID filtering objects are now:
*
* [UnionResultsCollector]
* +-> [IntersectionResultsCollector]
* +-> IDsCollector
* +-> ResultsCollector
*
* ResultsCollector has basically similar behaviour with IDsCollector. When
* RC::squeeze() is called, either RC::drip() is called instantly if we have
* already fetched results available, or the request is kept and IC::squeeze()
* is called.
*
* When RC::collect is called by IC::drip, it proceeds to fetch the
* corresponding record given that collected ID is neither an error nor an end
* mark. After the message/thread record being fetched, ResultsCollector::drip
* is called if we have pending request. Anyway, RC::maybeSqueezeIdCollector is
* called to determine whether we need to call IC::squeeze again.
*
* RC::squeeze is called when nsICursorContinueCallback::handleContinue() is
* called. ResultsCollector::drip will call to
* nsIMobileMessageCursorCallback::notifyFoo.
*
* In summary, the major call paths are:
*
* RC::squeeze
* o-> RC::drip
* +-> RC::notifyCallback
* +-> nsIMobileMessageCursorCallback::notifyFoo
* +-> RC::maybeSqueezeIdCollector
* o-> IC::squeeze
* o-> IC::drip
* +-> RC::collect
* o-> RC::readAhead
* +-> RC::notifyResult
* o-> RC::drip ...
* +-> RC::maybeSqueezeIdCollector ...
* o-> RC::notifyResult ...
*/
function ResultsCollector(readAheadFunc) {
this.idCollector = new IDsCollector();
this.results = [];
this.readAhead = readAheadFunc;
this.maxReadAhead = DEFAULT_READ_AHEAD_ENTRIES;
try {
// positive: finite read-ahead entries,
// 0: don't read ahead unless explicitly requested,
// negative: read ahead all IDs if possible.
this.maxReadAhead =
Services.prefs.getIntPref("dom.sms.maxReadAheadEntries");
} catch (e) {}
}
ResultsCollector.prototype = {
/**
* Underlying ID collector object.
*/
idCollector: null,
/**
* An array keeping fetched result objects. Replaced by a new empty array
* every time when |this.drip| is called.
*/
results: null,
/**
* A function that takes (<txn>, <id>, <collector>). It fetches the object
* specified by <id> and notify <collector> with that by calling
* |<collector>.notifyResult()|. If <txn> is null, this function should
* create a new read-only transaction itself. The returned result object may
* be null to indicate an error during the fetch process.
*/
readAhead: null,
/**
* A boolean value inidicating a readAhead call is ongoing. Set before calling
* |this.readAhead| and reset in |this.notifyResult|.
*/
readingAhead: false,
/**
* A numeric value read from preference "dom.sms.maxReadAheadEntries".
*/
maxReadAhead: 0,
/**
* An active IDBTransaction object to be reused.
*/
activeTxn: null,
/**
* A nsIMobileMessageCursorCallback.
*/
requestWaiting: null,
/**
* A boolean value indicating either a COLLECT_ID_END or COLLECT_ID_ERROR has
* been received.
*/
done: false,
/**
* When |this.done|, it's either COLLECT_ID_END or COLLECT_ID_ERROR.
*/
lastId: null,
/**
* Receive collected id from IDsCollector and fetch the correspond result
* object if necessary.
*
* @param txn
* An IDBTransaction object. Null if there is no active transaction in
* IDsCollector. That is, the ID collecting transaction is completed.
* @param id
* A positive numeric id, COLLECT_ID_END(0), or COLLECT_ID_ERROR(-1).
*/
collect: function(txn, id) {
if (this.done) {
// If this callector has been terminated because of previous errors in
// |this.readAhead|, ignore any further IDs from IDsCollector.
return;
}
if (DEBUG) debug("ResultsCollector::collect ID = " + id);
// Reuse the active transaction cached if IDsCollector has no active
// transaction.
txn = txn || this.activeTxn;
if (id > 0) {
this.readingAhead = true;
this.readAhead(txn, id, this);
} else {
this.notifyResult(txn, id, null);
}
},
/**
* Callback function for |this.readAhead|.
*
* This function pushes result object to |this.results| or updates
* |this.done|, |this.lastId| if an end mark or an error is found. Since we
* have already a valid result entry, check |this.requestWaiting| and deal
* with it. At last, call to |this.maybeSqueezeIdCollector| to ask more id
* again if necessary.
*
* @param txn
* An IDBTransaction object. Null if caller has no active transaction.
* @param id
* A positive numeric id, COLLECT_ID_END(0), or COLLECT_ID_ERROR(-1).
* @param result
* An object associated with id. Null if |this.readAhead| failed.
*/
notifyResult: function(txn, id, result) {
if (DEBUG) debug("notifyResult(txn, " + id + ", <result>)");
this.readingAhead = false;
if (id > 0) {
if (result != null) {
this.results.push(result);
} else {
id = COLLECT_ID_ERROR;
}
}
if (id <= 0) {
this.lastId = id;
this.done = true;
}
if (!this.requestWaiting) {
if (DEBUG) debug("notifyResult: cursor.continue() not called yet");
} else {
let callback = this.requestWaiting;
this.requestWaiting = null;
this.drip(callback);
}
this.maybeSqueezeIdCollector(txn);
},
/**
* Request for one more ID if necessary.
*
* @param txn
* An IDBTransaction object. Null if caller has no active transaction.
*/
maybeSqueezeIdCollector: function(txn) {
if (this.done || // Nothing to be read.
this.readingAhead || // Already in progress.
this.idCollector.requestWaiting) { // Already requested.
return;
}
let max = this.maxReadAhead;
if (!max && this.requestWaiting) {
// If |this.requestWaiting| is set, try to read ahead at least once.
max = 1;
}
if (max >= 0 && this.results.length >= max) {
// More-equal than <max> entries has been read. Stop.
if (DEBUG) debug("maybeSqueezeIdCollector: max " + max + " entries read. Stop.");
return;
}
// A hack to pass current txn to |this.collect| when it's called directly by
// |IDsCollector.squeeze|.
this.activeTxn = txn;
this.idCollector.squeeze(this.collect.bind(this));
this.activeTxn = null;
},
/**
* Request to pass available results or wait.
*
* @param callback
* A nsIMobileMessageCursorCallback.
*/
squeeze: function(callback) {
if (this.requestWaiting) {
throw new Error("Already waiting for another request!");
}
if (this.results.length || this.done) {
// If |this.results.length| is non-zero, we have already some results to
// pass. Otherwise, if |this.done| evaluates to true, we have also a
// confirmed result to pass.
this.drip(callback);
} else {
this.requestWaiting = callback;
}
// If we called |this.drip| in the last step, the fetched results have been
// consumed and we should ask some more for read-ahead now.
//
// Otherwise, kick start read-ahead again because it may be stopped
// previously because of |this.maxReadAhead| had been reached.
this.maybeSqueezeIdCollector(null);
},
/**
* Consume fetched resutls.
*
* @param callback
* A nsIMobileMessageCursorCallback.
*/
drip: function(callback) {
let results = this.results;
this.results = [];
let func = this.notifyCallback.bind(this, callback, results, this.lastId);
Services.tm.currentThread.dispatch(func, Ci.nsIThread.DISPATCH_NORMAL);
},
/**
* Notify a nsIMobileMessageCursorCallback.
*
* @param callback
* A nsIMobileMessageCursorCallback.
* @param results
* An array of result objects.
* @param lastId
* Since we only call |this.drip| when either there are results
* available or the read-ahead has done, so lastId here will be
* COLLECT_ID_END or COLLECT_ID_ERROR when results is empty and null
* otherwise.
*/
notifyCallback: function(callback, results, lastId) {
if (DEBUG) {
debug("notifyCallback(results[" + results.length + "], " + lastId + ")");
}
if (results.length) {
callback.notifyCursorResult(results, results.length);
} else if (lastId == COLLECT_ID_END) {
callback.notifyCursorDone();
} else {
callback.notifyCursorError(Ci.nsIMobileMessageCallback.INTERNAL_ERROR);
}
}
};
function IDsCollector() {
this.results = [];
this.done = false;
}
IDsCollector.prototype = {
results: null,
requestWaiting: null,
done: null,
/**
* Queue up passed id, reply if necessary.
*
* @param txn
* Ongoing IDBTransaction context object.
* @param id
* COLLECT_ID_END(0) for no more results, COLLECT_ID_ERROR(-1) for
* errors and valid otherwise.
* @param timestamp
* We assume this function is always called in timestamp order. So
* this parameter is actually unused.
*
* @return true if expects more. false otherwise.
*/
collect: function(txn, id, timestamp) {
if (this.done) {
return false;
}
if (DEBUG) debug("IDsCollector::collect ID = " + id);
// Queue up any id.
this.results.push(id);
if (id <= 0) {
// No more processing on '0' or negative values passed.
this.done = true;
}
if (!this.requestWaiting) {
if (DEBUG) debug("IDsCollector::squeeze() not called yet");
return !this.done;
}
// We assume there is only one request waiting throughout the message list
// retrieving process. So we don't bother continuing to process further
// waiting requests here. This assumption comes from DOMCursor::Continue()
// implementation.
let callback = this.requestWaiting;
this.requestWaiting = null;
this.drip(txn, callback);
return !this.done;
},
/**
* Callback right away with the first queued result entry if the filtering is
* done. Or queue up the request and callback when a new entry is available.
*
* @param callback
* A callback function that accepts a numeric id.
*/
squeeze: function(callback) {
if (this.requestWaiting) {
throw new Error("Already waiting for another request!");
}
if (!this.done) {
// Database transaction ongoing, let it reply for us so that we won't get
// blocked by the existing transaction.
this.requestWaiting = callback;
return;
}
this.drip(null, callback);
},
/**
* @param txn
* Ongoing IDBTransaction context object or null.
* @param callback
* A callback function that accepts a numeric id.
*/
drip: function(txn, callback) {
let firstId = this.results[0];
if (firstId > 0) {
this.results.shift();
}
callback(txn, firstId);
}
};
function IntersectionResultsCollector(collect, reverse) {
this.cascadedCollect = collect;
this.reverse = reverse;
this.contexts = [];
}
IntersectionResultsCollector.prototype = {
cascadedCollect: null,
reverse: false,
contexts: null,
/**
* Queue up {id, timestamp} pairs, find out intersections and report to
* |cascadedCollect|. Return true if it is still possible to have another match.
*/
collect: function(contextIndex, txn, id, timestamp) {
if (DEBUG) {
debug("IntersectionResultsCollector: "
+ contextIndex + ", " + id + ", " + timestamp);
}
let contexts = this.contexts;
let context = contexts[contextIndex];
if (id < 0) {
// Act as no more matched records.
id = 0;
}
if (!id) {
context.done = true;
if (!context.results.length) {
// Already empty, can't have further intersection results.
return this.cascadedCollect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
}
for (let i = 0; i < contexts.length; i++) {
if (!contexts[i].done) {
// Don't call |this.cascadedCollect| because |context.results| might not
// be empty, so other contexts might still have a chance here.
return false;
}
}
// It was the last processing context and is no more processing.
return this.cascadedCollect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
}
// Search id in other existing results. If no other results has it,
// and A) the last timestamp is smaller-equal to current timestamp,
// we wait for further results; either B) record timestamp is larger
// then current timestamp or C) no more processing for a filter, then we
// drop this id because there can't be a match anymore.
for (let i = 0; i < contexts.length; i++) {
if (i == contextIndex) {
continue;
}
let ctx = contexts[i];
let results = ctx.results;
let found = false;
for (let j = 0; j < results.length; j++) {
let result = results[j];
if (result.id == id) {
found = true;
break;
}
if ((!this.reverse && (result.timestamp > timestamp)) ||
(this.reverse && (result.timestamp < timestamp))) {
// B) Cannot find a match anymore. Drop.
return true;
}
}
if (!found) {
if (ctx.done) {
// C) Cannot find a match anymore. Drop.
if (results.length) {
let lastResult = results[results.length - 1];
if ((!this.reverse && (lastResult.timestamp >= timestamp)) ||
(this.reverse && (lastResult.timestamp <= timestamp))) {
// Still have a chance to get another match. Return true.
return true;
}
}
// Impossible to find another match because all results in ctx have
// timestamps smaller than timestamp.
context.done = true;
return this.cascadedCollect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
}
// A) Pending.
context.results.push({
id: id,
timestamp: timestamp
});
return true;
}
}
// Now id is found in all other results. Report it.
return this.cascadedCollect(txn, id, timestamp);
},
newContext: function() {
let contextIndex = this.contexts.length;
this.contexts.push({
results: [],
done: false
});
return this.collect.bind(this, contextIndex);
}
};
function UnionResultsCollector(collect) {
this.cascadedCollect = collect;
this.contexts = [{
// Timestamp.
processing: 1,
results: []
}, {
processing: 0,
results: []
}];
}
UnionResultsCollector.prototype = {
cascadedCollect: null,
contexts: null,
collect: function(contextIndex, txn, id, timestamp) {
if (DEBUG) {
debug("UnionResultsCollector: "
+ contextIndex + ", " + id + ", " + timestamp);
}
let contexts = this.contexts;
let context = contexts[contextIndex];
if (id < 0) {
// Act as no more matched records.
id = 0;
}
if (id) {
if (!contextIndex) {
// Timestamp.
context.results.push({
id: id,
timestamp: timestamp
});
} else {
context.results.push(id);
}
return true;
}
context.processing -= 1;
if (contexts[0].processing || contexts[1].processing) {
// At least one queue is still processing, but we got here because
// current cursor gives 0 as id meaning no more messages are
// available. Return false here to stop further cursor.continue() calls.
return false;
}
let tres = contexts[0].results;
let qres = contexts[1].results;
tres = tres.filter(function(element) {
return qres.indexOf(element.id) != -1;
});
for (let i = 0; i < tres.length; i++) {
this.cascadedCollect(txn, tres[i].id, tres[i].timestamp);
}
this.cascadedCollect(txn, COLLECT_ID_END, COLLECT_TIMESTAMP_UNUSED);
return false;
},
newTimestampContext: function() {
return this.collect.bind(this, 0);
},
newContext: function() {
this.contexts[1].processing++;
return this.collect.bind(this, 1);
}
};
function GetMessagesCursor(mmdb, callback) {
this.mmdb = mmdb;
this.callback = callback;
this.collector = new ResultsCollector(this.getMessage.bind(this));
this.handleContinue(); // Trigger first run.
}
GetMessagesCursor.prototype = {
classID: RIL_GETMESSAGESCURSOR_CID,
QueryInterface: XPCOMUtils.generateQI([Ci.nsICursorContinueCallback]),
mmdb: null,
callback: null,
collector: null,
getMessageTxn: function(txn, messageStore, messageId, collector) {
if (DEBUG) debug ("Fetching message " + messageId);
let getRequest = messageStore.get(messageId);
let self = this;
getRequest.onsuccess = function(event) {
if (DEBUG) {
debug("notifyNextMessageInListGot - messageId: " + messageId);
}
let domMessage =
self.mmdb.createDomMessageFromRecord(event.target.result);
collector.notifyResult(txn, messageId, domMessage);
};
getRequest.onerror = function(event) {
// Error reporting is done in ResultsCollector.notifyCallback.
event.stopPropagation();
event.preventDefault();
if (DEBUG) {
debug("notifyCursorError - messageId: " + messageId);
}
collector.notifyResult(txn, messageId, null);
};
},
getMessage: function(txn, messageId, collector) {
// When filter transaction is not yet completed, we're called with current
// ongoing transaction object.
if (txn) {
let messageStore = txn.objectStore(MESSAGE_STORE_NAME);
this.getMessageTxn(txn, messageStore, messageId, collector);
return;
}
// Or, we have to open another transaction ourselves.
let self = this;
this.mmdb.newTxn(READ_ONLY, function(error, txn, messageStore) {
if (error) {
debug("getMessage: failed to create new transaction");
collector.notifyResult(null, messageId, null);
} else {
self.getMessageTxn(txn, messageStore, messageId, collector);
}
}, [MESSAGE_STORE_NAME]);
},
// nsICursorContinueCallback
handleContinue: function() {
if (DEBUG) debug("Getting next message in list");
this.collector.squeeze(this.callback);
}
};
function GetThreadsCursor(mmdb, callback) {
this.mmdb = mmdb;
this.callback = callback;
this.collector = new ResultsCollector(this.getThread.bind(this));
this.handleContinue(); // Trigger first run.
}
GetThreadsCursor.prototype = {
classID: RIL_GETTHREADSCURSOR_CID,
QueryInterface: XPCOMUtils.generateQI([Ci.nsICursorContinueCallback]),
mmdb: null,
callback: null,
collector: null,
getThreadTxn: function(txn, threadStore, threadId, collector) {
if (DEBUG) debug ("Fetching thread " + threadId);
let getRequest = threadStore.get(threadId);
getRequest.onsuccess = function(event) {
let threadRecord = event.target.result;
if (DEBUG) {
debug("notifyCursorResult: " + JSON.stringify(threadRecord));
}
let thread =
gMobileMessageService.createThread(threadRecord.id,
threadRecord.participantAddresses,
threadRecord.lastTimestamp,
threadRecord.lastMessageSubject || "",
threadRecord.body,
threadRecord.unreadCount,
threadRecord.lastMessageType);
collector.notifyResult(txn, threadId, thread);
};
getRequest.onerror = function(event) {
// Error reporting is done in ResultsCollector.notifyCallback.
event.stopPropagation();
event.preventDefault();
if (DEBUG) {
debug("notifyCursorError - threadId: " + threadId);
}
collector.notifyResult(txn, threadId, null);
};
},
getThread: function(txn, threadId, collector) {
// When filter transaction is not yet completed, we're called with current
// ongoing transaction object.
if (txn) {
let threadStore = txn.objectStore(THREAD_STORE_NAME);
this.getThreadTxn(txn, threadStore, threadId, collector);
return;
}
// Or, we have to open another transaction ourselves.
let self = this;
this.mmdb.newTxn(READ_ONLY, function(error, txn, threadStore) {
if (error) {
collector.notifyResult(null, threadId, null);
} else {
self.getThreadTxn(txn, threadStore, threadId, collector);
}
}, [THREAD_STORE_NAME]);
},
// nsICursorContinueCallback
handleContinue: function() {
if (DEBUG) debug("Getting next thread in list");
this.collector.squeeze(this.callback);
}
}
this.EXPORTED_SYMBOLS = [
'MobileMessageDB'
];
function debug() {
dump("MobileMessageDB: " + Array.slice(arguments).join(" ") + "\n");
}
Ссылка в новой задаче Показать git blame Копировать постоянную ссылку