oxen-io
/
session-android
mirror of https://github.com/oxen-io/session-android.git
1
0
Fork 0
Code Issues 1 Projects Releases Wiki Activity
session-android/src/org/thoughtcrime/securesms/database/MmsDatabase.java

1130 lines
48 KiB
Java
Raw Normal View History

Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
/**
Initial Project Import
2011-12-20 19:20:44 +01:00
* Copyright (C) 2011 Whisper Systems
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
*
Initial Project Import
2011-12-20 19:20:44 +01:00
* This program is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* This program is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
*
Initial Project Import
2011-12-20 19:20:44 +01:00
* You should have received a copy of the GNU General Public License
* along with this program. If not, see <http://www.gnu.org/licenses/>.
*/
package org.thoughtcrime.securesms.database;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
import android.content.ContentValues;
import android.content.Context;
import android.database.Cursor;
import android.database.sqlite.SQLiteDatabase;
import android.database.sqlite.SQLiteOpenHelper;
use PartDatabase to look up thumbnails async // FREEBIE Closes #2286
2014-12-30 10:36:51 +01:00
import android.graphics.Bitmap;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
import android.net.Uri;
Format-neutral compare numbers in MMS group with local device. Closes #1018
2014-03-07 22:05:35 +01:00
import android.telephony.TelephonyManager;
Split out Util functions.
2014-11-12 20:15:05 +01:00
import android.text.TextUtils;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
import android.util.Log;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
import android.util.Pair;
Initial Project Import
2011-12-20 19:20:44 +01:00
Format-neutral compare numbers in MMS group with local device. Closes #1018
2014-03-07 22:05:35 +01:00
import com.google.i18n.phonenumbers.PhoneNumberUtil;
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
import org.thoughtcrime.securesms.ApplicationContext;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
import org.thoughtcrime.securesms.R;
Beginning of libtextsecure refactor. 1) Break out appropriate components. 2) Switch the incoming pipeline from SendReceiveService to the JobManager.
2014-11-04 00:16:04 +01:00
import org.thoughtcrime.securesms.crypto.MasterCipher;
import org.thoughtcrime.securesms.crypto.MasterSecret;
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
import org.thoughtcrime.securesms.database.model.DisplayRecord;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import org.thoughtcrime.securesms.database.model.MediaMmsMessageRecord;
import org.thoughtcrime.securesms.database.model.MessageRecord;
import org.thoughtcrime.securesms.database.model.NotificationMmsMessageRecord;
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
import org.thoughtcrime.securesms.jobs.TrimThreadJob;
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
import org.thoughtcrime.securesms.mms.IncomingMediaMessage;
Split out Util functions.
2014-11-12 20:15:05 +01:00
import org.thoughtcrime.securesms.mms.OutgoingGroupMediaMessage;
import org.thoughtcrime.securesms.mms.OutgoingMediaMessage;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
import org.thoughtcrime.securesms.mms.PartParser;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import org.thoughtcrime.securesms.mms.SlideDeck;
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
import org.thoughtcrime.securesms.mms.TextSlide;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import org.thoughtcrime.securesms.recipients.Recipient;
Initial Project Import
2011-12-20 19:20:44 +01:00
import org.thoughtcrime.securesms.recipients.RecipientFactory;
import org.thoughtcrime.securesms.recipients.RecipientFormattingException;
import org.thoughtcrime.securesms.recipients.Recipients;
Split out Util functions.
2014-11-12 20:15:05 +01:00
import org.thoughtcrime.securesms.util.GroupUtil;
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
import org.thoughtcrime.securesms.util.LRUCache;
Move ListenableFutureTask up to parent.
2014-11-12 18:20:57 +01:00
import org.thoughtcrime.securesms.util.ListenableFutureTask;
Split out Util functions.
2014-11-12 20:15:05 +01:00
import org.thoughtcrime.securesms.util.TextSecurePreferences;
import org.thoughtcrime.securesms.util.Util;
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
import org.whispersystems.jobqueue.JobManager;
Split out Util functions.
2014-11-12 20:15:05 +01:00
import org.whispersystems.libaxolotl.InvalidMessageException;
import org.whispersystems.libaxolotl.util.guava.Optional;
import org.whispersystems.textsecure.api.util.InvalidNumberException;
Initial Project Import
2011-12-20 19:20:44 +01:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import java.io.UnsupportedEncodingException;
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
import java.lang.ref.SoftReference;
import java.util.Collections;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import java.util.HashSet;
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
import java.util.List;
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
import java.util.Map;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
import java.util.Set;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
import java.util.concurrent.Callable;
import java.util.concurrent.ExecutorService;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
import ws.com.google.android.mms.ContentType;
Initial Project Import
2011-12-20 19:20:44 +01:00
import ws.com.google.android.mms.InvalidHeaderValueException;
import ws.com.google.android.mms.MmsException;
import ws.com.google.android.mms.pdu.CharacterSets;
import ws.com.google.android.mms.pdu.EncodedStringValue;
import ws.com.google.android.mms.pdu.NotificationInd;
import ws.com.google.android.mms.pdu.PduBody;
import ws.com.google.android.mms.pdu.PduHeaders;
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
import ws.com.google.android.mms.pdu.PduPart;
Initial Project Import
2011-12-20 19:20:44 +01:00
import ws.com.google.android.mms.pdu.SendReq;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make delivery receipts work correctly for groups.
2014-10-21 06:06:34 +02:00
import static org.thoughtcrime.securesms.util.Util.canonicalizeNumber;
import static org.thoughtcrime.securesms.util.Util.canonicalizeNumberOrGroup;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
// XXXX Clean up MMS efficiency:
// 1) We need to be careful about how much memory we're using for parts. SoftRefereences.
// 2) How many queries do we make? calling getMediaMessageForId() from within an existing query
// seems wasteful.
Initial Project Import
2011-12-20 19:20:44 +01:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public class MmsDatabase extends Database implements MmsSmsColumns {
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public static final String TABLE_NAME = "mms";
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
static final String DATE_SENT = "date";
static final String DATE_RECEIVED = "date_received";
Initial Project Import
2011-12-20 19:20:44 +01:00
public static final String MESSAGE_BOX = "msg_box";
private static final String MESSAGE_ID = "m_id";
private static final String SUBJECT = "sub";
private static final String SUBJECT_CHARSET = "sub_cs";
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
static final String CONTENT_TYPE = "ct_t";
static final String CONTENT_LOCATION = "ct_l";
static final String EXPIRY = "exp";
Initial Project Import
2011-12-20 19:20:44 +01:00
private static final String MESSAGE_CLASS = "m_cls";
public static final String MESSAGE_TYPE = "m_type";
private static final String MMS_VERSION = "v";
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
static final String MESSAGE_SIZE = "m_size";
Initial Project Import
2011-12-20 19:20:44 +01:00
private static final String PRIORITY = "pri";
private static final String READ_REPORT = "rr";
private static final String REPORT_ALLOWED = "rpt_a";
private static final String RESPONSE_STATUS = "resp_st";
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
static final String STATUS = "st";
static final String TRANSACTION_ID = "tr_id";
Initial Project Import
2011-12-20 19:20:44 +01:00
private static final String RETRIEVE_STATUS = "retr_st";
private static final String RETRIEVE_TEXT = "retr_txt";
private static final String RETRIEVE_TEXT_CS = "retr_txt_cs";
private static final String READ_STATUS = "read_status";
private static final String CONTENT_CLASS = "ct_cls";
private static final String RESPONSE_TEXT = "resp_txt";
private static final String DELIVERY_TIME = "d_tm";
private static final String DELIVERY_REPORT = "d_rpt";
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
static final String PART_COUNT = "part_count";
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public static final String CREATE_TABLE = "CREATE TABLE " + TABLE_NAME + " (" + ID + " INTEGER PRIMARY KEY, " +
Fix for DB creation and migration with new date schema changes.
2013-01-07 03:47:20 +01:00
THREAD_ID + " INTEGER, " + DATE_SENT + " INTEGER, " + DATE_RECEIVED + " INTEGER, " + MESSAGE_BOX + " INTEGER, " +
Initial Project Import
2011-12-20 19:20:44 +01:00
READ + " INTEGER DEFAULT 0, " + MESSAGE_ID + " TEXT, " + SUBJECT + " TEXT, " +
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
SUBJECT_CHARSET + " INTEGER, " + BODY + " TEXT, " + PART_COUNT + " INTEGER, " +
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
CONTENT_TYPE + " TEXT, " + CONTENT_LOCATION + " TEXT, " + ADDRESS + " TEXT, " +
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
ADDRESS_DEVICE_ID + " INTEGER, " +
Initial Project Import
2011-12-20 19:20:44 +01:00
EXPIRY + " INTEGER, " + MESSAGE_CLASS + " TEXT, " + MESSAGE_TYPE + " INTEGER, " +
MMS_VERSION + " INTEGER, " + MESSAGE_SIZE + " INTEGER, " + PRIORITY + " INTEGER, " +
READ_REPORT + " INTEGER, " + REPORT_ALLOWED + " INTEGER, " + RESPONSE_STATUS + " INTEGER, " +
STATUS + " INTEGER, " + TRANSACTION_ID + " TEXT, " + RETRIEVE_STATUS + " INTEGER, " +
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
RETRIEVE_TEXT + " TEXT, " + RETRIEVE_TEXT_CS + " INTEGER, " + READ_STATUS + " INTEGER, " +
Initial Project Import
2011-12-20 19:20:44 +01:00
CONTENT_CLASS + " INTEGER, " + RESPONSE_TEXT + " TEXT, " + DELIVERY_TIME + " INTEGER, " +
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
RECEIPT_COUNT + " INTEGER DEFAULT 0, " + DELIVERY_REPORT + " INTEGER);";
Initial Project Import
2011-12-20 19:20:44 +01:00
Create DB indexes for optimized queries.
2012-10-30 01:41:06 +01:00
public static final String[] CREATE_INDEXS = {
"CREATE INDEX IF NOT EXISTS mms_thread_id_index ON " + TABLE_NAME + " (" + THREAD_ID + ");",
"CREATE INDEX IF NOT EXISTS mms_read_index ON " + TABLE_NAME + " (" + READ + ");",
"CREATE INDEX IF NOT EXISTS mms_read_and_thread_id_index ON " + TABLE_NAME + "(" + READ + "," + THREAD_ID + ");",
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
"CREATE INDEX IF NOT EXISTS mms_message_box_index ON " + TABLE_NAME + " (" + MESSAGE_BOX + ");",
"CREATE INDEX IF NOT EXISTS mms_date_sent_index ON " + TABLE_NAME + " (" + DATE_SENT + ");"
Create DB indexes for optimized queries.
2012-10-30 01:41:06 +01:00
};
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
private static final String[] MMS_PROJECTION = new String[] {
ID, THREAD_ID, DATE_SENT + " * 1000 AS " + NORMALIZED_DATE_SENT,
DATE_RECEIVED + " * 1000 AS " + NORMALIZED_DATE_RECEIVED,
MESSAGE_BOX, READ, MESSAGE_ID, SUBJECT, SUBJECT_CHARSET, CONTENT_TYPE,
CONTENT_LOCATION, EXPIRY, MESSAGE_CLASS, MESSAGE_TYPE, MMS_VERSION,
MESSAGE_SIZE, PRIORITY, REPORT_ALLOWED, STATUS, TRANSACTION_ID, RETRIEVE_STATUS,
RETRIEVE_TEXT, RETRIEVE_TEXT_CS, READ_STATUS, CONTENT_CLASS, RESPONSE_TEXT,
Handle identity key mismatch on outgoing group messages. Additionally, make the group creation process asynchronous.
2014-02-17 20:42:51 +01:00
DELIVERY_TIME, DELIVERY_REPORT, BODY, PART_COUNT, ADDRESS, ADDRESS_DEVICE_ID,
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
RECEIPT_COUNT
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
};
Move most of Util into library
2013-07-10 04:48:33 +02:00
public static final ExecutorService slideResolver = org.thoughtcrime.securesms.util.Util.newSingleThreadedLifoExecutor();
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
private static final Map<Long, SoftReference<SlideDeck>> slideCache =
Collections.synchronizedMap(new LRUCache<Long, SoftReference<SlideDeck>>(20));
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
private final JobManager jobManager;
Initial Project Import
2011-12-20 19:20:44 +01:00
public MmsDatabase(Context context, SQLiteOpenHelper databaseHelper) {
super(context, databaseHelper);
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
this.jobManager = ApplicationContext.getInstance(context).getJobManager();
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public int getMessageCountForThread(long threadId) {
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
SQLiteDatabase db = databaseHelper.getReadableDatabase();
Initial Project Import
2011-12-20 19:20:44 +01:00
Cursor cursor = null;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
cursor = db.query(TABLE_NAME, new String[] {"COUNT(*)"}, THREAD_ID + " = ?", new String[] {threadId+""}, null, null, null);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
if (cursor != null && cursor.moveToFirst())
return cursor.getInt(0);
} finally {
if (cursor != null)
cursor.close();
}
return 0;
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
public void incrementDeliveryReceiptCount(String address, long timestamp) {
MmsAddressDatabase addressDatabase = DatabaseFactory.getMmsAddressDatabase(context);
SQLiteDatabase database = databaseHelper.getWritableDatabase();
Cursor cursor = null;
try {
Make delivery receipts work correctly for groups.
2014-10-21 06:06:34 +02:00
cursor = database.query(TABLE_NAME, new String[] {ID, THREAD_ID, MESSAGE_BOX}, DATE_SENT + " = ?", new String[] {String.valueOf(timestamp / 1000)}, null, null, null, null);
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
while (cursor.moveToNext()) {
Make delivery receipts work correctly for groups.
2014-10-21 06:06:34 +02:00
if (Types.isOutgoingMessageType(cursor.getLong(cursor.getColumnIndexOrThrow(MESSAGE_BOX)))) {
List<String> addresses = addressDatabase.getAddressesForId(cursor.getLong(cursor.getColumnIndexOrThrow(ID)));
for (String storedAddress : addresses) {
try {
String ourAddress = canonicalizeNumber(context, address);
String theirAddress = canonicalizeNumberOrGroup(context, storedAddress);
if (ourAddress.equals(theirAddress) || GroupUtil.isEncodedGroup(theirAddress)) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(ID));
long threadId = cursor.getLong(cursor.getColumnIndexOrThrow(THREAD_ID));
database.execSQL("UPDATE " + TABLE_NAME + " SET " +
RECEIPT_COUNT + " = " + RECEIPT_COUNT + " + 1 WHERE " + ID + " = ?",
new String[] {String.valueOf(id)});
notifyConversationListeners(threadId);
}
} catch (InvalidNumberException e) {
Log.w("MmsDatabase", e);
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
}
}
}
}
} finally {
if (cursor != null)
cursor.close();
}
}
Initial Project Import
2011-12-20 19:20:44 +01:00
public long getThreadIdForMessage(long id) {
String sql = "SELECT " + THREAD_ID + " FROM " + TABLE_NAME + " WHERE " + ID + " = ?";
String[] sqlArgs = new String[] {id+""};
SQLiteDatabase db = databaseHelper.getReadableDatabase();
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
Cursor cursor = null;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
cursor = db.rawQuery(sql, sqlArgs);
if (cursor != null && cursor.moveToFirst())
return cursor.getLong(0);
else
return -1;
} finally {
if (cursor != null)
cursor.close();
}
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Prevent NPE when MMS's FROM PduHeader is missing Fixes #1448 // FREEBIE
2015-02-16 06:53:59 +01:00
private long getThreadIdFor(IncomingMediaMessage retrieved) throws RecipientFormattingException, MmsException {
wip
2014-01-14 09:26:43 +01:00
if (retrieved.getGroupId() != null) {
Display group actions and correctly handle group delivery.
2014-02-15 00:59:57 +01:00
Recipients groupRecipients = RecipientFactory.getRecipientsFromString(context, retrieved.getGroupId(), true);
return DatabaseFactory.getThreadDatabase(context).getThreadIdFor(groupRecipients);
wip
2014-01-14 09:26:43 +01:00
}
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
PduHeaders headers = retrieved.getPduHeaders();
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
Set<String> group = new HashSet<String>();
wip
2014-01-14 09:26:43 +01:00
EncodedStringValue encodedFrom = headers.getEncodedStringValue(PduHeaders.FROM);
EncodedStringValue[] encodedCcList = headers.getEncodedStringValues(PduHeaders.CC);
EncodedStringValue[] encodedToList = headers.getEncodedStringValues(PduHeaders.TO);
Prevent NPE when MMS's FROM PduHeader is missing Fixes #1448 // FREEBIE
2015-02-16 06:53:59 +01:00
if (encodedFrom == null) {
throw new MmsException("FROM value in PduHeaders did not exist.");
}
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
group.add(new String(encodedFrom.getTextString(), CharacterSets.MIMENAME_ISO_8859_1));
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
TelephonyManager telephonyManager = (TelephonyManager) context.getSystemService(Context.TELEPHONY_SERVICE);
String localNumber = telephonyManager.getLine1Number();
if (localNumber == null) {
localNumber = TextSecurePreferences.getLocalNumber(context);
}
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
if (encodedCcList != null) {
for (EncodedStringValue encodedCc : encodedCcList) {
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
String cc = new String(encodedCc.getTextString(), CharacterSets.MIMENAME_ISO_8859_1);
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
PhoneNumberUtil.MatchType match;
wip
2014-01-14 09:26:43 +01:00
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
if (localNumber == null) match = PhoneNumberUtil.MatchType.NO_MATCH;
else match = PhoneNumberUtil.getInstance().isNumberMatch(localNumber, cc);
if (match == PhoneNumberUtil.MatchType.NO_MATCH ||
match == PhoneNumberUtil.MatchType.NOT_A_NUMBER)
{
group.add(cc);
}
Fix for MMS decoding when no SIM is available.
2014-02-21 02:32:01 +01:00
}
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
}
Fix for MMS decoding when no SIM is available.
2014-02-21 02:32:01 +01:00
Also check cc for duplicates
2014-03-13 01:45:21 +01:00
if (encodedToList != null && (encodedToList.length > 1 || group.size() > 1)) {
wip
2014-01-14 09:26:43 +01:00
for (EncodedStringValue encodedTo : encodedToList) {
String to = new String(encodedTo.getTextString(), CharacterSets.MIMENAME_ISO_8859_1);
Format-neutral compare numbers in MMS group with local device. Closes #1018
2014-03-07 22:05:35 +01:00
PhoneNumberUtil.MatchType match;
if (localNumber == null) match = PhoneNumberUtil.MatchType.NO_MATCH;
else match = PhoneNumberUtil.getInstance().isNumberMatch(localNumber, to);
if (match == PhoneNumberUtil.MatchType.NO_MATCH ||
match == PhoneNumberUtil.MatchType.NOT_A_NUMBER)
{
wip
2014-01-14 09:26:43 +01:00
group.add(to);
}
}
}
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
String recipientsList = Util.join(group, ",");
Recipients recipients = RecipientFactory.getRecipientsFromString(context, recipientsList, false);
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
return DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipients);
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
}
private long getThreadIdFor(NotificationInd notification) throws RecipientFormattingException {
try {
EncodedStringValue encodedString = notification.getFrom();
Initial Project Import
2011-12-20 19:20:44 +01:00
String fromString = new String(encodedString.getTextString(), CharacterSets.MIMENAME_ISO_8859_1);
Refactor recipient access. 1) Refactor recipient class to support asynchronous loading operations. 2) Refactor recipient factory to simplify recipient access. 3) Consoliate everything into one recipient provider that is capable of doing async lookups and intelligent caching.
2012-12-24 17:40:37 +01:00
Recipients recipients = RecipientFactory.getRecipientsFromString(context, fromString, false);
Initial Project Import
2011-12-20 19:20:44 +01:00
return DatabaseFactory.getThreadDatabase(context).getThreadIdFor(recipients);
} catch (UnsupportedEncodingException e) {
throw new AssertionError(e);
}
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public void updateResponseStatus(long messageId, int status) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(RESPONSE_STATUS, status);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
database.update(TABLE_NAME, contentValues, ID_WHERE, new String[] {messageId + ""});
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
private void updateMailboxBitmask(long id, long maskOff, long maskOn) {
SQLiteDatabase db = databaseHelper.getWritableDatabase();
db.execSQL("UPDATE " + TABLE_NAME +
" SET " + MESSAGE_BOX + " = (" + MESSAGE_BOX + " & " + (Types.TOTAL_MASK - maskOff) + " | " + maskOn + " )" +
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
" WHERE " + ID + " = ?", new String[] {id + ""});
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Correct retry logic for SMS JB+ and for push groups.
2014-02-16 03:31:25 +01:00
public void markAsOutbox(long messageId) {
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_OUTBOX_TYPE);
notifyConversationListeners(getThreadIdForMessage(messageId));
more precise sms controls // FREEBIE
2014-03-01 23:17:55 +01:00
}
mark auto-fallback to sms as forcedSms // FREEBIE
2014-04-04 01:20:23 +02:00
public void markAsForcedSms(long messageId) {
updateMailboxBitmask(messageId, 0, Types.MESSAGE_FORCE_SMS_BIT);
notifyConversationListeners(getThreadIdForMessage(messageId));
more precise sms controls // FREEBIE
2014-03-01 23:17:55 +01:00
}
UX for unencrypted fallback case
2014-04-01 03:47:24 +02:00
public void markAsPendingSecureSmsFallback(long messageId) {
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_PENDING_SECURE_SMS_FALLBACK);
notifyConversationListeners(getThreadIdForMessage(messageId));
}
public void markAsPendingInsecureSmsFallback(long messageId) {
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_PENDING_INSECURE_SMS_FALLBACK);
more precise sms controls // FREEBIE
2014-03-01 23:17:55 +01:00
notifyConversationListeners(getThreadIdForMessage(messageId));
Correct retry logic for SMS JB+ and for push groups.
2014-02-16 03:31:25 +01:00
}
Allow to resend a failed message Add an option to the context menu of the message to resend it if it has failed.
2013-10-13 12:53:41 +02:00
public void markAsSending(long messageId) {
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_SENDING_TYPE);
notifyConversationListeners(getThreadIdForMessage(messageId));
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public void markAsSentFailed(long messageId) {
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_SENT_FAILED_TYPE);
Initial Project Import
2011-12-20 19:20:44 +01:00
notifyConversationListeners(getThreadIdForMessage(messageId));
}
Refactor MMS send/download to be synchronous. 1) Make the radio change a synchronous action with a timeout. 2) Move the send logic into an MmsTransport, in preparation for UniversalTransport composition. 3) Move the download logic into a synchronous receiver.
2013-07-17 04:52:02 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public void markAsSent(long messageId, byte[] mmsId, long status) {
Initial Project Import
2011-12-20 19:20:44 +01:00
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(RESPONSE_STATUS, status);
contentValues.put(MESSAGE_ID, new String(mmsId));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
database.update(TABLE_NAME, contentValues, ID_WHERE, new String[] {messageId+""});
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
updateMailboxBitmask(messageId, Types.BASE_TYPE_MASK, Types.BASE_SENT_TYPE);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
notifyConversationListeners(getThreadIdForMessage(messageId));
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public void markDownloadState(long messageId, long state) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(STATUS, state);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
database.update(TABLE_NAME, contentValues, ID_WHERE, new String[] {messageId + ""});
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
notifyConversationListeners(getThreadIdForMessage(messageId));
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Indicate a message was delivered via push in its delivery status.
2014-02-21 01:14:58 +01:00
public void markDeliveryStatus(long messageId, int status) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(STATUS, status);
database.update(TABLE_NAME, contentValues, ID_WHERE, new String[] {messageId + ""});
notifyConversationListeners(getThreadIdForMessage(messageId));
}
Initial Project Import
2011-12-20 19:20:44 +01:00
public void markAsNoSession(long messageId, long threadId) {
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
updateMailboxBitmask(messageId, Types.ENCRYPTION_MASK, Types.ENCRYPTION_REMOTE_NO_SESSION_BIT);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
notifyConversationListeners(threadId);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Correctly update MMS security status.
2013-11-19 19:13:24 +01:00
public void markAsSecure(long messageId) {
updateMailboxBitmask(messageId, 0, Types.SECURE_MESSAGE_BIT);
}
UX for unencrypted fallback case
2014-04-01 03:47:24 +02:00
public void markAsInsecure(long messageId) {
updateMailboxBitmask(messageId, Types.SECURE_MESSAGE_BIT, 0);
}
Make 'push' status a type bit on both incoming and outgoing msgs.
2014-02-21 08:00:38 +01:00
public void markAsPush(long messageId) {
updateMailboxBitmask(messageId, 0, Types.PUSH_MESSAGE_BIT);
}
Initial Project Import
2011-12-20 19:20:44 +01:00
public void markAsDecryptFailed(long messageId, long threadId) {
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
updateMailboxBitmask(messageId, Types.ENCRYPTION_MASK, Types.ENCRYPTION_REMOTE_FAILED_BIT);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
notifyConversationListeners(threadId);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Don't display duplicate push messages.
2014-03-19 20:37:46 +01:00
public void markAsDecryptDuplicate(long messageId, long threadId) {
updateMailboxBitmask(messageId, Types.ENCRYPTION_MASK, Types.ENCRYPTION_REMOTE_DUPLICATE_BIT);
notifyConversationListeners(threadId);
}
Remove V1 code.
2014-04-10 05:02:46 +02:00
public void markAsLegacyVersion(long messageId, long threadId) {
Display legacy message error when V1 message is received.
2014-04-11 00:20:43 +02:00
updateMailboxBitmask(messageId, Types.ENCRYPTION_MASK, Types.ENCRYPTION_REMOTE_LEGACY_BIT);
Remove V1 code.
2014-04-10 05:02:46 +02:00
notifyConversationListeners(threadId);
}
Initial Project Import
2011-12-20 19:20:44 +01:00
public void setMessagesRead(long threadId) {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(READ, 1);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
database.update(TABLE_NAME, contentValues, THREAD_ID + " = ?", new String[] {threadId + ""});
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Add 'mark all as read' option
2013-05-06 22:59:40 +02:00
public void setAllMessagesRead() {
SQLiteDatabase database = databaseHelper.getWritableDatabase();
ContentValues contentValues = new ContentValues();
contentValues.put(READ, 1);
database.update(TABLE_NAME, contentValues, null, null);
}
Beginning of libtextsecure refactor. 1) Break out appropriate components. 2) Switch the incoming pipeline from SendReceiveService to the JobManager.
2014-11-04 00:16:04 +01:00
public Optional<NotificationInd> getNotification(long messageId) {
SQLiteDatabase db = databaseHelper.getReadableDatabase();
MmsAddressDatabase addressDatabase = DatabaseFactory.getMmsAddressDatabase(context);
Cursor cursor = null;
try {
cursor = db.query(TABLE_NAME, MMS_PROJECTION, ID_WHERE, new String[] {String.valueOf(messageId)}, null, null, null);
if (cursor != null && cursor.moveToNext()) {
PduHeaders headers = getHeadersFromCursor(cursor);
addressDatabase.getAddressesForId(messageId, headers);
return Optional.of(new NotificationInd(headers));
} else {
return Optional.absent();
}
} catch (InvalidHeaderValueException e) {
Log.w("MmsDatabase", e);
return Optional.absent();
} finally {
if (cursor != null)
cursor.close();
}
}
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
public SendReq getOutgoingMessage(MasterSecret masterSecret, long messageId)
throws MmsException, NoSuchMessageException
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
{
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
MmsAddressDatabase addr = DatabaseFactory.getMmsAddressDatabase(context);
streaming media // FREEBIE
2014-12-12 10:03:24 +01:00
PartDatabase partDatabase = DatabaseFactory.getPartDatabase(context);
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
SQLiteDatabase database = databaseHelper.getReadableDatabase();
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
MasterCipher masterCipher = new MasterCipher(masterSecret);
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
Cursor cursor = null;
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
String selection = ID_WHERE;
String[] selectionArgs = new String[]{String.valueOf(messageId)};
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
cursor = database.query(TABLE_NAME, MMS_PROJECTION, selection, selectionArgs, null, null, null);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
if (cursor != null && cursor.moveToNext()) {
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
long outboxType = cursor.getLong(cursor.getColumnIndexOrThrow(MESSAGE_BOX));
String messageText = cursor.getString(cursor.getColumnIndexOrThrow(BODY));
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
long timestamp = cursor.getLong(cursor.getColumnIndexOrThrow(NORMALIZED_DATE_SENT));
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
PduHeaders headers = getHeadersFromCursor(cursor);
Removed tabs
2012-10-01 04:56:29 +02:00
addr.getAddressesForId(messageId, headers);
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
streaming media // FREEBIE
2014-12-12 10:03:24 +01:00
PduBody body = getPartsAsBody(partDatabase.getParts(messageId));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
try {
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (!TextUtils.isEmpty(messageText) && Types.isSymmetricEncryption(outboxType)) {
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
body.addPart(new TextSlide(context, masterCipher.decryptBody(messageText)).getPart());
Split out Util functions.
2014-11-12 20:15:05 +01:00
} else if (!TextUtils.isEmpty(messageText)) {
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
body.addPart(new TextSlide(context, messageText).getPart());
}
} catch (InvalidMessageException e) {
Log.w("MmsDatabase", e);
}
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
return new SendReq(headers, body, messageId, outboxType, timestamp);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
throw new NoSuchMessageException("No record found for id: " + messageId);
Initial Project Import
2011-12-20 19:20:44 +01:00
} finally {
if (cursor != null)
cursor.close();
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
}
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Enhanced MMS configuration prompts and processing. 1) Added a new message status to MmsDatabase to signify a pending MMS download which requires APN settings. 2) Added a database method to query MMS messages based on status. 3) Added login to SendReceiveService for processing of MMS pending APN information. 4) Moved all APN/MMS settings into ApnPreferencesActivity and transformed PromptApnActivity into a simple informational activity. 5) Added logic to check for APN settings on send and receive of all MMS (media, group, email) and direct user to PromptApnActivity then ApnPreferencesActivity if necessary. 6) Vocab/grammar adjustments.
2013-09-16 09:55:01 +02:00
public Reader getNotificationsWithDownloadState(MasterSecret masterSecret, long state) {
SQLiteDatabase database = databaseHelper.getReadableDatabase();
String selection = STATUS + " = ?";
String[] selectionArgs = new String[]{state + ""};
Cursor cursor = database.query(TABLE_NAME, MMS_PROJECTION, selection, selectionArgs, null, null, null);
return new Reader(masterSecret, cursor);
}
Short circuit self-send. // FREEBIE
2014-10-23 03:28:03 +02:00
public long copyMessageInbox(MasterSecret masterSecret, long messageId) throws MmsException {
Transition the outbound pipeline to JobManager jobs.
2014-11-08 20:35:58 +01:00
try {
SendReq request = getOutgoingMessage(masterSecret, messageId);
ContentValues contentValues = getContentValuesFromHeader(request.getPduHeaders());
contentValues.put(MESSAGE_BOX, Types.BASE_INBOX_TYPE | Types.SECURE_MESSAGE_BIT | Types.ENCRYPTION_SYMMETRIC_BIT);
contentValues.put(THREAD_ID, getThreadIdForMessage(messageId));
contentValues.put(READ, 1);
contentValues.put(DATE_RECEIVED, contentValues.getAsLong(DATE_SENT));
return insertMediaMessage(masterSecret, request.getPduHeaders(),
request.getBody(), contentValues);
} catch (NoSuchMessageException e) {
throw new MmsException(e);
}
Short circuit self-send. // FREEBIE
2014-10-23 03:28:03 +02:00
}
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
private Pair<Long, Long> insertMessageInbox(MasterSecret masterSecret, IncomingMediaMessage retrieved,
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
String contentLocation, long threadId, long mailbox)
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
throws MmsException
{
Change the way notifications work for non-default KitKat. Messages that are not "secure" (encrypted or key exchange) are automatically marked as read if TextSecure isn't the default KitKat SMS app. This change in functionality allows people who aren't using TextSecure as a default SMS app on KitKat to still receive notifications when they get incoming encrypted messages.
2013-12-07 20:00:20 +01:00
PduHeaders headers = retrieved.getPduHeaders();
Initial Project Import
2011-12-20 19:20:44 +01:00
ContentValues contentValues = getContentValuesFromHeader(headers);
Fix rebase errors
2014-01-07 03:52:18 +01:00
boolean unread = org.thoughtcrime.securesms.util.Util.isDefaultSmsProvider(context) ||
((mailbox & Types.SECURE_MESSAGE_BIT) != 0);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
if (threadId == -1 || retrieved.isGroupMessage()) {
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
try {
threadId = getThreadIdFor(retrieved);
} catch (RecipientFormattingException e) {
Log.w("MmsDatabase", e);
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
if (threadId == -1)
throw new MmsException(e);
First cut at group messaging refactor.
2013-04-26 03:59:49 +02:00
}
}
Initial Project Import
2011-12-20 19:20:44 +01:00
contentValues.put(MESSAGE_BOX, mailbox);
contentValues.put(THREAD_ID, threadId);
contentValues.put(CONTENT_LOCATION, contentLocation);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
contentValues.put(STATUS, Status.DOWNLOAD_INITIALIZED);
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
contentValues.put(DATE_RECEIVED, System.currentTimeMillis() / 1000);
Change the way notifications work for non-default KitKat. Messages that are not "secure" (encrypted or key exchange) are automatically marked as read if TextSecure isn't the default KitKat SMS app. This change in functionality allows people who aren't using TextSecure as a default SMS app on KitKat to still receive notifications when they get incoming encrypted messages.
2013-12-07 20:00:20 +01:00
contentValues.put(READ, unread ? 0 : 1);
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
if (!contentValues.containsKey(DATE_SENT)) {
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
contentValues.put(DATE_SENT, contentValues.getAsLong(DATE_RECEIVED));
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
long messageId = insertMediaMessage(masterSecret, retrieved.getPduHeaders(),
retrieved.getBody(), contentValues);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
Change the way notifications work for non-default KitKat. Messages that are not "secure" (encrypted or key exchange) are automatically marked as read if TextSecure isn't the default KitKat SMS app. This change in functionality allows people who aren't using TextSecure as a default SMS app on KitKat to still receive notifications when they get incoming encrypted messages.
2013-12-07 20:00:20 +01:00
if (unread) {
DatabaseFactory.getThreadDatabase(context).setUnread(threadId);
}
Fixed group in-thread notifications
2013-05-05 22:14:23 +02:00
DatabaseFactory.getThreadDatabase(context).update(threadId);
notifyConversationListeners(threadId);
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
jobManager.add(new TrimThreadJob(context, threadId));
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
return new Pair<>(messageId, threadId);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
public Pair<Long, Long> insertMessageInbox(MasterSecret masterSecret,
IncomingMediaMessage retrieved,
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
String contentLocation, long threadId)
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
throws MmsException
{
return insertMessageInbox(masterSecret, retrieved, contentLocation, threadId,
Make 'push' status a type bit on both incoming and outgoing msgs.
2014-02-21 08:00:38 +01:00
Types.BASE_INBOX_TYPE | Types.ENCRYPTION_SYMMETRIC_BIT |
(retrieved.isPushMessage() ? Types.PUSH_MESSAGE_BIT : 0));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
}
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
public Pair<Long, Long> insertSecureMessageInbox(MasterSecret masterSecret,
IncomingMediaMessage retrieved,
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
String contentLocation, long threadId)
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
throws MmsException
{
return insertMessageInbox(masterSecret, retrieved, contentLocation, threadId,
Make 'push' status a type bit on both incoming and outgoing msgs.
2014-02-21 08:00:38 +01:00
Types.BASE_INBOX_TYPE | Types.SECURE_MESSAGE_BIT |
Types.ENCRYPTION_REMOTE_BIT);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
public Pair<Long, Long> insertSecureDecryptedMessageInbox(MasterSecret masterSecret,
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
IncomingMediaMessage retrieved,
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
long threadId)
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
throws MmsException
{
return insertMessageInbox(masterSecret, retrieved, "", threadId,
Make 'push' status a type bit on both incoming and outgoing msgs.
2014-02-21 08:00:38 +01:00
Types.BASE_INBOX_TYPE | Types.SECURE_MESSAGE_BIT |
Types.ENCRYPTION_SYMMETRIC_BIT |
(retrieved.isPushMessage() ? Types.PUSH_MESSAGE_BIT : 0));
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
public Pair<Long, Long> insertMessageInbox(NotificationInd notification) {
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
SQLiteDatabase db = databaseHelper.getWritableDatabase();
Initial Project Import
2011-12-20 19:20:44 +01:00
MmsAddressDatabase addressDatabase = DatabaseFactory.getMmsAddressDatabase(context);
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
long threadId = getThreadIdFor(notification);
PduHeaders headers = notification.getPduHeaders();
ContentValues contentValues = getContentValuesFromHeader(headers);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
Log.w("MmsDatabse", "Message received type: " + headers.getOctet(PduHeaders.MESSAGE_TYPE));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
contentValues.put(MESSAGE_BOX, Types.BASE_INBOX_TYPE);
Initial Project Import
2011-12-20 19:20:44 +01:00
contentValues.put(THREAD_ID, threadId);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
contentValues.put(STATUS, Status.DOWNLOAD_INITIALIZED);
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
contentValues.put(DATE_RECEIVED, System.currentTimeMillis() / 1000);
Fix rebase errors
2014-01-07 03:52:18 +01:00
contentValues.put(READ, org.thoughtcrime.securesms.util.Util.isDefaultSmsProvider(context) ? 0 : 1);
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
if (!contentValues.containsKey(DATE_SENT))
contentValues.put(DATE_SENT, contentValues.getAsLong(DATE_RECEIVED));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
long messageId = db.insert(TABLE_NAME, null, contentValues);
Initial Project Import
2011-12-20 19:20:44 +01:00
addressDatabase.insertAddressesForId(messageId, headers);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
// notifyConversationListeners(threadId);
// DatabaseFactory.getThreadDatabase(context).update(threadId);
// DatabaseFactory.getThreadDatabase(context).setUnread(threadId);
// Trimmer.trimThread(context, threadId);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
return new Pair<Long, Long>(messageId, threadId);
Initial Project Import
2011-12-20 19:20:44 +01:00
} catch (RecipientFormattingException rfe) {
Log.w("MmsDatabase", rfe);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
return new Pair<Long, Long>(-1L, -1L);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
public void markIncomingNotificationReceived(long threadId) {
notifyConversationListeners(threadId);
DatabaseFactory.getThreadDatabase(context).update(threadId);
Change the way notifications work for non-default KitKat. Messages that are not "secure" (encrypted or key exchange) are automatically marked as read if TextSecure isn't the default KitKat SMS app. This change in functionality allows people who aren't using TextSecure as a default SMS app on KitKat to still receive notifications when they get incoming encrypted messages.
2013-12-07 20:00:20 +01:00
Fix rebase errors
2014-01-07 03:52:18 +01:00
if (org.thoughtcrime.securesms.util.Util.isDefaultSmsProvider(context)) {
Change the way notifications work for non-default KitKat. Messages that are not "secure" (encrypted or key exchange) are automatically marked as read if TextSecure isn't the default KitKat SMS app. This change in functionality allows people who aren't using TextSecure as a default SMS app on KitKat to still receive notifications when they get incoming encrypted messages.
2013-12-07 20:00:20 +01:00
DatabaseFactory.getThreadDatabase(context).setUnread(threadId);
}
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
jobManager.add(new TrimThreadJob(context, threadId));
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
}
Add correct contextual menu options on 'Send' button. [Send TextSecure message | Send unencrypted SMS | Send encrypted SMS] // FREEBIE
2014-06-12 00:31:59 +02:00
public long insertMessageOutbox(MasterSecret masterSecret, OutgoingMediaMessage message,
long threadId, boolean forceSms)
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
throws MmsException
{
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
long type = Types.BASE_OUTBOX_TYPE | Types.ENCRYPTION_SYMMETRIC_BIT;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Add correct contextual menu options on 'Send' button. [Send TextSecure message | Send unencrypted SMS | Send encrypted SMS] // FREEBIE
2014-06-12 00:31:59 +02:00
if (message.isSecure()) type |= Types.SECURE_MESSAGE_BIT;
if (forceSms) type |= Types.MESSAGE_FORCE_SMS_BIT;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
if (message.isGroup()) {
Refactor group messaging protocol. // FREEBIE
2014-02-22 02:51:25 +01:00
if (((OutgoingGroupMediaMessage)message).isGroupUpdate()) type |= Types.GROUP_UPDATE_BIT;
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
else if (((OutgoingGroupMediaMessage)message).isGroupQuit()) type |= Types.GROUP_QUIT_BIT;
}
SendReq sendRequest = new SendReq();
sendRequest.setDate(System.currentTimeMillis() / 1000L);
sendRequest.setBody(message.getPduBody());
sendRequest.setContentType(ContentType.MULTIPART_MIXED.getBytes());
String[] recipientsArray = message.getRecipients().toNumberStringArray(true);
EncodedStringValue[] encodedNumbers = EncodedStringValue.encodeStrings(recipientsArray);
if (message.getRecipients().isSingleRecipient()) {
sendRequest.setTo(encodedNumbers);
} else if (message.getDistributionType() == ThreadDatabase.DistributionTypes.BROADCAST) {
sendRequest.setBcc(encodedNumbers);
} else if (message.getDistributionType() == ThreadDatabase.DistributionTypes.CONVERSATION ||
message.getDistributionType() == 0)
{
sendRequest.setTo(encodedNumbers);
}
PduHeaders headers = sendRequest.getPduHeaders();
ContentValues contentValues = getContentValuesFromHeader(headers);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
contentValues.put(MESSAGE_BOX, type);
Initial Project Import
2011-12-20 19:20:44 +01:00
contentValues.put(THREAD_ID, threadId);
contentValues.put(READ, 1);
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
contentValues.put(DATE_RECEIVED, contentValues.getAsLong(DATE_SENT));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
contentValues.remove(ADDRESS);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
long messageId = insertMediaMessage(masterSecret, sendRequest.getPduHeaders(),
sendRequest.getBody(), contentValues);
Do thread trimming as JobManager job rather than AsyncTask. // FREEBIE
2014-11-25 07:50:32 +01:00
jobManager.add(new TrimThreadJob(context, threadId));
Support for auto-deleting old messages beyond a certain conversation thread length.
2013-01-10 06:06:56 +01:00
Initial Project Import
2011-12-20 19:20:44 +01:00
return messageId;
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
private long insertMediaMessage(MasterSecret masterSecret,
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
PduHeaders headers,
PduBody body,
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
ContentValues contentValues)
throws MmsException
{
streaming media // FREEBIE
2014-12-12 10:03:24 +01:00
SQLiteDatabase db = databaseHelper.getWritableDatabase();
PartDatabase partsDatabase = DatabaseFactory.getPartDatabase(context);
Initial Project Import
2011-12-20 19:20:44 +01:00
MmsAddressDatabase addressDatabase = DatabaseFactory.getMmsAddressDatabase(context);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
if (Types.isSymmetricEncryption(contentValues.getAsLong(MESSAGE_BOX))) {
String messageText = PartParser.getMessageText(body);
use PartDatabase to look up thumbnails async // FREEBIE Closes #2286
2014-12-30 10:36:51 +01:00
body = PartParser.getSupportedMediaParts(body);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (!TextUtils.isEmpty(messageText)) {
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
contentValues.put(BODY, new MasterCipher(masterSecret).encryptBody(messageText));
}
}
use PartDatabase to look up thumbnails async // FREEBIE Closes #2286
2014-12-30 10:36:51 +01:00
contentValues.put(PART_COUNT, PartParser.getSupportedMediaPartCount(body));
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
long messageId = db.insert(TABLE_NAME, null, contentValues);
Initial Project Import
2011-12-20 19:20:44 +01:00
Support for incoming attachments. 1) Refactored MMS layer to use abstracted types. 2) Added support for retrieving attachment IDs.
2013-07-19 02:42:45 +02:00
addressDatabase.insertAddressesForId(messageId, headers);
streaming media // FREEBIE
2014-12-12 10:03:24 +01:00
partsDatabase.insertParts(masterSecret, messageId, body);
Initial Project Import
2011-12-20 19:20:44 +01:00
notifyConversationListeners(contentValues.getAsLong(THREAD_ID));
DatabaseFactory.getThreadDatabase(context).update(contentValues.getAsLong(THREAD_ID));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
return messageId;
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public void delete(long messageId) {
long threadId = getThreadIdForMessage(messageId);
MmsAddressDatabase addrDatabase = DatabaseFactory.getMmsAddressDatabase(context);
PartDatabase partDatabase = DatabaseFactory.getPartDatabase(context);
partDatabase.deleteParts(messageId);
addrDatabase.deleteAddressesForId(messageId);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
SQLiteDatabase database = databaseHelper.getWritableDatabase();
database.delete(TABLE_NAME, ID_WHERE, new String[] {messageId+""});
DatabaseFactory.getThreadDatabase(context).update(threadId);
notifyConversationListeners(threadId);
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
public void deleteThread(long threadId) {
Set<Long> singleThreadSet = new HashSet<Long>();
singleThreadSet.add(threadId);
deleteThreads(singleThreadSet);
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
/*package*/ void deleteThreads(Set<Long> threadIds) {
SQLiteDatabase db = databaseHelper.getWritableDatabase();
String where = "";
Cursor cursor = null;
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
for (long threadId : threadIds) {
where += THREAD_ID + " = '" + threadId + "' OR ";
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
where = where.substring(0, where.length() - 4);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
try {
cursor = db.query(TABLE_NAME, new String[] {ID}, where, null, null, null, null);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
while (cursor != null && cursor.moveToNext()) {
delete(cursor.getLong(0));
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
} finally {
if (cursor != null)
cursor.close();
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
}
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Support for auto-deleting old messages beyond a certain conversation thread length.
2013-01-10 06:06:56 +01:00
/*package*/void deleteMessagesInThreadBeforeDate(long threadId, long date) {
date = date / 1000;
Cursor cursor = null;
try {
SQLiteDatabase db = databaseHelper.getReadableDatabase();
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
String where = THREAD_ID + " = ? AND (CASE (" + MESSAGE_BOX + " & " + Types.BASE_TYPE_MASK + ") ";
Support for auto-deleting old messages beyond a certain conversation thread length.
2013-01-10 06:06:56 +01:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
for (long outgoingType : Types.OUTGOING_MESSAGE_TYPES) {
Support for auto-deleting old messages beyond a certain conversation thread length.
2013-01-10 06:06:56 +01:00
where += " WHEN " + outgoingType + " THEN " + DATE_SENT + " < " + date;
}
where += (" ELSE " + DATE_RECEIVED + " < " + date + " END)");
Log.w("MmsDatabase", "Executing trim query: " + where);
cursor = db.query(TABLE_NAME, new String[] {ID}, where, new String[] {threadId+""}, null, null, null);
while (cursor != null && cursor.moveToNext()) {
Log.w("MmsDatabase", "Trimming: " + cursor.getLong(0));
delete(cursor.getLong(0));
}
} finally {
if (cursor != null)
cursor.close();
}
}
Initial Project Import
2011-12-20 19:20:44 +01:00
public void deleteAllThreads() {
DatabaseFactory.getPartDatabase(context).deleteAllParts();
DatabaseFactory.getMmsAddressDatabase(context).deleteAllAddresses();
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
SQLiteDatabase database = databaseHelper.getWritableDatabase();
database.delete(TABLE_NAME, null, null);
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial fixes for MMS retrieval. 1) Parse the APN information based on what the ConnectionManager tells us. 2) Accept email addresses as a valid Recipient format.
2012-09-30 20:46:45 +02:00
public Cursor getCarrierMmsInformation(String apn) {
We need READ_CALL_LOG if targetSDK is > 15. What a drag.
2012-11-21 04:09:46 +01:00
Uri uri = Uri.withAppendedPath(Uri.parse("content://telephony/carriers"), "current");
Split out Util functions.
2014-11-12 20:15:05 +01:00
String selection = TextUtils.isEmpty(apn) ? null : "apn = ?";
String[] selectionArgs = TextUtils.isEmpty(apn) ? null : new String[] {apn.trim()};
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Catch NPE thrown by APN provider.
2013-03-17 19:19:36 +01:00
try {
return context.getContentResolver().query(uri, null, selection, selectionArgs, null);
} catch (NullPointerException npe) {
// NOTE - This is dumb, but on some devices there's an NPE in the Android framework
// for the provider of this call, which gets rethrown back to here through a binder
// call.
throw new IllegalArgumentException(npe);
}
Initial Project Import
2011-12-20 19:20:44 +01:00
}
private PduHeaders getHeadersFromCursor(Cursor cursor) throws InvalidHeaderValueException {
PduHeaders headers = new PduHeaders();
PduHeadersBuilder phb = new PduHeadersBuilder(headers, cursor);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
phb.add(RETRIEVE_TEXT, RETRIEVE_TEXT_CS, PduHeaders.RETRIEVE_TEXT);
phb.add(SUBJECT, SUBJECT_CHARSET, PduHeaders.SUBJECT);
phb.addText(CONTENT_LOCATION, PduHeaders.CONTENT_LOCATION);
phb.addText(CONTENT_TYPE, PduHeaders.CONTENT_TYPE);
phb.addText(MESSAGE_CLASS, PduHeaders.MESSAGE_CLASS);
phb.addText(MESSAGE_ID, PduHeaders.MESSAGE_ID);
phb.addText(RESPONSE_TEXT, PduHeaders.RESPONSE_TEXT);
phb.addText(TRANSACTION_ID, PduHeaders.TRANSACTION_ID);
phb.addOctet(CONTENT_CLASS, PduHeaders.CONTENT_CLASS);
phb.addOctet(DELIVERY_REPORT, PduHeaders.DELIVERY_REPORT);
phb.addOctet(MESSAGE_TYPE, PduHeaders.MESSAGE_TYPE);
phb.addOctet(MMS_VERSION, PduHeaders.MMS_VERSION);
phb.addOctet(PRIORITY, PduHeaders.PRIORITY);
phb.addOctet(READ_STATUS, PduHeaders.READ_STATUS);
phb.addOctet(REPORT_ALLOWED, PduHeaders.REPORT_ALLOWED);
phb.addOctet(RETRIEVE_STATUS, PduHeaders.RETRIEVE_STATUS);
phb.addOctet(STATUS, PduHeaders.STATUS);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
phb.addLong(NORMALIZED_DATE_SENT, PduHeaders.DATE);
Initial Project Import
2011-12-20 19:20:44 +01:00
phb.addLong(DELIVERY_TIME, PduHeaders.DELIVERY_TIME);
phb.addLong(EXPIRY, PduHeaders.EXPIRY);
phb.addLong(MESSAGE_SIZE, PduHeaders.MESSAGE_SIZE);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
headers.setLongInteger(headers.getLongInteger(PduHeaders.DATE) / 1000L, PduHeaders.DATE);
return headers;
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
private ContentValues getContentValuesFromHeader(PduHeaders headers) {
ContentValues contentValues = new ContentValues();
ContentValuesBuilder cvb = new ContentValuesBuilder(contentValues);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
cvb.add(RETRIEVE_TEXT, RETRIEVE_TEXT_CS, headers.getEncodedStringValue(PduHeaders.RETRIEVE_TEXT));
cvb.add(SUBJECT, SUBJECT_CHARSET, headers.getEncodedStringValue(PduHeaders.SUBJECT));
cvb.add(CONTENT_LOCATION, headers.getTextString(PduHeaders.CONTENT_LOCATION));
cvb.add(CONTENT_TYPE, headers.getTextString(PduHeaders.CONTENT_TYPE));
cvb.add(MESSAGE_CLASS, headers.getTextString(PduHeaders.MESSAGE_CLASS));
cvb.add(MESSAGE_ID, headers.getTextString(PduHeaders.MESSAGE_ID));
cvb.add(RESPONSE_TEXT, headers.getTextString(PduHeaders.RESPONSE_TEXT));
cvb.add(TRANSACTION_ID, headers.getTextString(PduHeaders.TRANSACTION_ID));
cvb.add(CONTENT_CLASS, headers.getOctet(PduHeaders.CONTENT_CLASS));
cvb.add(DELIVERY_REPORT, headers.getOctet(PduHeaders.DELIVERY_REPORT));
cvb.add(MESSAGE_TYPE, headers.getOctet(PduHeaders.MESSAGE_TYPE));
cvb.add(MMS_VERSION, headers.getOctet(PduHeaders.MMS_VERSION));
cvb.add(PRIORITY, headers.getOctet(PduHeaders.PRIORITY));
cvb.add(READ_REPORT, headers.getOctet(PduHeaders.READ_REPORT));
cvb.add(READ_STATUS, headers.getOctet(PduHeaders.READ_STATUS));
cvb.add(REPORT_ALLOWED, headers.getOctet(PduHeaders.REPORT_ALLOWED));
cvb.add(RETRIEVE_STATUS, headers.getOctet(PduHeaders.RETRIEVE_STATUS));
cvb.add(STATUS, headers.getOctet(PduHeaders.STATUS));
Display both sent and received time in message details. 1) We record time sent in SMS database (date_sent). 2) We record time received in MMS database (date_received). 3) We union this information correctly in MmsSmsDatabase.
2013-01-06 22:13:14 +01:00
cvb.add(DATE_SENT, headers.getLongInteger(PduHeaders.DATE));
Initial Project Import
2011-12-20 19:20:44 +01:00
cvb.add(DELIVERY_TIME, headers.getLongInteger(PduHeaders.DELIVERY_TIME));
cvb.add(EXPIRY, headers.getLongInteger(PduHeaders.EXPIRY));
cvb.add(MESSAGE_SIZE, headers.getLongInteger(PduHeaders.MESSAGE_SIZE));
Fix for NPE on null FROM in MMS header.
2013-05-31 05:29:13 +02:00
if (headers.getEncodedStringValue(PduHeaders.FROM) != null)
cvb.add(ADDRESS, headers.getEncodedStringValue(PduHeaders.FROM).getTextString());
else
cvb.add(ADDRESS, null);
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Initial Project Import
2011-12-20 19:20:44 +01:00
return cvb.getContentValues();
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public Reader readerFor(MasterSecret masterSecret, Cursor cursor) {
return new Reader(masterSecret, cursor);
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public static class Status {
Initial Project Import
2011-12-20 19:20:44 +01:00
public static final int DOWNLOAD_INITIALIZED = 1;
public static final int DOWNLOAD_NO_CONNECTIVITY = 2;
public static final int DOWNLOAD_CONNECTING = 3;
Removed tabs
2012-10-01 04:56:29 +02:00
public static final int DOWNLOAD_SOFT_FAILURE = 4;
public static final int DOWNLOAD_HARD_FAILURE = 5;
Enhanced MMS configuration prompts and processing. 1) Added a new message status to MmsDatabase to signify a pending MMS download which requires APN settings. 2) Added a database method to query MMS messages based on status. 3) Added login to SendReceiveService for processing of MMS pending APN information. 4) Moved all APN/MMS settings into ApnPreferencesActivity and transformed PromptApnActivity into a simple informational activity. 5) Added logic to check for APN settings on send and receive of all MMS (media, group, email) and direct user to PromptApnActivity then ApnPreferencesActivity if necessary. 6) Vocab/grammar adjustments.
2013-09-16 09:55:01 +02:00
public static final int DOWNLOAD_APN_UNAVAILABLE = 6;
Initial Project Import
2011-12-20 19:20:44 +01:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public static boolean isDisplayDownloadButton(int status) {
return
status == DOWNLOAD_INITIALIZED ||
status == DOWNLOAD_NO_CONNECTIVITY ||
status == DOWNLOAD_SOFT_FAILURE;
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public static String getLabelForStatus(Context context, int status) {
switch (status) {
Enhanced MMS configuration prompts and processing. 1) Added a new message status to MmsDatabase to signify a pending MMS download which requires APN settings. 2) Added a database method to query MMS messages based on status. 3) Added login to SendReceiveService for processing of MMS pending APN information. 4) Moved all APN/MMS settings into ApnPreferencesActivity and transformed PromptApnActivity into a simple informational activity. 5) Added logic to check for APN settings on send and receive of all MMS (media, group, email) and direct user to PromptApnActivity then ApnPreferencesActivity if necessary. 6) Vocab/grammar adjustments.
2013-09-16 09:55:01 +02:00
case DOWNLOAD_CONNECTING: return context.getString(R.string.MmsDatabase_connecting_to_mms_server);
case DOWNLOAD_INITIALIZED: return context.getString(R.string.MmsDatabase_downloading_mms);
case DOWNLOAD_HARD_FAILURE: return context.getString(R.string.MmsDatabase_mms_download_failed);
case DOWNLOAD_APN_UNAVAILABLE: return context.getString(R.string.MmsDatabase_mms_pending_download);
Support for auto-deleting old messages beyond a certain conversation thread length.
2013-01-10 06:06:56 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
return context.getString(R.string.MmsDatabase_downloading);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public static boolean isHardError(int status) {
return status == DOWNLOAD_HARD_FAILURE;
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public class Reader {
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
private final Cursor cursor;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
private final MasterSecret masterSecret;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
private final MasterCipher masterCipher;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public Reader(MasterSecret masterSecret, Cursor cursor) {
this.cursor = cursor;
this.masterSecret = masterSecret;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
if (masterSecret != null) masterCipher = new MasterCipher(masterSecret);
else masterCipher = null;
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public MessageRecord getNext() {
if (cursor == null || !cursor.moveToNext())
return null;
return getCurrent();
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public MessageRecord getCurrent() {
long mmsType = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.MESSAGE_TYPE));
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
if (mmsType == PduHeaders.MESSAGE_TYPE_NOTIFICATION_IND) {
return getNotificationMmsMessageRecord(cursor);
} else {
return getMediaMmsMessageRecord(cursor);
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
}
Extract TextSecure strings for i18n. 1) Change all instances which use concatenation to build strings with variables in them to use string formatting instead. 2) Extract all string literals from layouts and menus into strings.xml 3) Extract all string literals from code into strings.xml
2012-09-08 05:03:23 +02:00
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
private NotificationMmsMessageRecord getNotificationMmsMessageRecord(Cursor cursor) {
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.ID));
long dateSent = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.NORMALIZED_DATE_SENT));
long dateReceived = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.NORMALIZED_DATE_RECEIVED));
long threadId = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.THREAD_ID));
long mailbox = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.MESSAGE_BOX));
String address = cursor.getString(cursor.getColumnIndexOrThrow(MmsDatabase.ADDRESS));
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
int addressDeviceId = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.ADDRESS_DEVICE_ID));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
Recipients recipients = getRecipientsFor(address);
String contentLocation = cursor.getString(cursor.getColumnIndexOrThrow(MmsDatabase.CONTENT_LOCATION));
String transactionId = cursor.getString(cursor.getColumnIndexOrThrow(MmsDatabase.TRANSACTION_ID));
long messageSize = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.MESSAGE_SIZE));
long expiry = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.EXPIRY));
int status = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.STATUS));
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
int receiptCount = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.RECEIPT_COUNT));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
byte[]contentLocationBytes = null;
byte[]transactionIdBytes = null;
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (!TextUtils.isEmpty(contentLocation))
Move most of Util into library
2013-07-10 04:48:33 +02:00
contentLocationBytes = org.thoughtcrime.securesms.util.Util.toIsoBytes(contentLocation);
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (!TextUtils.isEmpty(transactionId))
Move most of Util into library
2013-07-10 04:48:33 +02:00
transactionIdBytes = org.thoughtcrime.securesms.util.Util.toIsoBytes(transactionId);
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
return new NotificationMmsMessageRecord(context, id, recipients, recipients.getPrimaryRecipient(),
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
addressDeviceId, dateSent, dateReceived, receiptCount, threadId,
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
contentLocationBytes, messageSize, expiry, status,
Refactor group database model and flow. 1) Use existing DB types instead of adding new columns. 2) Store group attributes in message body, like everything else.
2014-02-20 06:06:54 +01:00
transactionIdBytes, mailbox);
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
private MediaMmsMessageRecord getMediaMmsMessageRecord(Cursor cursor) {
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
long id = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.ID));
long dateSent = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.NORMALIZED_DATE_SENT));
long dateReceived = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.NORMALIZED_DATE_RECEIVED));
long box = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.MESSAGE_BOX));
long threadId = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.THREAD_ID));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
String address = cursor.getString(cursor.getColumnIndexOrThrow(MmsDatabase.ADDRESS));
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
int addressDeviceId = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.ADDRESS_DEVICE_ID));
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
int receiptCount = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.RECEIPT_COUNT));
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
DisplayRecord.Body body = getBody(cursor);
int partCount = cursor.getInt(cursor.getColumnIndexOrThrow(MmsDatabase.PART_COUNT));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
Recipients recipients = getRecipientsFor(address);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
ListenableFutureTask<SlideDeck> slideDeck = getSlideDeck(masterSecret, id);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
return new MediaMmsMessageRecord(context, id, recipients, recipients.getPrimaryRecipient(),
Implement delivery receipts. 1) Support a "receipt" push message type. 2) Identify messages by timestamp. 3) Introduce a JobManager to handle the queue for network dependent jobs.
2014-07-26 00:14:29 +02:00
addressDeviceId, dateSent, dateReceived, receiptCount,
threadId, body, slideDeck, partCount, box);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
}
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
private Recipients getRecipientsFor(String address) {
try {
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (TextUtils.isEmpty(address) || address.equals("insert-address-token")) {
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
return new Recipients(Recipient.getUnknownRecipient(context));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
}
Recipients recipients = RecipientFactory.getRecipientsFromString(context, address, false);
if (recipients == null || recipients.isEmpty()) {
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
return new Recipients(Recipient.getUnknownRecipient(context));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
}
return recipients;
} catch (RecipientFormattingException e) {
Log.w("MmsDatabase", e);
Support for multi-device. 1) In addition to the Recipient interface, there is now RecipientDevice. A Recipient can have multiple corresponding RecipientDevices. All addressing is done to a Recipient, but crypto sessions and transport delivery are done to RecipientDevice. 2) The Push transport handles the discovery and session setup of additional Recipient devices. 3) Some internal rejiggering of Groups.
2014-02-03 04:38:06 +01:00
return new Recipients(Recipient.getUnknownRecipient(context));
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
}
}
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
private DisplayRecord.Body getBody(Cursor cursor) {
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
try {
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
String body = cursor.getString(cursor.getColumnIndexOrThrow(MmsDatabase.BODY));
long box = cursor.getLong(cursor.getColumnIndexOrThrow(MmsDatabase.MESSAGE_BOX));
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
Split out Util functions.
2014-11-12 20:15:05 +01:00
if (!TextUtils.isEmpty(body) && masterCipher != null && Types.isSymmetricEncryption(box)) {
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
return new DisplayRecord.Body(masterCipher.decryptBody(body), true);
Split out Util functions.
2014-11-12 20:15:05 +01:00
} else if (!TextUtils.isEmpty(body) && masterCipher == null && Types.isSymmetricEncryption(box)) {
Locally encrypted messages no longer show as ciphertext notifications.
2013-04-30 20:14:01 +02:00
return new DisplayRecord.Body(body, false);
} else {
return new DisplayRecord.Body(body == null ? "" : body, true);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
}
} catch (InvalidMessageException e) {
Log.w("MmsDatabase", e);
More l10n - for decrypting errors //FREEBIE Closes #2231
2014-12-17 20:21:04 +01:00
return new DisplayRecord.Body(context.getString(R.string.MmsDatabase_error_decrypting_message), true);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
}
Initial Project Import
2011-12-20 19:20:44 +01:00
}
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
private ListenableFutureTask<SlideDeck> getSlideDeck(final MasterSecret masterSecret,
final long id)
{
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
ListenableFutureTask<SlideDeck> future = getCachedSlideDeck(id);
if (future != null) {
return future;
}
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
Callable<SlideDeck> task = new Callable<SlideDeck>() {
@Override
public SlideDeck call() throws Exception {
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
if (masterSecret == null)
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
return null;
MMS and Group Messaging Improvements 1) Display the individual sender name in a group conversation. 2) Add an "address" column to MmsDatabase and keep FROM there. 3) Remove all blocking operations from MmsDatabase.Reader path. 4) Strip SMIL and other undisplayable parts from part count. 5) Fix places where messages weren't being correctly decrypted.
2013-05-05 21:51:36 +02:00
streaming media // FREEBIE
2014-12-12 10:03:24 +01:00
PartDatabase partDatabase = DatabaseFactory.getPartDatabase(context);
PduBody body = getPartsAsBody(partDatabase.getParts(id));
SlideDeck slideDeck = new SlideDeck(context, masterSecret, body);
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
if (!body.containsPushInProgress()) {
slideCache.put(id, new SoftReference<SlideDeck>(slideDeck));
}
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
return slideDeck;
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
}
};
refactor ListenableFutureTask and make saves async // FREEBIE
2014-10-28 08:23:00 +01:00
future = new ListenableFutureTask<SlideDeck>(task);
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
slideResolver.execute(future);
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
Make MMS more asynchronous and consistent with new SMS types. 1) We now delay MMS notifications until a payload is received, or there's an error downloading the payload. This makes group messages more consistent. 2) All "text" parts of an MMS are combined into a second text record, which is stored in the MMS row directly rather than as a distinct part. This allows for immediate text loading, which means there's no chance a ConversationItem will resize. To do this, we need to include MMS in the big DB migration that's already staged for this application update. It's also an "application-level" migration, because we need the MasterSecret to do it. 3) On conversation display, all image-based parts now have their thumbnails loaded asynchronously. This allows for smooth-scrolling. The thumbnails are also scaled more accurately.
2013-04-26 20:23:43 +02:00
return future;
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
}
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
private ListenableFutureTask<SlideDeck> getCachedSlideDeck(final long id) {
SoftReference<SlideDeck> reference = slideCache.get(id);
if (reference != null) {
final SlideDeck slideDeck = reference.get();
if (slideDeck != null) {
Callable<SlideDeck> task = new Callable<SlideDeck>() {
@Override
public SlideDeck call() throws Exception {
return slideDeck;
}
};
refactor ListenableFutureTask and make saves async // FREEBIE
2014-10-28 08:23:00 +01:00
ListenableFutureTask<SlideDeck> future = new ListenableFutureTask<SlideDeck>(task);
Replace LinkedHashMap with a SoftReference LRUCache. Add Slide cache.
2013-05-06 21:22:03 +02:00
future.run();
return future;
}
}
return null;
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
public void close() {
cursor.close();
Initial Project Import
2011-12-20 19:20:44 +01:00
}
}
Major storage layer refactoring to set the stage for clean GCM. 1) We now try to hand out cursors at a minimum. There has always been a fairly clean insertion layer that handles encrypting message bodies, but the process of decrypting message bodies has always been less than ideal. Here we introduce a "Reader" interface that will decrypt message bodies when appropriate and return objects that encapsulate record state. No more MessageDisplayHelper. The MmsSmsDatabase interface is also more sane. 2) We finally rid ourselves of the technical debt associated with TextSecure's initial usage of the default SMS DB. In that world, we weren't able to use anything other than the default "Inbox, Outbox, Sent" types to describe a message, and had to overload the message content itself with a set of local "prefixes" to describe what it was (encrypted, asymetric encrypted, remote encrypted, a key exchange, procssed key exchange), and so on. This includes a major schema update that transforms the "type" field into a bitmask that describes everything that used to be encoded in a prefix, and prefixes have been completely eliminated from the system. No more Prefix.java 3) Refactoring of the MultipartMessageHandler code. It's less of a mess, and hopefully more clear as to what's going on. The next step is to remove what we can from SmsTransportDetails and genericize that interface for a GCM equivalent.
2013-04-20 21:22:04 +02:00
Basic support for encrypted push-based attachments. 1) Move the attachment structures into the encrypted message body. 2) Encrypt attachments with symmetric keys transmitted in the encryptd attachment pointer structure. 3) Correctly handle asynchronous decryption and categorization of encrypted push messages. TODO: Correct notification process and network/interruption retries.
2013-09-09 03:19:05 +02:00
private PduBody getPartsAsBody(List<Pair<Long, PduPart>> parts) {
PduBody body = new PduBody();
for (Pair<Long, PduPart> part : parts) {
body.addPart(part.second);
}
return body;
}
Initial Project Import
2011-12-20 19:20:44 +01:00
}