/// <summary>
/// Decrypt a received <see cref="SignalServiceEnvelope"/>
/// </summary>
/// <param name="envelope">The received SignalServiceEnvelope</param>
/// <returns>a decrypted SignalServiceContent</returns>
public SignalServiceContent decrypt(SignalServiceEnvelope envelope)
{
try
{
SignalServiceContent content = new SignalServiceContent();
if (envelope.hasLegacyMessage())
{
DataMessage message = DataMessage.ParseFrom(decrypt(envelope, envelope.getLegacyMessage()));
content = new SignalServiceContent(createSignalServiceMessage(envelope, message));
}
else if (envelope.hasContent())
{
Content message = Content.ParseFrom(decrypt(envelope, envelope.getContent()));
if (message.HasDataMessage)
{
content = new SignalServiceContent(createSignalServiceMessage(envelope, message.DataMessage));
}
else if (message.HasSyncMessage && localAddress.getNumber().Equals(envelope.getSource()))
{
content = new SignalServiceContent(createSynchronizeMessage(envelope, message.SyncMessage));
}
}
return(content);
}
catch (InvalidProtocolBufferException e)
{
throw new InvalidMessageException(e);
}
}
private async Task HandleSessionResetMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
SignalConversation conversation;
string prefix;
string conversationId;
Guid? conversationGuid;
long composedTimestamp;
if (isSync)
{
var sent = content.SynchronizeMessage.Sent;
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
composedTimestamp = sent.Timestamp;
author = null;
prefix = "You have";
conversationId = sent.Destination.E164;
conversationGuid = sent.Destination.Uuid;
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = await SignalDBContext.GetOrCreateContactLocked(content.Sender.E164, content.Sender.Uuid);
prefix = $"{author.ThreadDisplayName} has";
composedTimestamp = envelope.GetTimestamp();
conversationId = content.Sender.E164;
conversationGuid = content.Sender.Uuid;
}
LibsignalDBContext.DeleteAllSessions(conversationId);
conversation = await SignalDBContext.GetOrCreateContactLocked(conversationId, conversationGuid);
SignalMessage sm = new SignalMessage()
{
Direction = type,
Type = SignalMessageType.SessionReset,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{prefix} reset the session."
},
ThreadId = conversationId,
ThreadGuid = conversationGuid,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
};
await SignalLibHandle.Instance.SaveAndDispatchSignalMessage(sm, null, conversation);
}
/// <summary>
/// Decrypt a received <see cref="SignalServiceEnvelope"/>
/// </summary>
/// <param name="envelope">The received SignalServiceEnvelope</param>
/// <returns>a decrypted SignalServiceContent</returns>
public SignalServiceContent Decrypt(SignalServiceEnvelope envelope)
{
try
{
SignalServiceContent content = new SignalServiceContent();
if (envelope.HasLegacyMessage())
{
DataMessage message = DataMessage.Parser.ParseFrom(Decrypt(envelope, envelope.GetLegacyMessage()));
content = new SignalServiceContent()
{
Message = CreateSignalServiceMessage(envelope, message)
};
}
else if (envelope.HasContent())
{
Content message = Content.Parser.ParseFrom(Decrypt(envelope, envelope.GetContent()));
if (message.DataMessageOneofCase == Content.DataMessageOneofOneofCase.DataMessage)
{
content = new SignalServiceContent()
{
Message = CreateSignalServiceMessage(envelope, message.DataMessage)
};
}
else if (message.SyncMessageOneofCase == Content.SyncMessageOneofOneofCase.SyncMessage && LocalAddress.E164number == envelope.GetSource())
{
content = new SignalServiceContent()
{
SynchronizeMessage = CreateSynchronizeMessage(envelope, message.SyncMessage)
};
}
else if (message.CallMessageOneofCase == Content.CallMessageOneofOneofCase.CallMessage)
{
content = new SignalServiceContent()
{
CallMessage = CreateCallMessage(message.CallMessage)
};
}
else if (message.ReceiptMessageOneofCase == Content.ReceiptMessageOneofOneofCase.ReceiptMessage)
{
content = new SignalServiceContent()
{
ReadMessage = CreateReceiptMessage(envelope, message.ReceiptMessage)
};
}
}
return(content);
}
catch (InvalidProtocolBufferException e)
{
throw new InvalidMessageException(e);
}
}
private void HandleSessionResetMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
string prefix;
string conversationId;
long composedTimestamp;
if (isSync)
{
var sent = content.SynchronizeMessage.getSent().ForceGetValue();
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
composedTimestamp = sent.getTimestamp();
author = null;
prefix = "You have";
conversationId = sent.getDestination().ForceGetValue();
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp, this);
prefix = $"{author.ThreadDisplayName} has";
composedTimestamp = envelope.getTimestamp();
conversationId = envelope.getSource();
}
LibsignalDBContext.DeleteAllSessions(conversationId);
SignalMessage sm = new SignalMessage()
{
Direction = type,
Type = SignalMessageType.SessionReset,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{prefix} reset the session."
},
ThreadId = conversationId,
DeviceId = (uint)envelope.getSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
};
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await UIHandleIncomingMessage(sm);
}).AsTask().Wait();
}
/// <summary>
/// Decrypt a received <see cref="SignalServiceEnvelope"/>
/// </summary>
/// <param name="envelope">The received SignalServiceEnvelope</param>
/// <returns>a decrypted SignalServiceContent</returns>
public SignalServiceContent?Decrypt(SignalServiceEnvelope envelope)
{
try
{
if (envelope.HasLegacyMessage())
{
Plaintext plaintext = Decrypt(envelope, envelope.GetLegacyMessage());
DataMessage dataMessage = DataMessage.Parser.ParseFrom(plaintext.data);
SignalServiceContentProto contentProto = new SignalServiceContentProto()
{
LocalAddress = SignalServiceAddressProtobufSerializer.ToProtobuf(localAddress),
Metadata = SignalServiceMetadataProtobufSerializer.ToProtobuf(plaintext.Metadata),
LegacyDataMessage = dataMessage
};
return(SignalServiceContent.CreateFromProto(contentProto));
}
else if (envelope.HasContent())
{
Plaintext plaintext = Decrypt(envelope, envelope.Envelope.Content.ToByteArray());
Content content = Content.Parser.ParseFrom(plaintext.data);
SignalServiceContentProto contentProto = new SignalServiceContentProto()
{
LocalAddress = SignalServiceAddressProtobufSerializer.ToProtobuf(localAddress),
Metadata = SignalServiceMetadataProtobufSerializer.ToProtobuf(plaintext.Metadata),
Content = content
};
return(SignalServiceContent.CreateFromProto(contentProto));
}
return(null);
}
catch (InvalidProtocolBufferException e)
{
throw new InvalidMetadataMessageException(e);
}
}
private void HandleSignalMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
string threadId;
long composedTimestamp;
string body = dataMessage.Body != null ? dataMessage.Body : "";
if (dataMessage.Group != null)
{
var rawId = dataMessage.Group.GroupId;
threadId = Base64.encodeBytes(rawId);
var g = SignalDBContext.GetOrCreateGroupLocked(threadId, timestamp, this);
if (!g.CanReceive)
{
SignalServiceGroup group = new SignalServiceGroup()
{
Type = SignalServiceGroup.GroupType.REQUEST_INFO,
GroupId = rawId
};
SignalServiceDataMessage requestInfoMessage = new SignalServiceDataMessage()
{
Group = group,
Timestamp = Util.CurrentTimeMillis()
};
MessageSender.sendMessage(envelope.getSourceAddress(), requestInfoMessage);
}
composedTimestamp = envelope.getTimestamp();
}
else
{
if (isSync)
{
var sent = content.SynchronizeMessage.getSent().ForceGetValue();
threadId = SignalDBContext.GetOrCreateContactLocked(sent.getDestination().ForceGetValue(), timestamp, this).ThreadId;
composedTimestamp = sent.getTimestamp();
}
else
{
threadId = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp, this).ThreadId;
composedTimestamp = envelope.getTimestamp();
}
}
if (isSync)
{
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
author = null;
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp, this);
}
List <SignalAttachment> attachments = new List <SignalAttachment>();
SignalMessage message = new SignalMessage()
{
Direction = type,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = body
},
ThreadId = threadId,
DeviceId = (uint)envelope.getSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
AttachmentsCount = (uint)attachments.Count,
Attachments = attachments
};
if (dataMessage.Attachments != null)
{
var receivedAttachments = dataMessage.Attachments;
foreach (var receivedAttachment in receivedAttachments)
{
var pointer = receivedAttachment.asPointer();
SignalAttachment sa = new SignalAttachment()
{
Message = message,
Status = (uint)SignalAttachmentStatus.Default,
SentFileName = pointer.FileName,
ContentType = "",
Key = pointer.Key,
Relay = pointer.Relay,
StorageId = pointer.Id
};
attachments.Add(sa);
}
}
Debug.WriteLine("received message: " + message.Content);
if (type == SignalMessageDirection.Incoming)
{
if (App.WindowActive)
{
Utils.TryVibrate(true);
}
else
{
SendTileNotification(message);
SendMessageNotification(message);
}
}
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await UIHandleIncomingMessage(message);
}).AsTask().Wait();
}
private void HandleGroupUpdateMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
if (dataMessage.Group != null) //TODO check signal droid: group messages have different types!
{
SignalServiceGroup group = dataMessage.Group;
string groupid = Base64.encodeBytes(group.GroupId);
SignalGroup g = new SignalGroup();
string displayname = "Unknown group";
string avatarfile = null;
if (group.Name != null)
{
displayname = group.Name;
}
var dbgroup = SignalDBContext.InsertOrUpdateGroupLocked(groupid, displayname, avatarfile, true, timestamp, this);
if (group.Members != null)
{
foreach (var member in group.Members)
{
SignalDBContext.InsertOrUpdateGroupMembershipLocked(dbgroup.Id, SignalDBContext.GetOrCreateContactLocked(member, 0, this).Id);
}
}
/* insert message into conversation */
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
string prefix;
long composedTimestamp;
if (isSync)
{
var sent = content.SynchronizeMessage.getSent().ForceGetValue();
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
composedTimestamp = sent.getTimestamp();
author = null;
prefix = "You have";
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp, this);
prefix = $"{author.ThreadDisplayName} has";
composedTimestamp = envelope.getTimestamp();
}
SignalMessage sm = new SignalMessage()
{
Direction = type,
Type = SignalMessageType.GroupUpdate,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{prefix} updated the group."
},
ThreadId = groupid,
DeviceId = (uint)envelope.getSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
};
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await UIHandleIncomingMessage(sm);
}).AsTask().Wait();
}
else
{
Debug.WriteLine("received group update without group info!");
}
}
private async Task HandleSignalMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
SignalConversation conversation;
long composedTimestamp;
string body = dataMessage.Body ?? "";
if (dataMessage.Group != null)
{
var rawId = dataMessage.Group.GroupId;
var threadId = Base64.EncodeBytes(rawId);
conversation = await SignalDBContext.GetOrCreateGroupLocked(threadId, timestamp);
if (!conversation.CanReceive)
{
SignalServiceGroup group = new SignalServiceGroup()
{
Type = SignalServiceGroup.GroupType.REQUEST_INFO,
GroupId = rawId
};
SignalServiceDataMessage requestInfoMessage = new SignalServiceDataMessage()
{
Group = group,
Timestamp = Util.CurrentTimeMillis()
};
SignalLibHandle.Instance.OutgoingQueue.Add(new SignalServiceDataMessageSendable(requestInfoMessage, envelope.GetSourceAddress()));
}
composedTimestamp = envelope.GetTimestamp();
}
else
{
if (isSync)
{
var sent = content.SynchronizeMessage.Sent;
conversation = await SignalDBContext.GetOrCreateContactLocked(sent.Destination.ForceGetValue(), timestamp);
composedTimestamp = sent.Timestamp;
}
else
{
conversation = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), timestamp);
composedTimestamp = envelope.GetTimestamp();
}
}
if (isSync)
{
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
author = null;
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), timestamp);
}
if (author != null && author.Blocked)
{
// Don't save blocked messages
return;
}
List <SignalAttachment> attachments = new List <SignalAttachment>();
SignalMessage message = new SignalMessage()
{
Direction = type,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = body.Truncate(2000)
},
ThreadId = conversation.ThreadId,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
AttachmentsCount = (uint)attachments.Count,
Attachments = attachments
};
if (dataMessage.Attachments != null)
{
var receivedAttachments = dataMessage.Attachments;
foreach (var receivedAttachment in receivedAttachments)
{
var pointer = receivedAttachment.AsPointer();
SignalAttachment sa = new SignalAttachment()
{
Message = message,
Status = (uint)SignalAttachmentStatus.Default,
SentFileName = pointer.FileName,
ContentType = receivedAttachment.ContentType,
Key = pointer.Key,
Relay = pointer.Relay,
StorageId = pointer.Id,
Size = (long)pointer.Size,
Digest = pointer.Digest
};
attachments.Add(sa);
}
// Make sure to update attachments count
message.AttachmentsCount = (uint)attachments.Count;
}
await SignalLibHandle.Instance.SaveAndDispatchSignalMessage(message, null, conversation);
}
private async Task HandleGroupUpdateMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
if (dataMessage.Group != null) //TODO check signal droid: group messages have different types!
{
SignalServiceGroup group = dataMessage.Group;
string groupid = Base64.EncodeBytes(group.GroupId);
SignalGroup g = new SignalGroup();
string displayname = "Unknown group";
string avatarfile = null;
if (group.Name != null)
{
displayname = group.Name;
}
var dbgroup = SignalDBContext.InsertOrUpdateGroupLocked(groupid, displayname, avatarfile, true, timestamp);
if (group.Members != null)
{
foreach (var member in group.Members)
{
SignalDBContext.InsertOrUpdateGroupMembershipLocked(dbgroup.Id, (await SignalDBContext.GetOrCreateContactLocked(member, 0)).Id);
}
}
/* insert message into conversation */
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
string prefix;
long composedTimestamp;
if (isSync)
{
var sent = content.SynchronizeMessage.Sent;
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
composedTimestamp = sent.Timestamp;
author = null;
prefix = "You have";
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), timestamp);
prefix = $"{author.ThreadDisplayName} has";
composedTimestamp = envelope.GetTimestamp();
}
SignalMessage sm = new SignalMessage()
{
Direction = type,
Type = SignalMessageType.GroupUpdate,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{prefix} updated the group."
},
ThreadId = groupid,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
};
SignalDBContext.SaveMessageLocked(sm);
dbgroup.MessagesCount += 1;
if (sm.Direction == SignalMessageDirection.Incoming)
{
dbgroup.UnreadCount += 1;
}
else
{
dbgroup.UnreadCount = 0;
dbgroup.LastSeenMessageIndex = dbgroup.MessagesCount;
}
dbgroup.LastMessage = sm;
await SignalLibHandle.Instance.DispatchAddOrUpdateConversation(dbgroup, sm);
}
else
{
Logger.LogError("HandleGroupUpdateMessage() received group update without group info");
}
}
private async Task HandleGroupLeaveMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalServiceGroup sentGroup = dataMessage.Group;
if (sentGroup != null)
{
string groupid = Base64.EncodeBytes(sentGroup.GroupId);
SignalGroup group = await SignalDBContext.GetOrCreateGroupLocked(groupid, 0);
if (isSync)
{
SignalContact author = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), 0);
SignalMessage sm = new SignalMessage()
{
Direction = SignalMessageDirection.Incoming,
Type = SignalMessageType.GroupLeave,
Status = SignalMessageStatus.Received,
Author = author,
Content = new SignalMessageContent()
{
Content = $"You have left the group."
},
ThreadId = groupid,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = envelope.GetTimestamp(),
ReceivedTimestamp = timestamp,
};
SignalConversation updatedConversation = SignalDBContext.RemoveMemberFromGroup(groupid, author, sm);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversation(updatedConversation, sm);
}
else
{
SignalContact author = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), 0);
SignalMessage sm = new SignalMessage()
{
Direction = SignalMessageDirection.Incoming,
Type = SignalMessageType.GroupLeave,
Status = SignalMessageStatus.Received,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{author.ThreadDisplayName} has left the group."
},
ThreadId = groupid,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = envelope.GetTimestamp(),
ReceivedTimestamp = timestamp,
};
SignalConversation updatedConversation = SignalDBContext.RemoveMemberFromGroup(groupid, author, sm);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversation(updatedConversation, sm);
}
}
else
{
Logger.LogError("HandleGroupLeaveMessage() received group update without group info");
}
}
private async Task HandleExpirationUpdateMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage message, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
string prefix;
SignalConversation conversation;
long composedTimestamp;
if (isSync)
{
var sent = content.SynchronizeMessage.Sent;
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
composedTimestamp = sent.Timestamp;
author = null;
prefix = "You have";
if (message.Group != null)
{
conversation = await SignalDBContext.GetOrCreateGroupLocked(Base64.EncodeBytes(message.Group.GroupId), 0);
}
else
{
conversation = await SignalDBContext.GetOrCreateContactLocked(sent.Destination.ForceGetValue(), 0);
}
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), timestamp);
prefix = $"{author.ThreadDisplayName} has";
composedTimestamp = envelope.GetTimestamp();
if (message.Group != null)
{
conversation = await SignalDBContext.GetOrCreateGroupLocked(Base64.EncodeBytes(message.Group.GroupId), 0);
}
else
{
conversation = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), 0);
}
}
conversation.ExpiresInSeconds = (uint)message.ExpiresInSeconds;
SignalDBContext.UpdateExpiresInLocked(conversation);
SignalMessage sm = new SignalMessage()
{
Direction = type,
Type = SignalMessageType.ExpireUpdate,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = $"{prefix} set the expiration timer to {message.ExpiresInSeconds} seconds."
},
ThreadId = conversation.ThreadId,
DeviceId = (uint)envelope.GetSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
};
await SignalLibHandle.Instance.SaveAndDispatchSignalMessage(sm, null, conversation);
}
private void handleMessage(SignalServiceEnvelope envelope, May <long> smsMessageId)
{
try
{
SignalProtocolStore axolotlStore = new TextSecureAxolotlStore();
SignalServiceAddress localAddress = new SignalServiceAddress(TextSecurePreferences.getLocalNumber());
SignalServiceCipher cipher = new SignalServiceCipher(localAddress, axolotlStore);
SignalServiceContent content = cipher.decrypt(envelope);
if (content.getDataMessage().HasValue)
{
SignalServiceDataMessage message = content.getDataMessage().ForceGetValue();
if (message.isEndSession())
{
handleEndSessionMessage(envelope, message, smsMessageId);
}
else if (message.isGroupUpdate())
{
handleGroupMessage(envelope, message, smsMessageId);
}
else if (message.getAttachments().HasValue)
{
handleMediaMessage(envelope, message, smsMessageId);
}
else
{
handleTextMessage(envelope, message, smsMessageId);
}
}
/*else if (content.getSyncMessage().HasValue) TODO: SYNC enable
* {
* TextSecureSyncMessage syncMessage = content.getSyncMessage().ForceGetValue();
*
* if (syncMessage.getSent().HasValue) handleSynchronizeSentMessage(masterSecret, syncMessage.getSent().ForceGetValue(), smsMessageId);
* else if (syncMessage.getRequest().HasValue) handleSynchronizeRequestMessage(masterSecret, syncMessage.getRequest().ForceGetValue());
* }*/
if (envelope.isPreKeySignalMessage())
{
App.Current.Worker.AddTaskActivities(new RefreshPreKeysTask());
//ApplicationContext.getInstance(context).getJobManager().add(new RefreshPreKeysJob(context));
}
}
catch (InvalidVersionException e)
{
Log.Warn(e);
handleInvalidVersionMessage(envelope, smsMessageId);
}
catch (InvalidMessageException e)
{
Log.Warn(e);
handleCorruptMessage(envelope, smsMessageId);
}
catch (InvalidKeyIdException e)
{
Log.Warn(e);
handleCorruptMessage(envelope, smsMessageId);
}
catch (InvalidKeyException e)
{
Log.Warn(e);
handleCorruptMessage(envelope, smsMessageId);
}
catch (NoSessionException e)
{
Log.Warn(e);
handleNoSessionMessage(envelope, smsMessageId);
}
catch (LegacyMessageException e)
{
Log.Warn(e);
handleLegacyMessage(envelope, smsMessageId);
}
catch (DuplicateMessageException e)
{
Log.Warn(e);
handleDuplicateMessage(envelope, smsMessageId);
}
catch (libsignal.exceptions.UntrustedIdentityException e)
{
Log.Warn(e);
handleUntrustedIdentityMessage(envelope, smsMessageId);
}
catch (Exception e)
{
Log.Warn($"Unexpected Exception");
}
}
private void HandleSignalMessage(SignalServiceEnvelope envelope, SignalServiceContent content, SignalServiceDataMessage dataMessage, bool isSync, long timestamp)
{
SignalMessageDirection type;
SignalContact author;
SignalMessageStatus status;
SignalConversation conversation;
long composedTimestamp;
string body = dataMessage.Body ?? "";
if (dataMessage.Group != null)
{
var rawId = dataMessage.Group.GroupId;
var threadId = Base64.encodeBytes(rawId);
conversation = SignalDBContext.GetOrCreateGroupLocked(threadId, timestamp);
if (!conversation.CanReceive)
{
SignalServiceGroup group = new SignalServiceGroup()
{
Type = SignalServiceGroup.GroupType.REQUEST_INFO,
GroupId = rawId
};
SignalServiceDataMessage requestInfoMessage = new SignalServiceDataMessage()
{
Group = group,
Timestamp = Util.CurrentTimeMillis()
};
//MessageSender.sendMessage(envelope.getSourceAddress(), requestInfoMessage); TODO
}
composedTimestamp = envelope.getTimestamp();
}
else
{
if (isSync)
{
var sent = content.SynchronizeMessage.getSent().ForceGetValue();
conversation = SignalDBContext.GetOrCreateContactLocked(sent.getDestination().ForceGetValue(), timestamp);
composedTimestamp = sent.getTimestamp();
}
else
{
conversation = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp);
composedTimestamp = envelope.getTimestamp();
}
}
if (isSync)
{
type = SignalMessageDirection.Synced;
status = SignalMessageStatus.Confirmed;
author = null;
}
else
{
status = 0;
type = SignalMessageDirection.Incoming;
author = SignalDBContext.GetOrCreateContactLocked(envelope.getSource(), timestamp);
}
List <SignalAttachment> attachments = new List <SignalAttachment>();
SignalMessage message = new SignalMessage()
{
Direction = type,
Status = status,
Author = author,
Content = new SignalMessageContent()
{
Content = body
},
ThreadId = conversation.ThreadId,
DeviceId = (uint)envelope.getSourceDevice(),
Receipts = 0,
ComposedTimestamp = composedTimestamp,
ReceivedTimestamp = timestamp,
AttachmentsCount = (uint)attachments.Count,
Attachments = attachments
};
if (dataMessage.Attachments != null)
{
var receivedAttachments = dataMessage.Attachments;
foreach (var receivedAttachment in receivedAttachments)
{
var pointer = receivedAttachment.asPointer();
SignalAttachment sa = new SignalAttachment()
{
Message = message,
Status = (uint)SignalAttachmentStatus.Default,
SentFileName = pointer.FileName,
ContentType = "",
Key = pointer.Key,
Relay = pointer.Relay,
StorageId = pointer.Id
};
attachments.Add(sa);
}
}
SignalLibHandle.Instance.SaveAndDispatchSignalMessage(message, conversation);
}
