internal static async void UpdateGroupLegibleID(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
{
return;
}
try
{
await service.GetBubbleGroupLegibleId(bubbleGroup, legibleID =>
{
bubbleGroup.LegibleId = legibleID;
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group legible ID: " + service.Information.ServiceName +
" - " + bubbleGroup.Address + ": " + ex);
if (finished != null)
{
finished();
}
}
}
protected internal void OnBubbleUpdated(VisualBubble bubble, BubbleGroup group)
{
if (Bubbles.Count >= BubblesCapSize)
{
Bubbles.RemoveAt(0);
}
var addedToEnd = false;
var unreadIndicatorGuid = BubbleGroupSettingsManager.GetUnreadIndicatorGuid(this);
for (int i = Bubbles.Count - 1; i >= 0; i--)
{
var nBubble = Bubbles[i];
var unreadIndicatorIndex = -1;
if (unreadIndicatorGuid != null && unreadIndicatorGuid == nBubble.ID)
{
unreadIndicatorIndex = i;
}
if (nBubble.Time <= bubble.Time)
{
// adding it to the end, we can do a simple contract
if (i == Bubbles.Count - 1)
{
addedToEnd = true;
Bubbles.Add(bubble);
if (bubble.Direction == Bubble.BubbleDirection.Incoming)
{
BubbleGroupSettingsManager.SetUnread(this, true);
}
}
// inserting, do a full contract
else
{
Bubbles.Insert(i + 1, bubble);
}
if (i >= unreadIndicatorIndex && bubble.Direction == Bubble.BubbleDirection.Outgoing)
{
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(this, bubble.ID, false);
}
break;
}
// could not find a valid place to insert, then skip insertion.
if (i == 0)
{
return;
}
}
if (SendingGroup != group && addedToEnd)
{
SendingGroup = group;
BubbleGroupEvents.RaiseSendingServiceChange(this);
}
RaiseBubbleInserted(bubble);
}
internal static void Update(BubbleGroup group, bool optimized = true, Action optimizedChainFinished = null)
{
if (optimized)
{
UpdateName(@group, () =>
{
UpdateGroupLegibleID(@group, () =>
{
UpdatePartyParticipants(@group, () =>
{
if (optimizedChainFinished != null)
{
optimizedChainFinished();
}
else
{
BubbleGroupEvents.RaiseRefreshed(@group);
BubbleGroupEvents.RaiseBubblesUpdated(@group);
BubbleGroupEvents.RaiseInformationUpdated(@group);
}
});
});
});
}
else
{
UpdateName(@group);
UpdateGroupLegibleID(@group);
UpdatePartyParticipants(@group);
}
}
public static void UpdatePartyParticipants(Service service,
string bubbleGroupAddress, Action <bool> finished = null)
{
var bubbleGroup =
BubbleGroupManager.FindWithAddress(service, bubbleGroupAddress);
if (bubbleGroup == null)
{
finished(false);
}
UpdatePartyParticipants(bubbleGroup, () =>
{
try
{
BubbleGroupEvents.RaiseBubblesUpdated(bubbleGroup);
}
catch
{
// do nothing
}
if (finished != null)
{
finished(true);
}
});
}
public static void SetNotQueuedToFailures(BubbleGroup group)
{
var groups = BubbleGroupManager.GetInner(@group).Where(x => !x.PartiallyLoaded &&
(x.Service.QueuedBubblesParameters != null &&
x.Service.QueuedBubblesParameters.SendingBubblesToFailOnServiceStart != null &&
x.Service.QueuedBubblesParameters.SendingBubblesToFailOnServiceStart.Any()));
var failed = new List <Tuple <BubbleGroup, VisualBubble> >();
foreach (var innerGroup in groups)
{
foreach (var bubble in innerGroup)
{
if (bubble.Direction == Bubble.BubbleDirection.Outgoing &&
bubble.Status == Bubble.BubbleStatus.Waiting)
{
if (innerGroup
.Service.QueuedBubblesParameters.SendingBubblesToFailOnServiceStart
.FirstOrDefault(x => x == bubble.GetType()) != null)
{
failed.Add(new Tuple <BubbleGroup, VisualBubble>(innerGroup, bubble));
}
}
}
}
if (!failed.Any())
{
return;
}
var somethingUpdated = false;
var failuresGroupedByBubbleGroup = failed.GroupBy(x => x.Item1);
foreach (var failureGroup in failuresGroupedByBubbleGroup)
{
var groupOfBubbles = failureGroup.First().Item1;
var bubbles = failureGroup.Select(x => x.Item2).ToArray();
foreach (var bubble in bubbles)
{
bubble.Status = Bubble.BubbleStatus.Failed;
}
BubbleGroupDatabase.UpdateBubble(groupOfBubbles, bubbles, groupOfBubbles.Bubbles.Count + 100); // 100 is really a tolerance here (just in case)
foreach (var bubble in bubbles)
{
BubbleGroupEvents.RaiseBubbleFailed(bubble, groupOfBubbles);
}
somethingUpdated = true;
}
if (somethingUpdated)
{
BubbleGroupEvents.RaiseBubblesUpdated(@group);
BubbleGroupEvents.RaiseRefreshed(@group);
}
}
internal static void UpdateLastOnline(BubbleGroup bubbleGroup, bool updateUi = true, bool fromProcessUpdateLastOnlineQueue = false)
{
var service = bubbleGroup.Service;
if (!fromProcessUpdateLastOnlineQueue)
{
if (!ServiceManager.IsRunning(service) && !bubbleGroup.IsParty)
{
lock (UpdateLastOnlineQueue)
UpdateLastOnlineQueue.Add(new Tuple <BubbleGroup, bool>(bubbleGroup, updateUi));
return;
}
}
if (!ServiceManager.IsRunning(service) || bubbleGroup.IsParty)
{
return;
}
// reject the last online update if the Presence is currently available
if (bubbleGroup.Presence)
{
return;
}
try
{
service.GetBubbleGroupLastOnline(bubbleGroup, time =>
{
// reject the last online update if the Presence is currently available
if (bubbleGroup.Presence)
{
return;
}
bubbleGroup.PresenceType = PresenceBubble.PresenceType.Unavailable;
bubbleGroup.LastSeen = time;
if (updateUi)
{
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
//we constantly need to subscribe to a bubble group. doing it
//in last online method is the most effective.
BubbleManager.SendSubscribe(bubbleGroup, true);
//Presence(service, true);
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group last online: " + service.Information.ServiceName + ": " +
ex.Message);
}
}
public static bool UpdateUnknownPartyParticipant(BubbleGroup bubbleGroup, string participantAddress, Action onAdded = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
{
return(false);
}
if (string.IsNullOrWhiteSpace(participantAddress))
{
return(false);
}
if (bubbleGroup.FailedUnknownParticipants.FirstOrDefault(x =>
bubbleGroup.Service.BubbleGroupComparer(x, participantAddress)) != null)
{
return(false);
}
try
{
service.GetBubbleGroupUnknownPartyParticipant(bubbleGroup, participantAddress, participant =>
{
if (participant != null)
{
var contains = bubbleGroup.Participants.FirstOrDefault(x =>
bubbleGroup.Service.BubbleGroupComparer(x.Address, participantAddress)) != null;
if (!contains)
{
participant.Unknown = true;
bubbleGroup.Participants.Add(participant);
}
}
else
{
bubbleGroup.FailedUnknownParticipants.Add(participantAddress);
}
if (onAdded != null)
{
onAdded();
}
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
BubbleGroupEvents.RaiseBubblesUpdated(bubbleGroup);
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error getting unknown bubble group participant: " + service.Information.ServiceName + ": " +
ex.Message);
return(false);
}
return(true);
}
public static void UpdateStatus(VisualBubble b, Bubble.BubbleStatus status, BubbleGroup group,
bool updateBubbleGroupBubbles = true)
{
b.Status = status;
BubbleGroupDatabase.UpdateBubble(@group, b);
if (updateBubbleGroupBubbles)
{
BubbleGroupEvents.RaiseBubblesUpdated(@group);
}
BubbleGroupEvents.RaiseRefreshed(@group);
}
internal static void UpdateLastOnline(BubbleGroup bubbleGroup, bool updateUi = true, bool fromProcessUpdateLastOnlineQueue = false)
{
var service = bubbleGroup.Service;
if (!fromProcessUpdateLastOnlineQueue)
{
if (!ServiceManager.IsRunning(service) && !bubbleGroup.IsParty)
{
Utils.DebugPrint(">>>>>>>>>>>>>> Stashing UpdateLastOnline for later.");
lock (UpdateLastOnlineQueue)
UpdateLastOnlineQueue.Add(new Tuple <BubbleGroup, bool>(bubbleGroup, updateUi));
return;
}
}
if (!ServiceManager.IsRunning(service) || bubbleGroup.IsParty)
{
return;
}
// reject the last online update if the Presence is currently available
if (bubbleGroup.Presence)
{
return;
}
try
{
Utils.DebugPrint(">>>>>>>>>>>>>> Calling GetBubbleGroupLastOnline.");
service.GetBubbleGroupLastOnline(bubbleGroup, time =>
{
// reject the last online update if the Presence is currently available
if (bubbleGroup.Presence)
{
return;
}
bubbleGroup.PresenceType = PresenceBubble.PresenceType.Unavailable;
bubbleGroup.LastSeen = time;
if (updateUi)
{
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group last online: " + service.Information.ServiceName + ": " +
ex.Message);
}
}
public static void UpdateStatus(VisualBubble[] bubbles, Bubble.BubbleStatus status, BubbleGroup group,
bool updateBubbleGroupBubbles = true)
{
foreach (var bubble in bubbles)
{
bubble.Status = status;
}
BubbleGroupDatabase.UpdateBubble(@group, bubbles);
if (updateBubbleGroupBubbles)
{
BubbleGroupEvents.RaiseBubblesUpdated(@group);
}
BubbleGroupEvents.RaiseRefreshed(@group);
}
private static void SetUnread(BubbleGroup group, bool unread, bool updateUi = true, bool skipSendReadBubble = false, bool onlySetIfServiceRunning = true)
{
var unifiedGroup = @group as UnifiedBubbleGroup;
if (unifiedGroup != null)
{
foreach (var innerGroup in unifiedGroup.Groups)
{
SetUnread(innerGroup, false, skipSendReadBubble);
}
}
Action @do = () =>
{
var updatedSomething = BubbleGroupSettingsManager.GetUnread(@group);
BubbleGroupSettingsManager.SetUnread(@group, unread);
if (unifiedGroup == null)
{
if (!skipSendReadBubble)
{
if (@group.Service.Information.DoesSupport(typeof(ReadBubble)) && ServiceManager.IsRunning(@group.Service))
{
BubbleManager.Send(new ReadBubble(Time.GetNowUnixTimestamp(), Bubble.BubbleDirection.Outgoing,
@group.Service, @group.Address, null, Time.GetNowUnixTimestamp(), @group.IsParty, updatedSomething));
}
}
}
if (updateUi)
{
BubbleGroupEvents.RaiseRefreshed(@group);
}
};
if (onlySetIfServiceRunning && ServiceManager.IsRunning(@group.Service))
{
@do();
}
else if (!onlySetIfServiceRunning)
{
@do();
}
}
internal static async void UpdateName(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
{
return;
}
try
{
await service.GetBubbleGroupName(bubbleGroup, title =>
{
bubbleGroup.IsTitleSetFromService = true;
if (string.IsNullOrWhiteSpace(title))
{
Utils.DebugPrint("Update name title is null (rejecting): " + service.Information.ServiceName +
" - " + bubbleGroup.Address);
}
else
{
bubbleGroup.Title = title;
}
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group name: " + service.Information.ServiceName +
" - " + bubbleGroup.Address + ": " + ex);
if (finished != null)
{
finished();
}
}
}
private static void SetUnread(BubbleGroup group, bool unread, bool updateUi = true, bool skipSendReadBubble = false, bool onlySetIfServiceRunning = true)
{
var unifiedGroup = @group as UnifiedBubbleGroup;
if (unifiedGroup != null)
{
foreach (var innerGroup in unifiedGroup.Groups)
{
SetUnread(innerGroup, unread, false, skipSendReadBubble, onlySetIfServiceRunning);
}
}
var currentlyUnread = BubbleGroupSettingsManager.GetUnread(@group);
if ((onlySetIfServiceRunning && ServiceManager.IsRunning(@group.Service)) || !onlySetIfServiceRunning)
{
BubbleGroupSettingsManager.SetUnread(@group, unread);
if (unifiedGroup == null)
{
if (!skipSendReadBubble)
{
if (@group.Service.Information.DoesSupport(typeof(ReadBubble)) && ServiceManager.IsRunning(@group.Service))
{
var readBubble = new ReadBubble(Time.GetNowUnixTimestamp(), Bubble.BubbleDirection.Outgoing,
@group.Service, @group.Address, null, Time.GetNowUnixTimestamp(), @group.IsParty, currentlyUnread);
if (@group.IsExtendedParty)
{
readBubble.ExtendedParty = true;
}
BubbleManager.Send(readBubble);
}
}
}
if (updateUi)
{
BubbleGroupEvents.RaiseRefreshed(@group);
}
}
else
{
BubbleGroupSettingsManager.SetUnreadOffline(@group, unread);
}
}
public static bool ResetSyncsIfHasAgent(Service service, string bubbleGroupAddress)
{
if (!SupportsSync(service))
{
return(false);
}
foreach (var group in BubbleGroupManager.FindAll(service))
{
if (service.BubbleGroupComparer(group.Address, bubbleGroupAddress))
{
group.NeedsSync = true;
BubbleGroupEvents.RaiseSyncReset(group);
return(true);
}
}
return(false);
}
private static BubbleGroup AddNewInternal(VisualBubble newBubble, bool raiseBubbleInserted)
{
var group = new BubbleGroup(newBubble, null, false);
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(group, group.LastBubbleSafe().ID, true);
if (ServiceManager.IsRunning(@group.Service))
{
newBubble.Service.NewBubbleGroupCreated(@group).ContinueWith(x =>
{
// force the UI to refetch the photo
@group.IsPhotoSetFromService = false;
BubbleManager.SendSubscribe(@group, true);
BubbleGroupUpdater.Update(@group);
});
}
BubbleGroupManager.BubbleGroupsAdd(@group);
BubbleGroupDatabase.AddBubble(@group, newBubble);
if (raiseBubbleInserted)
{
try
{
BubbleGroupEvents.RaiseBubbleInserted(newBubble, @group);
}
catch (Exception ex)
{
Utils.DebugPrint(
"Error in notifying the interface that the bubble group has been updated (" +
newBubble.Service.Information.ServiceName + "): " + ex.Message);
}
}
BubbleGroupUpdater.Update(@group);
return(@group);
}
public static void Update(Service service, bool optimized = true)
{
const int Interval = 5;
var updateCounter = 0;
var groupsDoneCounter = 0;
var groups = BubbleGroupManager.FindAll(service);
var updateCounterThreshold = groups.Count / Interval;
foreach (var group in groups)
{
Action chainFinished = null;
if (groups.Count >= Interval)
{
chainFinished = () =>
{
Action <bool> doUpdate = singleton =>
{
BubbleGroupEvents.RaiseRefreshed(groups);
BubbleGroupEvents.RaiseBubblesUpdated(groups);
BubbleGroupEvents.RaiseInformationUpdated(groups);
};
groupsDoneCounter++;
if (groupsDoneCounter % Interval == 0)
{
updateCounter++;
doUpdate(false);
}
// do the remainder one by one ...
else if (updateCounter >= updateCounterThreshold)
{
doUpdate(true);
}
};
}
Update(@group, optimized, chainFinished);
}
}
internal static void UpdateName(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
{
return;
}
try
{
service.GetBubbleGroupName(bubbleGroup, title =>
{
bubbleGroup.IsTitleSetFromService = true;
bubbleGroup.Title = title;
if (finished == null)
{
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
BubbleGroupEvents.RaiseInformationUpdated(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group name: " + service.Information.ServiceName + ": " +
ex.Message);
if (finished != null)
{
finished();
}
}
}
internal static BubbleGroup Group(VisualBubble vb, bool resend = false, bool insertAtBottom = false)
{
lock (BubbleGroupDatabase.OperationLock)
{
Utils.DebugPrint("Grouping an " + vb.Direction + " bubble on service " + vb.Service.Information.ServiceName);
var theGroup =
BubbleGroupManager.FindWithAddress(vb.Service, vb.Address);
BubbleGroupFactory.LoadFullyIfNeeded(theGroup);
var duplicate = false;
var newGroup = false;
if (theGroup == null)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " unable to find suitable group. Creating a new one.");
theGroup = new BubbleGroup(vb, null, false);
newGroup = true;
Utils.DebugPrint("GUID of new group: " + theGroup.ID);
vb.Service.NewBubbleGroupCreated(theGroup).ContinueWith(x =>
{
// force the UI to refetch the photo
theGroup.IsPhotoSetFromService = false;
SendSubscribe(theGroup, true);
BubbleGroupUpdater.Update(theGroup);
});
BubbleGroupManager.BubbleGroupsAdd(theGroup);
}
else
{
if (resend)
{
if (vb.Status == Bubble.BubbleStatus.Failed)
{
UpdateStatus(vb, Bubble.BubbleStatus.Waiting, theGroup);
}
return(theGroup);
}
var visualBubbleServiceId = vb.Service as IVisualBubbleServiceId;
if (visualBubbleServiceId != null &&
visualBubbleServiceId.DisctinctIncomingVisualBubbleIdServices())
{
if (vb.IdService != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x => x.GetType() == vb.GetType() && x.IdService == vb.IdService) != null;
}
if (!duplicate && vb.IdService2 != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x => x.GetType() == vb.GetType() && x.IdService2 == vb.IdService2) != null;
}
}
if (!duplicate)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " found a group. Adding.");
if (insertAtBottom)
{
var lastBubble = theGroup.LastBubbleSafe();
if (lastBubble.Time > vb.Time)
{
vb.Time = lastBubble.Time;
}
}
theGroup.InsertByTime(vb);
}
else
{
Utils.DebugPrint("Yuck. It's a duplicate bubble. No need to readd: " + vb.IdService + ", " + vb.IdService2);
}
}
if (!duplicate)
{
Utils.DebugPrint("Inserting bubble into database group!");
try
{
if (newGroup)
{
BubbleGroupDatabase.AddBubble(theGroup, vb);
}
else
{
BubbleGroupDatabase.InsertBubbleByTime(theGroup, vb);
}
}
catch (Exception ex)
{
Utils.DebugPrint("Bubble failed to be inserting/added into the group " + theGroup.ID + ": " + ex);
}
try
{
BubbleGroupEvents.RaiseBubbleInserted(vb, theGroup);
}
catch (Exception ex)
{
Utils.DebugPrint(
"Error in notifying the interface that the bubble group has been updated (" +
vb.Service.Information.ServiceName + "): " + ex.Message);
}
}
return(theGroup);
}
}
internal static BubbleGroup Group(VisualBubble vb, bool resend = false, bool insertAtBottom = false)
{
lock (BubbleGroupDatabase.OperationLock)
{
Utils.DebugPrint("Grouping an " + vb.Direction + " bubble on service " + vb.Service.Information.ServiceName);
var theGroup =
BubbleGroupManager.FindWithAddress(vb.Service, vb.Address);
BubbleGroupFactory.LoadFullyIfNeeded(theGroup);
var duplicate = false;
var newGroup = false;
if (theGroup == null)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " unable to find suitable group. Creating a new one.");
theGroup = new BubbleGroup(vb, null, false);
newGroup = true;
Utils.DebugPrint("GUID of new group: " + theGroup.ID);
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(theGroup, theGroup.LastBubbleSafe().ID, true);
vb.Service.NewBubbleGroupCreated(theGroup).ContinueWith(x =>
{
// force the UI to refetch the photo
theGroup.IsPhotoSetFromService = false;
SendSubscribe(theGroup, true);
BubbleGroupUpdater.Update(theGroup);
});
BubbleGroupManager.BubbleGroupsAdd(theGroup);
}
else
{
if (resend)
{
if (vb.Status == Bubble.BubbleStatus.Failed)
{
UpdateStatus(vb, Bubble.BubbleStatus.Waiting, theGroup);
}
return(theGroup);
}
var visualBubbleServiceId = vb.Service as IVisualBubbleServiceId;
if (visualBubbleServiceId != null &&
visualBubbleServiceId.DisctinctIncomingVisualBubbleIdServices())
{
if (vb.IdService != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x => x.GetType() == vb.GetType() && x.IdService == vb.IdService) != null;
}
if (!duplicate && vb.IdService2 != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x => x.GetType() == vb.GetType() && x.IdService2 == vb.IdService2) != null;
}
}
if (!duplicate)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " found a group. Adding.");
if (insertAtBottom)
{
var lastBubble = theGroup.LastBubbleSafe();
if (lastBubble.Time > vb.Time)
{
vb.Time = lastBubble.Time;
}
}
theGroup.InsertByTime(vb);
}
else
{
Utils.DebugPrint("Yuck. It's a duplicate bubble. No need to readd: " + vb.IdService + ", " + vb.IdService2);
}
}
try
{
if (theGroup.IsParty && !string.IsNullOrWhiteSpace(vb.ParticipantAddressNickname))
{
var participantAddressNicknamesArray = theGroup.ParticipantNicknames;
if (participantAddressNicknamesArray == null)
{
participantAddressNicknamesArray = new DisaParticipantNickname[0];
}
var participantAddressNicknames = participantAddressNicknamesArray.ToList();
var changed = false;
var adding = true;
foreach (var participantAddressNickname in participantAddressNicknames)
{
if (theGroup.Service.BubbleGroupComparer(participantAddressNickname.Address, vb.ParticipantAddress))
{
if (participantAddressNickname.Nickname != vb.ParticipantAddressNickname)
{
participantAddressNickname.Nickname = vb.ParticipantAddressNickname;
changed = true;
}
adding = false;
break;
}
}
if (adding)
{
participantAddressNicknames.Add(new DisaParticipantNickname
{
Address = vb.ParticipantAddress,
Nickname = vb.ParticipantAddressNickname,
});
}
if (changed || adding)
{
theGroup.ParticipantNicknames = participantAddressNicknames.ToArray();
}
}
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to insert/update participant nickname into cache: " + ex);
}
if (!duplicate)
{
Utils.DebugPrint("Inserting bubble into database group!");
try
{
if (newGroup)
{
BubbleGroupDatabase.AddBubble(theGroup, vb);
}
else
{
BubbleGroupDatabase.InsertBubbleByTime(theGroup, vb);
}
}
catch (Exception ex)
{
Utils.DebugPrint("Bubble failed to be inserting/added into the group " + theGroup.ID + ": " + ex);
}
try
{
BubbleGroupEvents.RaiseBubbleInserted(vb, theGroup);
}
catch (Exception ex)
{
Utils.DebugPrint(
"Error in notifying the interface that the bubble group has been updated (" +
vb.Service.Information.ServiceName + "): " + ex.Message);
}
}
return(theGroup);
}
}
internal static async void UpdatePartyParticipants(BubbleGroup bubbleGroup, Action finished = null)
{
var service = bubbleGroup.Service;
if (!ServiceManager.IsRunning(service))
{
return;
}
if (!bubbleGroup.IsParty)
{
if (finished != null)
{
finished();
}
return;
}
try
{
await service.GetBubbleGroupPartyParticipants(bubbleGroup, participants =>
{
// we need to propogate the old participant photos to the new participant list
var newParticipants = participants == null ? new List <DisaParticipant>() : participants.ToList();
foreach (var oldParticipant in bubbleGroup.Participants)
{
var newParticipant = newParticipants.FirstOrDefault(x => service.BubbleGroupComparer(x.Address, oldParticipant.Address));
if (newParticipant != null)
{
newParticipant.Photo = oldParticipant.Photo;
newParticipant.IsPhotoSetFromService = oldParticipant.IsPhotoSetFromService;
}
}
// move all unknown participants over
foreach (var unknownParticipant in bubbleGroup.Participants.Where(x => x.Unknown))
{
if (newParticipants.FirstOrDefault(x => service.BubbleGroupComparer(x.Address, unknownParticipant.Address)) == null)
{
newParticipants.Add(unknownParticipant);
}
}
bubbleGroup.Participants = new ThreadSafeList <DisaParticipant>(newParticipants);
bubbleGroup.IsParticipantsSetFromService = true;
if (finished == null)
{
BubbleGroupEvents.RaiseBubblesUpdated(bubbleGroup);
}
else
{
finished();
}
});
}
catch (Exception ex)
{
Utils.DebugPrint("Error updating bubble group participants: " + service.Information.ServiceName +
" - " + bubbleGroup.Address + ": " + ex);
if (finished != null)
{
finished();
}
}
}
private static Task <bool> Send(Bubble b, BubbleGroup group, bool resend)
{
return(Task <bool> .Factory.StartNew(() =>
{
var vb = b as VisualBubble;
if (vb != null)
{
if (vb.Status == Bubble.BubbleStatus.Sent)
{
Utils.DebugPrint("Trying to send a bubble that is already sent! On " + vb.Service.Information.ServiceName);
return true;
}
Func <bool> restartServiceIfNeeded = () =>
{
if (!ServiceManager.IsRegistered(b.Service) ||
ServiceManager.IsRunning(b.Service) ||
ServiceManager.IsAborted(b.Service))
{
return false;
}
Utils.DebugPrint(
"For f***s sakes. The scheduler isn't doing it's job properly, or " +
"you're sending a message to it at a weird time. Starting it up bra (" +
b.Service.Information.ServiceName + ").");
ServiceManager.AbortAndRestart(b.Service);
return true;
};
var visualBubbleServiceId = vb.Service as IVisualBubbleServiceId;
if (vb.IdService == null && vb.IdService2 == null && visualBubbleServiceId != null)
{
visualBubbleServiceId.AddVisualBubbleIdServices(vb);
}
try
{
@group = Group(vb, resend, true);
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in Send:GroupBubble from service " +
vb.Service.Information.ServiceName + ": " + ex.Message);
return false;
}
if (@group == null)
{
Utils.DebugPrint("Could not find a suitable group for bubble " + vb.ID
+ " on " + vb.Service.Information.ServiceName);
return false;
}
var shouldQueue = vb.Service.QueuedBubblesParameters == null ||
!vb.Service.QueuedBubblesParameters.BubblesNotToQueue.Contains(vb.GetType());
try
{
if (shouldQueue && !resend &&
BubbleQueueManager.HasQueuedBubbles(vb.Service.Information.ServiceName,
true, false))
{
BubbleQueueManager.JustQueue(group, vb);
restartServiceIfNeeded();
return false;
}
if (shouldQueue)
{
Monitor.Enter(vb.Service.SendBubbleLock);
}
using (var queued = new BubbleQueueManager.InsertBubble(group, vb, shouldQueue))
{
Action checkForQueued = () =>
{
if (!resend &&
BubbleQueueManager.HasQueuedBubbles(vb.Service.Information.ServiceName, true, true))
{
BubbleQueueManager.Send(new [] { vb.Service.Information.ServiceName });
}
};
try
{
FailBubbleIfPathDoesntExist(vb);
SendBubbleInternal(b);
}
catch (ServiceQueueBubbleException ex)
{
Utils.DebugPrint("Queuing visual bubble on service " +
vb.Service.Information.ServiceName + ": " + ex.Message);
UpdateStatus(vb, Bubble.BubbleStatus.Waiting, @group);
if (!restartServiceIfNeeded())
{
checkForQueued();
}
return false;
}
catch (Exception ex)
{
queued.CancelQueue();
Utils.DebugPrint("Visual bubble on " +
vb.Service.Information.ServiceName + " failed to be sent: " +
ex);
UpdateStatus(vb, Bubble.BubbleStatus.Failed, @group);
BubbleGroupEvents.RaiseBubbleFailed(vb, @group);
if (!restartServiceIfNeeded())
{
checkForQueued();
}
//FIXME: if the bubble fails to send, allow the queue manager to continue.
if (resend)
{
return true;
}
return false;
}
queued.CancelQueue();
lock (BubbleGroupManager.LastBubbleSentTimestamps)
{
BubbleGroupManager.LastBubbleSentTimestamps[group.ID] = Time.GetNowUnixTimestamp();
}
if (vb.Status == Bubble.BubbleStatus.Delivered)
{
Utils.DebugPrint(
"************ Race condition. The server set the status to delivered/read before we could send it to sent. :')");
checkForQueued();
return true;
}
UpdateStatus(vb, Bubble.BubbleStatus.Sent, @group);
checkForQueued();
return true;
}
}
finally
{
if (shouldQueue)
{
Monitor.Exit(vb.Service.SendBubbleLock);
}
}
}
else
{
var composeBubble = b as ComposeBubble;
if (composeBubble != null)
{
var bubbleToSend = composeBubble.BubbleToSend;
var visualBubbleServiceId = bubbleToSend.Service as IVisualBubbleServiceId;
if (bubbleToSend.IdService == null && bubbleToSend.IdService2 == null &&
visualBubbleServiceId != null)
{
visualBubbleServiceId.AddVisualBubbleIdServices(bubbleToSend);
}
@group.InsertByTime(bubbleToSend);
try
{
BubbleGroupEvents.RaiseBubbleInserted(bubbleToSend, @group);
}
catch
{
// do nothing
}
}
try
{
SendBubbleInternal(b);
}
catch (ServiceBubbleGroupAddressException ex)
{
if (!String.IsNullOrWhiteSpace(ex.Address))
{
if (composeBubble != null)
{
composeBubble.BubbleToSend.Address = ex.Address;
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Sent;
var actualGroup = Group(composeBubble.BubbleToSend, resend, true);
ServiceEvents.RaiseComposeFinished(
@group as ComposeBubbleGroup, actualGroup);
return true;
}
}
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
return false;
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to send bubble on service " + b.Service.Information.ServiceName);
if (composeBubble != null)
{
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
}
return false;
}
if (composeBubble != null)
{
composeBubble.BubbleToSend.Status = Bubble.BubbleStatus.Failed;
return false;
}
return true;
}
}));
}
internal static void OnBubbleReceived(Bubble b)
{
var visualBubble = b as VisualBubble;
if (visualBubble != null)
{
try
{
BubbleManager.Group(visualBubble);
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in OnBubbleReceived (VisualBubble) from service " +
visualBubble.Service.Information.ServiceName + ": " + ex.Message);
}
if (visualBubble.Direction == Bubble.BubbleDirection.Incoming &&
IsRunning(visualBubble.Service) &&
BubbleQueueManager.HasQueuedBubbles(b.Service.Information.ServiceName, true, true))
{
Utils.DebugPrint("Sending queued bubbles as we're getting some received.");
BubbleQueueManager.Send(new [] { b.Service.Information.ServiceName });
}
}
else if (b is AbstractBubble)
{
Utils.DebugPrint("We got an abstract bubble: " + b.GetType().Name + " Address: " + b.Address);
BubbleGroup group = null;
var deliveredBubble = b as DeliveredBubble;
if (deliveredBubble != null)
{
@group = BubbleGroupManager.FindWithAddress(deliveredBubble.Service, deliveredBubble.Address);
if (@group != null)
{
BubbleGroupFactory.LoadFullyIfNeeded(@group);
var bubbles = @group.Bubbles;
for (var i = bubbles.Count - 1; i >= 0; i--)
{
var bubble = bubbles[i];
if (bubble.ID != deliveredBubble.VisualBubbleID)
{
continue;
}
BubbleManager.UpdateStatus(bubble, Bubble.BubbleStatus.Delivered, @group);
if (@group.Service.Information.DoesSupport(typeof(DeliveredBubbleReceipt)))
{
BubbleManager.Send(new DeliveredBubbleReceipt(Time.GetNowUnixTimestamp(), Bubble.BubbleDirection.Outgoing,
@group.Service, bubble));
}
break;
}
}
}
var readBubble = b as ReadBubble;
if (readBubble != null)
{
@group = BubbleGroupManager.FindWithAddress(readBubble.Service, readBubble.Address);
if (@group != null)
{
BubbleGroupFactory.LoadFullyIfNeeded(@group);
if (@group.ReadTimes == null || [email protected])
{
@group.ReadTimes = new []
{
new DisaReadTime
{
ParticipantAddress = readBubble.ParticipantAddress,
Time = readBubble.ReadTime
}
};
}
else
{
var readTimes = @group.ReadTimes.ToList();
var duplicateReadTime = readTimes.FirstOrDefault(x =>
@group.Service.BubbleGroupComparer(x.ParticipantAddress, readBubble.ParticipantAddress));
if (duplicateReadTime != null)
{
readTimes.Remove(duplicateReadTime);
}
readTimes.Add(new DisaReadTime
{
ParticipantAddress = readBubble.ParticipantAddress,
Time = readBubble.ReadTime
});
@group.ReadTimes = readTimes.ToArray();
}
}
}
var prescenceBubble = b as PresenceBubble;
if (prescenceBubble != null)
{
@group = BubbleGroupManager.Find(bubbleGroup =>
!bubbleGroup.IsParty &&
bubbleGroup.Service ==
prescenceBubble.Service &&
prescenceBubble.Service.BubbleGroupComparer(
bubbleGroup.Address,
prescenceBubble.Address));
if (@group != null)
{
if ([email protected] && !prescenceBubble.Available)
{
var oldPresence = @group.PresenceType;
@group.PresenceType = PresenceBubble.PresenceType.Unavailable;
if (oldPresence != prescenceBubble.Presence)
{
BubbleGroupManager.UpdateLastOnline(@group);
}
}
else
{
@group.PresenceType = prescenceBubble.Presence;
@group.PresencePlatformType = prescenceBubble.Platform;
}
if (!prescenceBubble.Available)
{
@group.Typing = false;
}
}
}
var typingBubble = b as TypingBubble;
if (typingBubble != null)
{
@group = BubbleGroupManager.Find(bubbleGroup =>
!bubbleGroup.IsParty &&
bubbleGroup.Service ==
typingBubble.Service &&
typingBubble.Service.BubbleGroupComparer(
bubbleGroup.Address,
typingBubble.Address));
if (@group != null)
{
if (@group.Presence)
{
@group.Typing = typingBubble.Typing;
@group.TypingIsAudio = typingBubble.IsAudio;
}
else
{
@group.Typing = false;
}
}
}
try
{
if (@group != null)
{
BubbleGroupEvents.RaiseNewAbstractBubble(b as AbstractBubble, @group);
}
}
catch (Exception ex)
{
Utils.DebugPrint("Problem in OnBubbleReceived (AbstractBubble) from service " +
b.Service.Information.ServiceName + ": " + ex.Message);
}
}
}
public static Task <List <Receipt> > Send(string[] serviceNames, bool scheduled = false)
{
return(Task <List <Receipt> > .Factory.StartNew(() =>
{
//PROCESS: 1) find all bubbles under serviceNames in db
// 2) relate db entries to bubbles loaded into memory by Disa
// 3) parallel send bubbles based respective to service
// 4) delete all successful bubbles out of db
lock (_sendLock)
{
var nowUnixTimestamp = Time.GetNowUnixTimestamp();
var possibleBubblesFromDatabase = new List <Entry>();
lock (_dbLock)
{
using (var db = new SqlDatabase <Entry>(Location))
{
foreach (var possibleBubble in db.Store.Where(x => serviceNames.Contains(x.ServiceName)).Reverse())
{
if (!InsertBubble.IsSending(possibleBubble.Guid))
{
possibleBubblesFromDatabase.Add(possibleBubble);
}
}
}
}
var possibleBubblesInDisa = new List <Tuple <Entry, VisualBubble> >();
foreach (var bubbleGroup in BubbleGroupManager.BubbleGroupsNonUnified)
{
var hasPossibleBubble = possibleBubblesFromDatabase.FirstOrDefault(x =>
x.BubbleGroupGuid != null && x.BubbleGroupGuid == bubbleGroup.ID) != null;
if (!hasPossibleBubble)
{
continue;
}
if (bubbleGroup.PartiallyLoaded)
{
BubbleGroupFactory.LoadFullyIfNeeded(bubbleGroup);
}
var bubblesToSetToFail = new List <Tuple <Entry, VisualBubble> >();
foreach (var bubble in bubbleGroup.Bubbles)
{
if (bubble.Status != Bubble.BubbleStatus.Waiting)
{
continue;
}
if (bubble.Direction != Bubble.BubbleDirection.Outgoing)
{
continue;
}
var possibleBubbleFromDatabase = possibleBubblesFromDatabase.FirstOrDefault(x => x.Guid == bubble.ID);
if (possibleBubbleFromDatabase != null)
{
// older than 10 minutes, fail
if (bubble.Time < (nowUnixTimestamp - 600))
{
bubble.Status = Bubble.BubbleStatus.Failed;
bubblesToSetToFail.Add(Tuple.Create(possibleBubbleFromDatabase, bubble));
continue;
}
possibleBubblesInDisa.Add(new Tuple <Entry, VisualBubble>(possibleBubbleFromDatabase, bubble));
}
}
if (bubblesToSetToFail.Any())
{
BubbleGroupDatabase.UpdateBubble(bubbleGroup,
bubblesToSetToFail.Select(x => x.Item2).ToArray(), 100);
Remove(bubblesToSetToFail.Select(x => x.Item1).ToArray());
foreach (var bubble in bubblesToSetToFail)
{
BubbleGroupEvents.RaiseBubbleFailed(bubble.Item2, bubbleGroup);
}
BubbleGroupEvents.RaiseBubblesUpdated(bubbleGroup);
BubbleGroupEvents.RaiseRefreshed(bubbleGroup);
}
}
var sent = new List <Tuple <Entry, bool> >();
var possibleBubblesInDisaByService = possibleBubblesInDisa.GroupBy(x => x.Item1.ServiceName);
Parallel.ForEach(possibleBubblesInDisaByService, possibleBubblesInService =>
{
var failed = false;
foreach (var possibleBubble in possibleBubblesInService)
{
if (failed)
{
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, false));
continue;
}
Utils.DebugPrint(">>>>>>>>>>> Sending queued bubble on "
+ possibleBubble.Item2.Service.Information.ServiceName + "!");
var sendBubbleTask = BubbleManager.Send(possibleBubble.Item2, true);
sendBubbleTask.Wait();
if (sendBubbleTask.Result)
{
Utils.DebugPrint(">>>>>>>>> Successfully sent queued bubble on " +
possibleBubble.Item2.Service.Information.ServiceName + "!");
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, true));
lock (_dbLock)
{
using (var db = new SqlDatabase <Entry>(Location))
{
db.Remove(possibleBubble.Item1);
}
}
Utils.Delay(100).Wait();
}
else
{
Utils.DebugPrint(">>>>>>>>> Failed to send queued bubble on " +
possibleBubble.Item2.Service.Information.ServiceName + "!");
sent.Add(new Tuple <Entry, bool>(possibleBubble.Item1, false));
failed = true; // fail the entire chain for this service from here on out so messages aren't sent out of order
}
}
});
var receipts = sent.Select(x => new Receipt(x.Item1.Guid, x.Item2)).ToList();
if (!scheduled)
{
if (receipts.FirstOrDefault(x => !x.Success) != null)
{
ScheduleReSend(serviceNames);
}
else
{
var needToSendAgain = serviceNames.Where(x => BubbleQueueManager.HasQueuedBubbles(x, true, true)).ToArray();
if (needToSendAgain.Any())
{
Send(needToSendAgain);
}
}
}
SanityCheckup();
return receipts;
}
}));
}
public static void SetNotQueuedToFailures(BubbleGroup group)
{
var nowUnixTimeStamp = Time.GetNowUnixTimestamp();
var groups = BubbleGroupManager.GetInner(@group).Where(x =>
(x.Service.QueuedBubblesParameters != null &&
x.Service.QueuedBubblesParameters.BubblesNotToQueue != null &&
x.Service.QueuedBubblesParameters.BubblesNotToQueue.Any()));
if (!groups.Any())
{
return;
}
foreach (var innerGroup in groups)
{
if (HasNotQueued(innerGroup))
{
if (innerGroup.PartiallyLoaded)
{
BubbleGroupFactory.LoadFullyIfNeeded(innerGroup);
}
var bubblesSetToFailed = new List <VisualBubble>();
foreach (var bubble in innerGroup.Bubbles)
{
if (bubble.Direction == Bubble.BubbleDirection.Outgoing &&
bubble.Status == Bubble.BubbleStatus.Waiting)
{
if (innerGroup
.Service.QueuedBubblesParameters.BubblesNotToQueue
.FirstOrDefault(x => x == bubble.GetType()) != null)
{
var failBubble = innerGroup
.Service.QueuedBubblesParameters.SendingBubblesToFailOnServiceStart
.FirstOrDefault(x => x == bubble.GetType()) != null;
// Older than 10 minutes, fail it regardless.
if (!failBubble && bubble.Time < (nowUnixTimeStamp - 600))
{
failBubble = true;
}
if (failBubble)
{
RemoveNotQueued(bubble);
bubble.Status = Bubble.BubbleStatus.Failed;
bubblesSetToFailed.Add(bubble);
}
}
}
}
if (bubblesSetToFailed.Any())
{
BubbleGroupDatabase.UpdateBubble(innerGroup, bubblesSetToFailed.ToArray(), 100);
foreach (var bubble in bubblesSetToFailed)
{
BubbleGroupEvents.RaiseBubbleFailed(bubble, innerGroup);
}
BubbleGroupEvents.RaiseBubblesUpdated(innerGroup);
BubbleGroupEvents.RaiseRefreshed(innerGroup);
}
}
}
NotQueuedSanityCheckup();
}
internal static BubbleGroup Group(VisualBubble vb, bool resend = false, bool insertAtBottom = false)
{
lock (BubbleGroupDatabase.OperationLock)
{
Utils.DebugPrint("Grouping an " + vb.Direction + " bubble on service " + vb.Service.Information.ServiceName);
AddUrlMarkupIfNeeded(vb);
var theGroup =
BubbleGroupManager.FindWithAddress(vb.Service, vb.Address);
BubbleGroupFactory.LoadFullyIfNeeded(theGroup);
var duplicate = false;
var newGroup = false;
if (theGroup == null)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " unable to find suitable group. Creating a new one.");
theGroup = new BubbleGroup(vb, null, false);
newGroup = true;
Utils.DebugPrint("GUID of new group: " + theGroup.ID);
BubbleGroupSettingsManager.SetUnreadIndicatorGuid(theGroup, theGroup.LastBubbleSafe().ID, true);
vb.Service.NewBubbleGroupCreated(theGroup).ContinueWith(x =>
{
// force the UI to refetch the photo
theGroup.IsPhotoSetFromService = false;
SendSubscribe(theGroup, true);
BubbleGroupUpdater.Update(theGroup);
});
BubbleGroupManager.BubbleGroupsAdd(theGroup);
}
else
{
if (resend)
{
if (vb.Status == Bubble.BubbleStatus.Failed)
{
UpdateStatus(vb, Bubble.BubbleStatus.Waiting, theGroup);
}
return(theGroup);
}
// Does the Service for this VisualBubble require that the VisualBubble's IdService and IdService2
// be distinct?
var visualBubbleServiceId = vb.Service as IVisualBubbleServiceId;
if (visualBubbleServiceId != null &&
visualBubbleServiceId.DisctinctIncomingVisualBubbleIdServices())
{
// Ok, we need to be distinct, BUT do the VisualBubble Type's have to be distinct as well?
var checkType = true;
if (!DisaFrameworkMethods.Missing(vb.Service, DisaFrameworkMethods.IVisualBubbleServiceIdCheckType))
{
checkType = visualBubbleServiceId.CheckType();
}
// Ok, now does the Service have special additional logic it wants to use for the distinction comparison?
// Example: For Telegram, we allow an ImageBubble immediately followed by a TextBubble to have the
// same VisualBubble.IdService - as this represents an image with a caption in Telegram.
if (DisaFrameworkMethods.Missing(vb.Service, DisaFrameworkMethods.IVisualBubbleServiceIdVisualBubbleIdComparer))
{
// Normal distinction checks
if (vb.IdService != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x =>
(!checkType || x.GetType() == vb.GetType()) && x.IdService == vb.IdService) != null;
}
if (!duplicate && vb.IdService2 != null)
{
duplicate = theGroup.Bubbles.FirstOrDefault(x =>
(!checkType || x.GetType() == vb.GetType()) && x.IdService2 == vb.IdService2) != null;
}
}
else
{
// Special additional Service defined distinction checks
if (vb.IdService != null)
{
var duplicateBubble = theGroup.Bubbles.FirstOrDefault(x =>
(!checkType || x.GetType() == vb.GetType()) && x.IdService == vb.IdService);
duplicate = duplicateBubble == null ? false :
visualBubbleServiceId.VisualBubbleIdComparer(left: duplicateBubble, right: vb);
}
if (!duplicate && vb.IdService2 != null)
{
var duplicateBubble = theGroup.Bubbles.FirstOrDefault(x =>
(!checkType || x.GetType() == vb.GetType()) && x.IdService2 == vb.IdService2);
duplicate = duplicateBubble == null ? false :
visualBubbleServiceId.VisualBubbleIdComparer(duplicateBubble, vb);
}
}
}
if (!duplicate)
{
Utils.DebugPrint(vb.Service.Information.ServiceName + " found a group. Adding.");
if (insertAtBottom)
{
var lastBubble = theGroup.LastBubbleSafe();
if (lastBubble.Time > vb.Time)
{
vb.Time = lastBubble.Time;
}
}
theGroup.InsertByTime(vb);
}
else
{
Utils.DebugPrint("Yuck. It's a duplicate bubble. No need to readd: " + vb.IdService + ", " + vb.IdService2);
}
}
try
{
if (theGroup.IsParty && !string.IsNullOrWhiteSpace(vb.ParticipantAddressNickname))
{
var participantAddressNicknamesArray = theGroup.ParticipantNicknames;
if (participantAddressNicknamesArray == null)
{
participantAddressNicknamesArray = new DisaParticipantNickname[0];
}
var participantAddressNicknames = participantAddressNicknamesArray.ToList();
var changed = false;
var adding = true;
foreach (var participantAddressNickname in participantAddressNicknames)
{
if (theGroup.Service.BubbleGroupComparer(participantAddressNickname.Address, vb.ParticipantAddress))
{
if (participantAddressNickname.Nickname != vb.ParticipantAddressNickname)
{
participantAddressNickname.Nickname = vb.ParticipantAddressNickname;
changed = true;
}
adding = false;
break;
}
}
if (adding)
{
participantAddressNicknames.Add(new DisaParticipantNickname
{
Address = vb.ParticipantAddress,
Nickname = vb.ParticipantAddressNickname,
});
}
if (changed || adding)
{
theGroup.ParticipantNicknames = participantAddressNicknames.ToArray();
}
}
}
catch (Exception ex)
{
Utils.DebugPrint("Failed to insert/update participant nickname into cache: " + ex);
}
if (!duplicate)
{
Utils.DebugPrint("Inserting bubble into database group!");
try
{
if (newGroup)
{
BubbleGroupDatabase.AddBubble(theGroup, vb);
}
else
{
BubbleGroupDatabase.InsertBubbleByTime(theGroup, vb);
}
}
catch (Exception ex)
{
Utils.DebugPrint("Bubble failed to be inserting/added into the group " + theGroup.ID + ": " + ex);
}
try
{
BubbleGroupEvents.RaiseBubbleInserted(vb, theGroup);
}
catch (Exception ex)
{
Utils.DebugPrint(
"Error in notifying the interface that the bubble group has been updated (" +
vb.Service.Information.ServiceName + "): " + ex.Message);
}
}
return(theGroup);
}
}