protected override async Task <string> ExecuteAsync()
{
TextMessageDatabase database = DatabaseFactory.getTextMessageDatabase();
var record = await database.getMessageRecord(messageId);
//var message = await database.Get(messageId);
try
{
await deliver(record);
database.MarkAsPush(messageId);
database.MarkAsSecure(messageId);
database.MarkAsSent(messageId);
}
catch (libsignalservice.crypto.UntrustedIdentityException e)
{
Log.Debug($"Untrusted Identity Key: {e.getIdentityKey()} {e.getE164Number()}");
var recipients = RecipientFactory.getRecipientsFromString(e.getE164Number(), false);
long recipientId = recipients.getPrimaryRecipient().getRecipientId();
database.AddMismatchedIdentity(record.MessageId, recipientId, e.getIdentityKey());
database.MarkAsSentFailed(record.MessageId);
database.MarkAsPush(record.MessageId);
}
catch (Exception e)
{
Log.Error($"Unexpected Exception {e.Source} {e.GetType()} : {e.Message}");
}
return("");
//throw new NotImplementedException();
}
public bool IsTrustedIdentity(string name, IdentityKey identityKey)
{
long recipientId = RecipientFactory.getRecipientsFromString(name, true).getPrimaryRecipient().getRecipientId();
return(DatabaseFactory.getIdentityDatabase()
.IsValidIdentity(recipientId, identityKey));
}
public bool SaveIdentity(string name, IdentityKey identityKey)
{
long recipientId = RecipientFactory.getRecipientsFromString(name, true).getPrimaryRecipient().getRecipientId();
DatabaseFactory.getIdentityDatabase().SaveIdentity(recipientId, identityKey);
return(true);
}
/*
* CREATE
*/
private long CreateForRecipients(String recipients, int recipientCount, int distributionType)
{
var reci = RecipientFactory.getRecipientsForIds(recipients, false);
if (recipientCount > 1)
{
return(CreateForRecipients(reci, distributionType));
}
return(CreateForRecipients(reci, DistributionTypes.DEFAULT)); // TODO: lala
}
private Recipients getSyncMessageDestination(SentTranscriptMessage message)
{
if (message.getMessage().getGroupInfo().HasValue)
{
throw new NotImplementedException("GROUP getSyncMessageDestination");
//return RecipientFactory.getRecipientsFromString(GroupUtil.getEncodedId(message.getMessage().getGroupInfo().get().getGroupId()), false); // TODO: Group enable
}
else
{
return(RecipientFactory.getRecipientsFromString(message.getDestination().ForceGetValue(), false));
}
}
public Recipients GetRecipients(long[] recipientIds)
{
//var recipients = conn.Table<Recipient>().Where(s => recipientIds.Contains(s.RecipientId)).ToList();
var recipients = new List <Recipient>();
foreach (var recipientId in recipientIds)
{
}
return(RecipientFactory.getRecipientsFor(recipients, false));
}
public Recipients GetOrCreateRecipients(TextSecureDirectory.Directory d)
{
var recipients = new List <Recipient>();
/*foreach (var recipientId in recipientIds)
* {
*
* }*/
recipients.Add(GetOrCreateRecipient(d));
return(RecipientFactory.getRecipientsFor(recipients, false));
}
private Recipients getRecipientsFor(String address)
{
if (address != null)
{
Recipients recipients = RecipientFactory.getRecipientsFromString(address, true);
if (recipients == null || recipients.IsEmpty)
{
return(RecipientFactory.getRecipientsFor(Recipient.getUnknownRecipient(), true));
}
return(recipients);
}
else
{
Log.Warn("getRecipientsFor() address is null");
return(RecipientFactory.getRecipientsFor(Recipient.getUnknownRecipient(), true));
}
}
private Recipients GetRecipientsFor(string address)
{
if (address != null)
{
Recipients recipients = RecipientFactory.getRecipientsFromString(address, false);
if (recipients == null || recipients.IsEmpty)
{
return(RecipientFactory.getRecipientsFor(Recipient.getUnknownRecipient(), false));
}
return(recipients);
}
else
{
//Log.w(TAG, "getRecipientsFor() address is null");
return(RecipientFactory.getRecipientsFor(Recipient.getUnknownRecipient(), false));
}
}
public async Task <Recipients> getGroupMembers(byte[] groupId, bool includeSelf)
{
String localNumber = TextSecurePreferences.getLocalNumber();
List <String> members = await getCurrentMembers(groupId);
List <Recipient> recipients = new List <Recipient>();
foreach (String member in members)
{
if (!includeSelf && member.Equals(localNumber))
{
continue;
}
recipients.AddRange(RecipientFactory.getRecipientsFromString(member, false)
.getRecipientsList());
}
return(RecipientFactory.getRecipientsFor(recipients, false));
}
private void handleUntrustedIdentityMessage(SignalServiceEnvelope envelope, May <long> smsMessageId)
{
try
{
var database = DatabaseFactory.getTextMessageDatabase(); //getEncryptingSmsDatabase(context);
Recipients recipients = RecipientFactory.getRecipientsFromString(envelope.getSource(), false);
long recipientId = recipients.getPrimaryRecipient().getRecipientId();
PreKeySignalMessage whisperMessage = new PreKeySignalMessage(envelope.getLegacyMessage());
IdentityKey identityKey = whisperMessage.getIdentityKey();
String encoded = Base64.encodeBytes(envelope.getLegacyMessage());
IncomingTextMessage textMessage = new IncomingTextMessage(envelope.getSource(), envelope.getSourceDevice(),
envelope.getTimestamp(), encoded,
May <SignalServiceGroup> .NoValue);
if (!smsMessageId.HasValue)
{
IncomingPreKeyBundleMessage bundleMessage = new IncomingPreKeyBundleMessage(textMessage, encoded);
Pair <long, long> messageAndThreadId = database.InsertMessageInbox(bundleMessage);
database.SetMismatchedIdentity(messageAndThreadId.first(), recipientId, identityKey);
//MessageNotifier.updateNotification(context, masterSecret.getMasterSecret().orNull(), messageAndThreadId.second);
}
else
{
var messageId = smsMessageId.ForceGetValue();
database.UpdateMessageBody(messageId, encoded);
database.MarkAsPreKeyBundle(messageId);
database.SetMismatchedIdentity(messageId, recipientId, identityKey);
}
}
catch (InvalidMessageException e)
{
throw new InvalidOperationException(e.Message);
}
catch (InvalidVersionException e)
{
throw new InvalidOperationException(e.Message);
}
}
/*protected Pair<long, long> updateMessageBodyAndType(long messageId, String body, long maskOff, long maskOn)
* {
* SQLiteDatabase db = databaseHelper.getWritableDatabase();
* db.execSQL("UPDATE " + TABLE_NAME + " SET " + BODY + " = ?, " +
* TYPE + " = (" + TYPE + " & " + (MessageTypes.TOTAL_MASK - maskOff) + " | " + maskOn + ") " +
* "WHERE " + ID + " = ?",
* new String[] { body, messageId + "" });
*
* long threadId = getThreadIdForMessage(messageId);
*
* DatabaseFactory.getThreadDatabase().update(threadId);
* notifyConversationListeners(threadId);
* //notifyConversationListListeners();
*
* return new Pair<long, long>(messageId, threadId);
* }
*
* public Pair<long, long> copyMessageInbox(long messageId)
* {
* Reader reader = readerFor(getMessage(messageId));
* SmsMessageRecord record = reader.getNext();
*
* ContentValues contentValues = new ContentValues();
* contentValues.put(TYPE, (record.getType() & ~MessageTypes.BASE_TYPE_MASK) | MessageTypes.BASE_INBOX_TYPE);
* contentValues.put(ADDRESS, record.getIndividualRecipient().getNumber());
* contentValues.put(ADDRESS_DEVICE_ID, record.getRecipientDeviceId());
* contentValues.put(DATE_RECEIVED, System.currentTimeMillis());
* contentValues.put(DATE_SENT, record.getDateSent());
* contentValues.put(PROTOCOL, 31337);
* contentValues.put(READ, 0);
* contentValues.put(BODY, record.getBody().getBody());
* contentValues.put(THREAD_ID, record.getThreadId());
*
* SQLiteDatabase db = databaseHelper.getWritableDatabase();
* long newMessageId = db.insert(TABLE_NAME, null, contentValues);
*
* DatabaseFactory.getThreadDatabase(context).update(record.getThreadId());
* notifyConversationListeners(record.getThreadId());
*
* jobManager.add(new TrimThreadJob(context, record.getThreadId()));
* reader.close();
*
* return new Pair<>(newMessageId, record.getThreadId());
* }
*/
protected Pair <long, long> insertMessageInbox(IncomingTextMessage message, long type)
{
if (message.isPreKeyBundle())
{
type |= MessageTypes.KEY_EXCHANGE_BIT | MessageTypes.KEY_EXCHANGE_BUNDLE_BIT;
}
else if (message.isSecureMessage())
{
type |= MessageTypes.SECURE_MESSAGE_BIT;
}
/*else if (message.isGroup()) TODO: GROUP enable
* {
* type |= MessageTypes.SECURE_MESSAGE_BIT;
* if (((IncomingGroupMessage)message).isUpdate()) type |= MessageTypes.GROUP_UPDATE_BIT;
* else if (((IncomingGroupMessage)message).isQuit()) type |= MessageTypes.GROUP_QUIT_BIT;
* }*/
else if (message.isEndSession())
{
type |= MessageTypes.SECURE_MESSAGE_BIT;
type |= MessageTypes.END_SESSION_BIT;
}
if (message.isPush())
{
type |= MessageTypes.PUSH_MESSAGE_BIT;
}
Recipients recipients;
if (message.getSender() != null)
{
recipients = RecipientFactory.getRecipientsFromString(message.getSender(), true);
}
else
{
//Log.w(TAG, "Sender is null, returning unknown recipient");
recipients = new Recipients(Recipient.getUnknownRecipient());
}
Recipients groupRecipients;
if (message.getGroupId() == null)
{
groupRecipients = null;
}
else
{
groupRecipients = RecipientFactory.getRecipientsFromString(message.getGroupId(), true);
}
bool unread = /*org.thoughtcrime.securesms.util.Util.isDefaultSmsProvider() ||*/
message.isSecureMessage() || message.isPreKeyBundle();
long threadId;
if (groupRecipients == null)
{
threadId = DatabaseFactory.getThreadDatabase().GetThreadIdForRecipients(recipients); // TODO CHECK
}
else
{
threadId = DatabaseFactory.getThreadDatabase().GetThreadIdForRecipients(groupRecipients);
}
/*ContentValues values = new ContentValues(6);
* values.put(ADDRESS, message.getSender());
* values.put(ADDRESS_DEVICE_ID, message.getSenderDeviceId());
* values.put(DATE_RECEIVED, System.currentTimeMillis());
* values.put(DATE_SENT, message.getSentTimestampMillis());
* values.put(PROTOCOL, message.getProtocol());
* values.put(READ, unread ? 0 : 1);
*
* if (!TextUtils.isEmpty(message.getPseudoSubject()))
* values.put(SUBJECT, message.getPseudoSubject());
*
* values.put(REPLY_PATH_PRESENT, message.isReplyPathPresent());
* values.put(SERVICE_CENTER, message.getServiceCenterAddress());
* values.put(BODY, message.getMessageBody());
* values.put(TYPE, type);
* values.put(THREAD_ID, threadId);*/
var insert = new Message()
{
Address = message.getSender(),
AddressDeviceId = message.getSenderDeviceId(),
DateReceived = TimeUtil.GetDateTimeMillis(), // force precision to millis not to ticks
DateSent = TimeUtil.GetDateTime(message.getSentTimestampMillis()),
Read = !unread,
Body = message.getMessageBody(),
Type = type,
ThreadId = threadId
};
long rows = conn.Insert(insert);
long messageId = insert.MessageId;
if (unread)
{
DatabaseFactory.getThreadDatabase().SetUnread(threadId);
}
DatabaseFactory.getThreadDatabase().Refresh(threadId);
notifyConversationListeners(threadId);
//jobManager.add(new TrimThreadJob(context, threadId)); // TODO
return(new Pair <long, long>(messageId, threadId));
}
