public static SignalGroup GetOrCreateGroupLocked(string groupId, long timestamp)
{
SignalGroup dbgroup;
lock (DBLock)
{
using (var ctx = new SignalDBContext())
{
dbgroup = ctx.Groups
.Where(g => g.ThreadId == groupId)
.Include(g => g.GroupMemberships)
.ThenInclude(gm => gm.Contact)
.SingleOrDefault();
if (dbgroup == null)
{
dbgroup = new SignalGroup()
{
ThreadId = groupId,
ThreadDisplayName = "Unknown group",
LastActiveTimestamp = timestamp,
AvatarFile = null,
UnreadCount = 0,
CanReceive = false,
GroupMemberships = new List <GroupMembership>()
};
ctx.Add(dbgroup);
ctx.SaveChanges();
}
}
}
return(dbgroup);
}
public SignalManager(List <string> groupNames, List <string> channelNames)
{
foreach (string groupName in groupNames)
{
_signalGroupDict[groupName] = new SignalGroup(groupName, channelNames);
}
}
//加载路网
private void InitialSystem()
{
vis = new Vissim();
vis.LoadNet(@"E:\vissim4.3\Example\lianglukou.inp", 0);
vis.Simulation.Resolution = 1;
vis.Evaluation.set_AttValue("DATACOLLECTION", true); //软件激活datacollection检测器评价
vis.Evaluation.set_AttValue("TRAVELTIME", true); //软件激活traveltime检测器评价
vis.Evaluation.set_AttValue("QUEUECOUNTER", true); //软件激活queuecounter检测器评价
vis.Evaluation.set_AttValue("DELAY", true); //软件激活dealy检测器评价
//设置各检测器的评价周期
label15.Text = ""; //仿真步数显示控件初始化
progressBar1.Minimum = 0; //进度条显示控件最小值设置
progressBar1.Maximum = Convert.ToInt32(vis.Simulation.Period); //进度条显示控件最大值设置
//仿真信息表格展示
VehicleInputs vehins = vis.Net.VehicleInputs;
listView2.Clear();
listView2.View = View.Details;
listView2.FullRowSelect = true;
listView2.Columns.Add("交叉口ID", 100, HorizontalAlignment.Center);
listView2.Columns.Add("延时时间(s)", 100, HorizontalAlignment.Center);
listView2.Columns.Add("仿真时间(s)", 100, HorizontalAlignment.Center);
listView2.Columns.Add("输入交通量(pcu)", 100, HorizontalAlignment.Center);
for (int i = 1; i <= vehins.Count; i++)
{
ListViewItem itm = listView2.Items.Add(vehins[i].ID.ToString());
itm.SubItems.AddRange(new string[] { (vehins[i].AttValue["TIMEFROM"]).ToString(), vis.Simulation.Period.ToString(), (string)(vehins[i].AttValue["VOLUME"]).ToString() });
}
//修改vissim中各交叉口信号机周期
for (int i = 1; i <= 4; i++)
{
vis.Net.SignalControllers.GetSignalControllerByNumber(i).AttValue["CYCLETIME"] = infoArr[i - 1];
groups = vis.Net.SignalControllers[i].SignalGroups;
for (int j = 1; j <= Convert.ToInt32(groups.Count); j++)
{
group = groups.GetSignalGroupByNumber(j);
if (j == 1)
{
group.AttValue["GREENEND"] = firstgreenArr[i - 1];
group.AttValue["REDEND"] = 0;
group.AttValue["AMBER"] = 3;
}
else
{
group.AttValue["GREENEND"] = infoArr[i - 1] - 3;
group.AttValue["REDEND"] = infoArr[i - 1] - secondgreenArr[i - 1] - 3;
group.AttValue["AMBER"] = 3;
}
}
}
}
public static SignalGroup InsertOrUpdateGroupLocked(string groupId, string displayname, string avatarfile, bool canReceive, long timestamp, MainPageViewModel mpvm)
{
SignalGroup dbgroup;
bool is_new = false;
lock (DBLock)
{
using (var ctx = new SignalDBContext())
{
dbgroup = ctx.Groups
.Where(g => g.ThreadId == groupId)
.Include(g => g.GroupMemberships)
.ThenInclude(gm => gm.Contact)
.SingleOrDefault();
if (dbgroup == null)
{
is_new = true;
dbgroup = new SignalGroup()
{
ThreadId = groupId,
ThreadDisplayName = displayname,
LastActiveTimestamp = timestamp,
AvatarFile = avatarfile,
UnreadCount = 0,
CanReceive = canReceive,
GroupMemberships = new List <GroupMembership>()
};
ctx.Add(dbgroup);
}
else
{
dbgroup.ThreadDisplayName = displayname;
dbgroup.LastActiveTimestamp = timestamp;
dbgroup.AvatarFile = avatarfile;
dbgroup.CanReceive = true;
}
ctx.SaveChanges();
}
if (is_new)
{
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
mpvm.AddThread(dbgroup);
}).AsTask().Wait();
}
else
{
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, () =>
{
mpvm.UIUpdateThread(dbgroup);
}).AsTask().Wait();
}
}
return(dbgroup);
}
public void ReLoadSignalsAndSignalGroups()
{
m_angleReference.GetPoints(out MetadataBase angleReference);
AllSignals allSignals = new AllSignals();
AllSignalGroups allSignalGroups = new AllSignalGroups();
m_allSignals.Clear();
allSignals.Signals.ForEach(x => m_allSignals.Add(x.MakeSignal()));
Dictionary <ulong, MetadataBase> allPoints = m_allSignals.ToDictionary(signal => signal.HistorianId.Value);
m_allSignalGroups.Clear();
allSignalGroups.SignalGroups.ForEach(x =>
{
SignalGroup group = x.CreateGroup(allPoints, angleReference);
group.GetAllSignals().ToList().ForEach(y => m_allSignals.Add(y));
m_allSignalGroups.Add(group);
});
}
void initNet()
{
vissim = new Vissim();
vissim.LoadNet(vissimMapFilePath);
net = vissim.Net;
simulation = vissim.Simulation;
simulation.Resolution = 4;
if (net.SignalControllers.Count != 0)
{
signalController = net.SignalControllers.GetSignalControllerByNumber(1);
signalGroup = signalController.SignalGroups.GetSignalGroupByNumber(1);
}
check();
while ((vehicle = getVehicle(1)) == null)
{
RunSingle();
}
}
public static SignalGroup InsertOrUpdateGroupLocked(string groupId, string displayname, string avatarfile, bool canReceive, long timestamp)
{
SignalGroup dbgroup;
lock (DBLock)
{
using (var ctx = new SignalDBContext())
{
dbgroup = ctx.Groups
.Where(g => g.ThreadId == groupId)
.Include(g => g.GroupMemberships)
.ThenInclude(gm => gm.Contact)
.SingleOrDefault();
if (dbgroup == null)
{
dbgroup = new SignalGroup()
{
ThreadId = groupId,
ThreadDisplayName = displayname,
LastActiveTimestamp = timestamp,
AvatarFile = avatarfile,
UnreadCount = 0,
CanReceive = canReceive,
GroupMemberships = new List <GroupMembership>()
};
ctx.Add(dbgroup);
}
else
{
dbgroup.ThreadDisplayName = displayname;
dbgroup.LastActiveTimestamp = timestamp;
dbgroup.AvatarFile = avatarfile;
dbgroup.CanReceive = true;
}
ctx.SaveChanges();
}
}
return(dbgroup);
}
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 HandleMessage(SignalServiceEnvelope envelope)
{
var cipher = new SignalServiceCipher(new SignalServiceAddress(SignalLibHandle.Instance.Store.Username), new Store());
var content = cipher.Decrypt(envelope);
long timestamp = Util.CurrentTimeMillis();
if (content.Message != null)
{
SignalServiceDataMessage message = content.Message;
if (message.EndSession)
{
await HandleSessionResetMessage(envelope, content, message, false, timestamp);
}
else if (message.IsGroupUpdate())
{
if (message.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, message, false, timestamp);
}
else if (message.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received REQUEST_INFO request");
}
}
else if (message.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, message, false, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, message, false, timestamp);
}
}
else if (content.SynchronizeMessage != null)
{
if (content.SynchronizeMessage.Sent != null)
{
var syncMessage = content.SynchronizeMessage.Sent;
var dataMessage = syncMessage.Message;
if (dataMessage.EndSession)
{
await HandleSessionResetMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.IsGroupUpdate())
{
if (dataMessage.Group.Type == SignalServiceGroup.GroupType.UPDATE)
{
await HandleGroupUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.QUIT)
{
await HandleGroupLeaveMessage(envelope, content, dataMessage, true, timestamp);
}
else if (dataMessage.Group.Type == SignalServiceGroup.GroupType.REQUEST_INFO)
{
Logger.LogWarning("Received synced REQUEST_INFO request");
}
}
else if (dataMessage.ExpirationUpdate)
{
await HandleExpirationUpdateMessage(envelope, content, dataMessage, true, timestamp);
}
else
{
await HandleSignalMessage(envelope, content, dataMessage, true, timestamp);
}
}
else if (content.SynchronizeMessage.Reads != null)
{
var readMessages = content.SynchronizeMessage.Reads;
foreach (var readMessage in readMessages)
{
try
{
await HandleSyncedReadMessage(readMessage);
}
catch (Exception e)
{
Logger.LogError("HandleReadMessage failed: {0}\n{1}", e.Message, e.StackTrace);
}
}
}
else if (content.SynchronizeMessage.BlockedList != null)
{
List <string> blockedNumbers = content.SynchronizeMessage.BlockedList.Numbers;
await HandleBlockedNumbers(blockedNumbers);
}
else if (content.SynchronizeMessage.Groups != null)
{
Logger.LogInformation("HandleMessage() handling groups sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
var groups = content.SynchronizeMessage.Groups;
using (var tmpFile = LibUtils.CreateTmpFile("groups_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, groups.AsPointer(), tmpFile, 10000, null);
var deviceGroupsStream = new DeviceGroupsInputStream(plaintextStream);
var groupsList = new List <(SignalGroup, IList <string>)>();
DeviceGroup g;
while ((g = deviceGroupsStream.Read()) != null)
{
if (g.Avatar != null)
{
SignalServiceAttachmentStream ssas = g.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
var group = new SignalGroup()
{
ThreadDisplayName = g.Name,
ThreadId = Base64.EncodeBytes(g.Id),
GroupMemberships = new List <GroupMembership>(),
CanReceive = true,
ExpiresInSeconds = g.ExpirationTimer != null ? g.ExpirationTimer.Value : 0
};
groupsList.Add((group, g.Members));
}
List <SignalConversation> dbGroups = await SignalDBContext.InsertOrUpdateGroups(groupsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbGroups);
}
}
else if (content.SynchronizeMessage.Contacts != null && content.SynchronizeMessage.Contacts.Complete) //TODO incomplete updates
{
Logger.LogInformation("HandleMessage() handling contacts sync message from device {0}", envelope.GetSourceDevice());
int read;
var avatarBuffer = new byte[4096];
ContactsMessage contacts = content.SynchronizeMessage.Contacts;
using (var tmpFile = LibUtils.CreateTmpFile("contacts_sync"))
{
var plaintextStream = await MessageReceiver.RetrieveAttachment(Token, contacts.Contacts.AsPointer(), tmpFile, 10000, null);
var deviceContactsStream = new DeviceContactsInputStream(plaintextStream);
List <SignalContact> contactsList = new List <SignalContact>();
DeviceContact c;
while ((c = deviceContactsStream.Read()) != null)
{
if (c.Avatar != null)
{
SignalServiceAttachmentStream ssas = c.Avatar.AsStream();
while ((read = ssas.InputStream.Read(avatarBuffer, 0, avatarBuffer.Length)) > 0)
{
}
}
SignalContact contact = new SignalContact()
{
ThreadDisplayName = c.Name,
ThreadId = c.Number,
Color = c.Color,
CanReceive = true,
ExpiresInSeconds = c.ExpirationTimer != null ? c.ExpirationTimer.Value : 0
};
contactsList.Add(contact);
}
var dbContacts = SignalDBContext.InsertOrUpdateContacts(contactsList);
await SignalLibHandle.Instance.DispatchAddOrUpdateConversations(dbContacts);
}
}
}
else if (content.ReadMessage != null)
{
SignalServiceReceiptMessage receiptMessage = content.ReadMessage;
Logger.LogTrace("HandleMessage() received ReceiptMessage (type={0}, when={1})", receiptMessage.ReceiptType, receiptMessage.When);
}
else
{
//TODO callmessages
Logger.LogWarning("HandleMessage() received unrecognized message");
}
}
public void DeactivateSignalGroup(SignalGroup signalGroup)
{
m_activeSignalGroups.Remove(signalGroup);
RefreshActivePoints();
}
public void ActivateSignalGroup(SignalGroup signalGroup)
{
m_activeSignalGroups.Add(signalGroup);
RefreshActivePoints();
}
/// <summary>
/// Reads pending messages from the <see cref="OutgoingQueue"/> and attempts to send them
/// </summary>
public void HandleOutgoingMessages()
{
Debug.WriteLine("HandleOutgoingMessages starting...");
CancellationToken token = CancelSource.Token;
while (!token.IsCancellationRequested)
{
SignalMessage outgoingSignalMessage = null;
try
{
outgoingSignalMessage = OutgoingQueue.Take(token);
SignalServiceDataMessage message = new SignalServiceDataMessage()
{
Body = outgoingSignalMessage.Content.Content,
Timestamp = outgoingSignalMessage.ComposedTimestamp,
ExpiresInSeconds = (int)outgoingSignalMessage.ExpiresAt
};
if (!outgoingSignalMessage.ThreadId.EndsWith("="))
{
if (!token.IsCancellationRequested)
{
MessageSender.sendMessage(new SignalServiceAddress(outgoingSignalMessage.ThreadId), message);
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
}
}
else
{
List <SignalServiceAddress> recipients = new List <SignalServiceAddress>();
SignalGroup g = SignalDBContext.GetOrCreateGroupLocked(outgoingSignalMessage.ThreadId, 0, this);
foreach (GroupMembership sc in g.GroupMemberships)
{
if (sc.Contact.ThreadId != App.Store.Username)
{
recipients.Add(new SignalServiceAddress(sc.Contact.ThreadId));
}
}
message.Group = new SignalServiceGroup()
{
GroupId = Base64.decode(g.ThreadId),
Type = SignalServiceGroup.GroupType.DELIVER
};
if (!token.IsCancellationRequested)
{
MessageSender.sendMessage(recipients, message);
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
}
}
}
catch (OperationCanceledException e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
Debug.WriteLine("HandleOutgoingMessages finished");
return;
}
catch (EncapsulatedExceptions exceptions)
{
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
Debug.WriteLine(exceptions.Message);
Debug.WriteLine(exceptions.StackTrace);
IList <UntrustedIdentityException> identityExceptions = exceptions.getUntrustedIdentityExceptions();
if (exceptions.getNetworkExceptions().Count > 0)
{
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Network;
}
if (identityExceptions.Count > 0)
{
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Identity;
}
foreach (UntrustedIdentityException e in identityExceptions)
{
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await MainPage.NotifyNewIdentity(e.getE164Number());
}).AsTask().Wait();
LibsignalDBContext.SaveIdentityLocked(new SignalProtocolAddress(e.getE164Number(), 1), Base64.encodeBytes(e.getIdentityKey().serialize()));
}
}
catch (RateLimitException e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Ratelimit;
}
catch (UntrustedIdentityException e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Identity;
Windows.ApplicationModel.Core.CoreApplication.MainView.CoreWindow.Dispatcher.RunAsync(Windows.UI.Core.CoreDispatcherPriority.Normal, async() =>
{
await MainPage.NotifyNewIdentity(e.getE164Number());
}).AsTask().Wait();
LibsignalDBContext.SaveIdentityLocked(new SignalProtocolAddress(e.getE164Number(), 1), Base64.encodeBytes(e.getIdentityKey().serialize()));
}
catch (Exception e)
{
Debug.WriteLine(e.Message);
Debug.WriteLine(e.StackTrace);
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Unknown;
}
SignalDBContext.UpdateMessageStatus(outgoingSignalMessage, this);
}
Debug.WriteLine("HandleOutgoingMessages finished");
}
public async Task HandleOutgoingMessages()
{
Logger.LogDebug("HandleOutgoingMessages()");
while (!Token.IsCancellationRequested)
{
SignalMessage outgoingSignalMessage = null;
try
{
outgoingSignalMessage = Handle.OutgoingQueue.Take(Token);
SignalServiceDataMessage message = new SignalServiceDataMessage()
{
Body = outgoingSignalMessage.Content.Content,
Timestamp = outgoingSignalMessage.ComposedTimestamp,
ExpiresInSeconds = (int)outgoingSignalMessage.ExpiresAt
};
if (!outgoingSignalMessage.ThreadId.EndsWith("="))
{
if (!Token.IsCancellationRequested)
{
await MessageSender.SendMessage(Token, new SignalServiceAddress(outgoingSignalMessage.ThreadId), message);
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
}
}
else
{
List <SignalServiceAddress> recipients = new List <SignalServiceAddress>();
SignalGroup g = await SignalDBContext.GetOrCreateGroupLocked(outgoingSignalMessage.ThreadId, 0);
foreach (GroupMembership sc in g.GroupMemberships)
{
if (sc.Contact.ThreadId != SignalLibHandle.Instance.Store.Username)
{
recipients.Add(new SignalServiceAddress(sc.Contact.ThreadId));
}
}
message.Group = new SignalServiceGroup()
{
GroupId = Base64.Decode(g.ThreadId),
Type = SignalServiceGroup.GroupType.DELIVER
};
if (!Token.IsCancellationRequested)
{
await SendMessage(recipients, message);
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
}
}
}
catch (OperationCanceledException)
{
Logger.LogInformation("HandleOutgoingMessages() finished");
return;
}
catch (EncapsulatedExceptions exceptions)
{
outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
Logger.LogError("HandleOutgoingMessages() encountered libsignal exceptions");
IList <UntrustedIdentityException> identityExceptions = exceptions.UntrustedIdentityExceptions;
if (exceptions.NetworkExceptions.Count > 0)
{
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Network;
}
if (identityExceptions.Count > 0)
{
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Identity;
}
foreach (UntrustedIdentityException e in identityExceptions)
{
await Handle.HandleOutgoingKeyChangeLocked(e.E164number, Base64.EncodeBytes(e.IdentityKey.serialize()));
}
}
catch (RateLimitException)
{
Logger.LogError("HandleOutgoingMessages() could not send due to rate limits");
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Ratelimit;
}
catch (UntrustedIdentityException e)
{
Logger.LogError("HandleOutgoingMessages() could not send due to untrusted identities");
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Identity;
await Handle.HandleOutgoingKeyChangeLocked(e.E164number, Base64.EncodeBytes(e.IdentityKey.serialize()));
}
catch (Exception e)
{
var line = new StackTrace(e, true).GetFrames()[0].GetFileLineNumber();
Logger.LogError("HandleOutgoingMessages() failed in line {0}: {1}\n{2}", line, e.Message, e.StackTrace);
outgoingSignalMessage.Status = SignalMessageStatus.Failed_Unknown;
}
await Handle.HandleMessageSentLocked(outgoingSignalMessage);
}
Logger.LogInformation("HandleOutgoingMessages() finished");
}
public SignalWrapper(SignalGroup signal)
{
Signal = signal;
}
public void DeactivateSignalGroup(SignalGroup signalGroup)
{
m_activeSignalGroups.Remove(signalGroup);
RefreshActivePoints();
}
public void ActivateSignalGroup(SignalGroup signalGroup)
{
m_activeSignalGroups.Add(signalGroup);
RefreshActivePoints();
}
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!");
}
}
public SignalWrapper(SignalGroup signal)
{
Signal = signal;
}
