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
|
|
|
package org.thoughtcrime.securesms.database;
|
|
|
|
|
2015-11-13 22:20:16 +01:00
|
|
|
@SuppressWarnings("UnnecessaryInterfaceModifier")
|
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 interface MmsSmsColumns {
|
|
|
|
|
|
|
|
public static final String ID = "_id";
|
|
|
|
public static final String NORMALIZED_DATE_SENT = "date_sent";
|
|
|
|
public static final String NORMALIZED_DATE_RECEIVED = "date_received";
|
|
|
|
public static final String THREAD_ID = "thread_id";
|
|
|
|
public static final String READ = "read";
|
2013-04-26 20:23:43 +02:00
|
|
|
public static final String BODY = "body";
|
2014-02-03 04:38:06 +01:00
|
|
|
public static final String ADDRESS = "address";
|
|
|
|
public static final String ADDRESS_DEVICE_ID = "address_device_id";
|
2017-09-16 07:38:53 +02:00
|
|
|
public static final String DELIVERY_RECEIPT_COUNT = "delivery_receipt_count";
|
|
|
|
public static final String READ_RECEIPT_COUNT = "read_receipt_count";
|
2015-01-15 22:35:35 +01:00
|
|
|
public static final String MISMATCHED_IDENTITIES = "mismatched_identities";
|
2015-11-13 22:20:16 +01:00
|
|
|
public static final String UNIQUE_ROW_ID = "unique_row_id";
|
2016-08-16 05:23:56 +02:00
|
|
|
public static final String SUBSCRIPTION_ID = "subscription_id";
|
|
|
|
public static final String EXPIRES_IN = "expires_in";
|
|
|
|
public static final String EXPIRE_STARTED = "expire_started";
|
2017-03-09 02:38:55 +01:00
|
|
|
public static final String NOTIFIED = "notified";
|
2018-05-22 11:13:10 +02:00
|
|
|
public static final String UNIDENTIFIED = "unidentified";
|
2022-03-04 07:46:39 +01:00
|
|
|
public static final String MESSAGE_REQUEST_RESPONSE = "message_request_response";
|
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 Types {
|
|
|
|
protected static final long TOTAL_MASK = 0xFFFFFFFF;
|
|
|
|
|
|
|
|
// Base Types
|
2014-04-01 03:47:24 +02:00
|
|
|
protected static final long BASE_TYPE_MASK = 0x1F;
|
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
|
|
|
|
2015-09-21 19:54:23 +02:00
|
|
|
protected static final long INCOMING_CALL_TYPE = 1;
|
|
|
|
protected static final long OUTGOING_CALL_TYPE = 2;
|
|
|
|
protected static final long MISSED_CALL_TYPE = 3;
|
2015-10-27 20:18:02 +01:00
|
|
|
protected static final long JOINED_TYPE = 4;
|
2022-04-06 08:38:55 +02:00
|
|
|
protected static final long FIRST_MISSED_CALL_TYPE = 5;
|
2015-09-21 19:54:23 +02:00
|
|
|
|
2014-04-01 03:47:24 +02:00
|
|
|
protected static final long BASE_INBOX_TYPE = 20;
|
|
|
|
protected static final long BASE_OUTBOX_TYPE = 21;
|
|
|
|
protected static final long BASE_SENDING_TYPE = 22;
|
|
|
|
protected static final long BASE_SENT_TYPE = 23;
|
|
|
|
protected static final long BASE_SENT_FAILED_TYPE = 24;
|
|
|
|
protected static final long BASE_PENDING_SECURE_SMS_FALLBACK = 25;
|
|
|
|
protected static final long BASE_PENDING_INSECURE_SMS_FALLBACK = 26;
|
2014-12-12 02:13:01 +01:00
|
|
|
public static final long BASE_DRAFT_TYPE = 27;
|
2021-08-12 03:43:33 +02:00
|
|
|
protected static final long BASE_DELETED_TYPE = 28;
|
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
|
|
|
|
|
|
|
protected static final long[] OUTGOING_MESSAGE_TYPES = {BASE_OUTBOX_TYPE, BASE_SENT_TYPE,
|
2014-03-01 23:17:55 +01:00
|
|
|
BASE_SENDING_TYPE, BASE_SENT_FAILED_TYPE,
|
2014-04-01 03:47:24 +02:00
|
|
|
BASE_PENDING_SECURE_SMS_FALLBACK,
|
2017-03-10 02:16:21 +01:00
|
|
|
BASE_PENDING_INSECURE_SMS_FALLBACK,
|
|
|
|
OUTGOING_CALL_TYPE};
|
2014-03-01 23:17:55 +01:00
|
|
|
|
2021-05-12 00:40:10 +02:00
|
|
|
|
2021-05-17 07:18:41 +02:00
|
|
|
// TODO: Clean unused keys
|
|
|
|
|
2014-03-01 23:17:55 +01:00
|
|
|
// Message attributes
|
|
|
|
protected static final long MESSAGE_FORCE_SMS_BIT = 0x40;
|
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
|
|
|
|
|
|
|
// Key Exchange Information
|
2017-06-07 03:03:09 +02:00
|
|
|
protected static final long KEY_EXCHANGE_MASK = 0xFF00;
|
|
|
|
protected static final long KEY_EXCHANGE_BIT = 0x8000;
|
2021-05-12 00:40:10 +02:00
|
|
|
protected static final long KEY_EXCHANGE_IDENTITY_VERIFIED_BIT = 0x40000;
|
2017-06-07 03:03:09 +02:00
|
|
|
protected static final long KEY_EXCHANGE_IDENTITY_DEFAULT_BIT = 0x2000;
|
|
|
|
protected static final long KEY_EXCHANGE_CORRUPTED_BIT = 0x1000;
|
|
|
|
protected static final long KEY_EXCHANGE_INVALID_VERSION_BIT = 0x800;
|
|
|
|
protected static final long KEY_EXCHANGE_BUNDLE_BIT = 0x400;
|
|
|
|
protected static final long KEY_EXCHANGE_IDENTITY_UPDATE_BIT = 0x200;
|
|
|
|
protected static final long KEY_EXCHANGE_CONTENT_FORMAT = 0x100;
|
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
|
|
|
|
|
|
|
// Secure Message Information
|
|
|
|
protected static final long SECURE_MESSAGE_BIT = 0x800000;
|
2014-02-19 22:46:49 +01:00
|
|
|
protected static final long END_SESSION_BIT = 0x400000;
|
2014-02-21 08:00:38 +01:00
|
|
|
protected static final long PUSH_MESSAGE_BIT = 0x200000;
|
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
|
|
|
|
2014-02-20 06:06:54 +01:00
|
|
|
// Group Message Information
|
2016-08-16 05:23:56 +02:00
|
|
|
protected static final long GROUP_UPDATE_BIT = 0x10000;
|
|
|
|
protected static final long GROUP_QUIT_BIT = 0x20000;
|
|
|
|
protected static final long EXPIRATION_TIMER_UPDATE_BIT = 0x40000;
|
2021-04-15 06:41:29 +02:00
|
|
|
protected static final long GROUP_UPDATE_MESSAGE_BIT = 0x80000;
|
2014-02-20 06:06:54 +01:00
|
|
|
|
2021-05-17 07:18:41 +02:00
|
|
|
// Data Extraction Notification
|
2021-04-09 08:06:12 +02:00
|
|
|
protected static final long MEDIA_SAVED_EXTRACTION_BIT = 0x01000;
|
|
|
|
protected static final long SCREENSHOT_EXTRACTION_BIT = 0x02000;
|
2021-05-17 07:18:41 +02:00
|
|
|
|
2021-05-12 00:40:10 +02:00
|
|
|
// Open Group Invitation
|
|
|
|
protected static final long OPEN_GROUP_INVITATION_BIT = 0x04000;
|
2021-04-09 08:06:12 +02:00
|
|
|
|
2018-01-25 04:17:44 +01:00
|
|
|
// Encrypted Storage Information XXX
|
|
|
|
public static final long ENCRYPTION_MASK = 0xFF000000;
|
2018-01-31 02:45:12 +01:00
|
|
|
// public static final long ENCRYPTION_SYMMETRIC_BIT = 0x80000000; Deprecated
|
|
|
|
// protected static final long ENCRYPTION_ASYMMETRIC_BIT = 0x40000000; Deprecated
|
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
|
|
|
protected static final long ENCRYPTION_REMOTE_BIT = 0x20000000;
|
|
|
|
protected static final long ENCRYPTION_REMOTE_FAILED_BIT = 0x10000000;
|
|
|
|
protected static final long ENCRYPTION_REMOTE_NO_SESSION_BIT = 0x08000000;
|
2014-03-19 20:37:46 +01:00
|
|
|
protected static final long ENCRYPTION_REMOTE_DUPLICATE_BIT = 0x04000000;
|
2014-04-11 00:20:43 +02:00
|
|
|
protected static final long ENCRYPTION_REMOTE_LEGACY_BIT = 0x02000000;
|
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
|
|
|
|
2019-12-05 02:59:37 +01:00
|
|
|
// Loki
|
2019-12-09 01:50:22 +01:00
|
|
|
protected static final long ENCRYPTION_LOKI_SESSION_RESTORE_SENT_BIT = 0x01000000;
|
2020-08-24 03:41:39 +02:00
|
|
|
protected static final long ENCRYPTION_LOKI_SESSION_RESTORE_DONE_BIT = 0x00100000;
|
2019-12-05 02:59:37 +01:00
|
|
|
|
2022-03-04 07:46:39 +01:00
|
|
|
protected static final long MESSAGE_REQUEST_RESPONSE_BIT = 0x010000;
|
|
|
|
|
2014-12-12 02:13:01 +01:00
|
|
|
public static boolean isDraftMessageType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_DRAFT_TYPE;
|
|
|
|
}
|
|
|
|
|
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 isFailedMessageType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_SENT_FAILED_TYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isOutgoingMessageType(long type) {
|
|
|
|
for (long outgoingType : OUTGOING_MESSAGE_TYPES) {
|
|
|
|
if ((type & BASE_TYPE_MASK) == outgoingType)
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2017-04-23 01:29:26 +02:00
|
|
|
public static long getOutgoingEncryptedMessageType() {
|
|
|
|
return Types.BASE_SENDING_TYPE | Types.SECURE_MESSAGE_BIT | Types.PUSH_MESSAGE_BIT;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static long getOutgoingSmsMessageType() {
|
|
|
|
return Types.BASE_SENDING_TYPE;
|
|
|
|
}
|
|
|
|
|
2014-03-01 23:17:55 +01:00
|
|
|
public static boolean isForcedSms(long type) {
|
|
|
|
return (type & MESSAGE_FORCE_SMS_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
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 isPendingMessageType(long type) {
|
|
|
|
return
|
|
|
|
(type & BASE_TYPE_MASK) == BASE_OUTBOX_TYPE ||
|
2017-06-07 03:03:09 +02:00
|
|
|
(type & BASE_TYPE_MASK) == BASE_SENDING_TYPE;
|
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
|
|
|
}
|
|
|
|
|
2018-11-14 20:39:23 +01:00
|
|
|
public static boolean isSentType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_SENT_TYPE;
|
|
|
|
}
|
|
|
|
|
2014-04-01 03:47:24 +02:00
|
|
|
public static boolean isPendingSmsFallbackType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_PENDING_INSECURE_SMS_FALLBACK ||
|
|
|
|
(type & BASE_TYPE_MASK) == BASE_PENDING_SECURE_SMS_FALLBACK;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isPendingSecureSmsFallbackType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_PENDING_SECURE_SMS_FALLBACK;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isPendingInsecureSmsFallbackType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_PENDING_INSECURE_SMS_FALLBACK;
|
2014-03-01 23:17:55 +01:00
|
|
|
}
|
|
|
|
|
2013-06-25 06:02:30 +02:00
|
|
|
public static boolean isInboxType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == BASE_INBOX_TYPE;
|
|
|
|
}
|
|
|
|
|
2021-08-12 03:43:33 +02:00
|
|
|
public static boolean isDeletedMessage(long type) { return (type & BASE_TYPE_MASK) == BASE_DELETED_TYPE; }
|
|
|
|
|
2015-10-27 20:18:02 +01:00
|
|
|
public static boolean isJoinedType(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == JOINED_TYPE;
|
|
|
|
}
|
|
|
|
|
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 isSecureType(long type) {
|
|
|
|
return (type & SECURE_MESSAGE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2014-02-21 08:00:38 +01:00
|
|
|
public static boolean isPushType(long type) {
|
|
|
|
return (type & PUSH_MESSAGE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2014-02-19 22:46:49 +01:00
|
|
|
public static boolean isEndSessionType(long type) {
|
|
|
|
return (type & END_SESSION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
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 isKeyExchangeType(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2017-06-07 03:03:09 +02:00
|
|
|
public static boolean isIdentityVerified(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_IDENTITY_VERIFIED_BIT) != 0;
|
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
|
|
|
}
|
|
|
|
|
2017-06-07 03:03:09 +02:00
|
|
|
public static boolean isIdentityDefault(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_IDENTITY_DEFAULT_BIT) != 0;
|
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
|
|
|
}
|
|
|
|
|
2013-08-22 02:25:19 +02:00
|
|
|
public static boolean isCorruptedKeyExchange(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_CORRUPTED_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isInvalidVersionKeyExchange(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_INVALID_VERSION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2013-09-14 22:33:23 +02:00
|
|
|
public static boolean isBundleKeyExchange(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_BUNDLE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2016-11-09 18:37:40 +01:00
|
|
|
public static boolean isContentBundleKeyExchange(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_CONTENT_FORMAT) != 0;
|
|
|
|
}
|
|
|
|
|
2014-02-17 00:23:49 +01:00
|
|
|
public static boolean isIdentityUpdate(long type) {
|
|
|
|
return (type & KEY_EXCHANGE_IDENTITY_UPDATE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2015-09-21 19:54:23 +02:00
|
|
|
public static boolean isCallLog(long type) {
|
2021-11-23 07:59:02 +01:00
|
|
|
long baseType = type & BASE_TYPE_MASK;
|
2022-04-06 08:38:55 +02:00
|
|
|
return baseType == INCOMING_CALL_TYPE || baseType == OUTGOING_CALL_TYPE || baseType == MISSED_CALL_TYPE || baseType == FIRST_MISSED_CALL_TYPE;
|
2015-09-21 19:54:23 +02:00
|
|
|
}
|
|
|
|
|
2016-08-16 05:23:56 +02:00
|
|
|
public static boolean isExpirationTimerUpdate(long type) {
|
|
|
|
return (type & EXPIRATION_TIMER_UPDATE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2021-04-09 08:06:12 +02:00
|
|
|
public static boolean isMediaSavedExtraction(long type) {
|
|
|
|
return (type & MEDIA_SAVED_EXTRACTION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isScreenshotExtraction(long type) {
|
|
|
|
return (type & SCREENSHOT_EXTRACTION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2021-05-12 00:40:10 +02:00
|
|
|
public static boolean isOpenGroupInvitation(long type) {
|
|
|
|
return (type & OPEN_GROUP_INVITATION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2015-09-21 19:54:23 +02:00
|
|
|
public static boolean isIncomingCall(long type) {
|
2021-11-24 01:57:23 +01:00
|
|
|
return (type & BASE_TYPE_MASK) == INCOMING_CALL_TYPE;
|
2015-09-21 19:54:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isOutgoingCall(long type) {
|
2021-11-24 01:57:23 +01:00
|
|
|
return (type & BASE_TYPE_MASK) == OUTGOING_CALL_TYPE;
|
2015-09-21 19:54:23 +02:00
|
|
|
}
|
|
|
|
|
|
|
|
public static boolean isMissedCall(long type) {
|
2021-11-24 01:57:23 +01:00
|
|
|
return (type & BASE_TYPE_MASK) == MISSED_CALL_TYPE;
|
2015-09-21 19:54:23 +02:00
|
|
|
}
|
|
|
|
|
2022-04-06 08:38:55 +02:00
|
|
|
public static boolean isFirstMissedCall(long type) {
|
|
|
|
return (type & BASE_TYPE_MASK) == FIRST_MISSED_CALL_TYPE;
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2014-02-22 02:51:25 +01:00
|
|
|
public static boolean isGroupUpdate(long type) {
|
|
|
|
return (type & GROUP_UPDATE_BIT) != 0;
|
2014-02-20 06:06:54 +01:00
|
|
|
}
|
|
|
|
|
2021-04-15 06:41:29 +02:00
|
|
|
public static boolean isGroupUpdateMessage(long type) { return (type & GROUP_UPDATE_MESSAGE_BIT) != 0; }
|
|
|
|
|
2014-02-20 06:06:54 +01:00
|
|
|
public static boolean isGroupQuit(long type) {
|
|
|
|
return (type & GROUP_QUIT_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
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 isFailedDecryptType(long type) {
|
|
|
|
return (type & ENCRYPTION_REMOTE_FAILED_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2014-03-19 20:37:46 +01:00
|
|
|
public static boolean isDuplicateMessageType(long type) {
|
|
|
|
return (type & ENCRYPTION_REMOTE_DUPLICATE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
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 isDecryptInProgressType(long type) {
|
2018-01-31 02:45:12 +01:00
|
|
|
return (type & 0x40000000) != 0; // Inline deprecated asymmetric encryption type
|
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 isNoRemoteSessionType(long type) {
|
|
|
|
return (type & ENCRYPTION_REMOTE_NO_SESSION_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2019-12-05 02:59:37 +01:00
|
|
|
public static boolean isLokiSessionRestoreSentType(long type) {
|
|
|
|
return (type & ENCRYPTION_LOKI_SESSION_RESTORE_SENT_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2020-08-24 03:41:39 +02:00
|
|
|
public static boolean isLokiSessionRestoreDoneType(long type) {
|
|
|
|
return (type & ENCRYPTION_LOKI_SESSION_RESTORE_DONE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
2014-04-11 00:20:43 +02:00
|
|
|
public static boolean isLegacyType(long type) {
|
2015-07-07 02:36:49 +02:00
|
|
|
return (type & ENCRYPTION_REMOTE_LEGACY_BIT) != 0 ||
|
|
|
|
(type & ENCRYPTION_REMOTE_BIT) != 0;
|
2014-04-11 00:20:43 +02:00
|
|
|
}
|
|
|
|
|
2022-03-04 07:46:39 +01:00
|
|
|
public static boolean isMessageRequestResponse(long type) {
|
|
|
|
return (type & MESSAGE_REQUEST_RESPONSE_BIT) != 0;
|
|
|
|
}
|
|
|
|
|
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 long translateFromSystemBaseType(long theirType) {
|
|
|
|
|
|
|
|
switch ((int)theirType) {
|
|
|
|
case 1: return BASE_INBOX_TYPE;
|
|
|
|
case 2: return BASE_SENT_TYPE;
|
2014-12-13 04:35:52 +01:00
|
|
|
case 3: return BASE_DRAFT_TYPE;
|
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
|
|
|
case 4: return BASE_OUTBOX_TYPE;
|
|
|
|
case 5: return BASE_SENT_FAILED_TYPE;
|
2014-12-13 04:35:52 +01:00
|
|
|
case 6: return BASE_OUTBOX_TYPE;
|
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 BASE_INBOX_TYPE;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
}
|