public static void RaiseBubbleFailed(VisualBubble bubble, BubbleGroup bubbleGroup) { if (OnBubbleFailed != null) { OnBubbleFailed(bubble, bubbleGroup); } }
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); }
public static BubbleGroup FindInner(VisualBubble visualBubble, BubbleGroup group) { if (visualBubble.BubbleGroupReference != null) { return(visualBubble.BubbleGroupReference); } var unifiedGroup = @group as UnifiedBubbleGroup; if (unifiedGroup == null) { return(@group); } // try to find it. foreach (var innerGroup in unifiedGroup.Groups) { foreach (var bubble in innerGroup.Bubbles) { if (bubble.ID != visualBubble.ID) { continue; } return(innerGroup); } } return(null); }
private static void AddUrlMarkupIfNeeded(VisualBubble bubble) { try { var textBubble = bubble as TextBubble; if (textBubble != null && !textBubble.HasParsedMessageForUrls) { var markups = new List <BubbleMarkup>(); if (_linkExtraction == null) { _linkExtraction = new Regex(@"\b(?:https?://|www\.)\S+\b", RegexOptions.Compiled | RegexOptions.IgnoreCase); } var rawString = textBubble.Message; foreach (Match m in _linkExtraction.Matches(rawString)) { markups.Add(new BubbleMarkupUrl { Url = m.Value, }); } if (textBubble.BubbleMarkups == null) { textBubble.BubbleMarkups = new List <BubbleMarkup>(); } textBubble.BubbleMarkups.AddRange(markups); textBubble.HasParsedMessageForUrls = true; } } catch (Exception e) { Utils.DebugPrint("Failed to add UrlMarkup: " + e); } }
public static Task JustQueue(VisualBubble visualBubble) { return(Task.Factory.StartNew(() => { var entry = Add(visualBubble); })); }
private static Entry Add(VisualBubble bubble) { lock (_dbLock) { using (var db = new SqlDatabase <Entry>(Location)) { // don't add a duplicate bubble in the queue foreach (var possibleBubble in db.Store) { if (possibleBubble.Guid == bubble.ID) { return(possibleBubble); } } var entry = new Entry() { ServiceName = bubble.Service.Information.ServiceName, Guid = bubble.ID, Time = bubble.Time }; db.Add(entry); return(entry); } } }
public static string GetMediaFilePathIfPossible(VisualBubble bubble) { var imageBubble = bubble as ImageBubble; if (imageBubble != null) { return(imageBubble.ImagePath); } var videoBubble = bubble as VideoBubble; if (videoBubble != null) { return(videoBubble.VideoPath); } var audioBubble = bubble as AudioBubble; if (audioBubble != null) { return(audioBubble.AudioPath); } var fileBubble = bubble as FileBubble; if (fileBubble != null) { return(fileBubble.Path); } return(null); }
public virtual Task GetQuotedMessageTitle(VisualBubble bubble, Action <string> result) { return(Task.Factory.StartNew(() => { result(null); })); }
private static bool IsBubbleDownloading(VisualBubble bubble) { var imageBubble = bubble as ImageBubble; if (imageBubble != null) { return(imageBubble.Transfer != null); } var videoBubble = bubble as VideoBubble; if (videoBubble != null) { return(videoBubble.Transfer != null); } var audioBubble = bubble as AudioBubble; if (audioBubble != null) { return(audioBubble.Transfer != null); } var fileBubble = bubble as FileBubble; if (fileBubble != null) { return(fileBubble.Transfer != null); } return(false); }
public static bool Update(BubbleGroup group, VisualBubble visualBubble, int bubbleDepth = 100) { if (visualBubble.BubbleGroupReference != null) { BubbleGroupDatabase.UpdateBubble(visualBubble.BubbleGroupReference, visualBubble, bubbleDepth); return(true); } var unifiedGroup = @group as UnifiedBubbleGroup; if (unifiedGroup == null) { BubbleGroupDatabase.UpdateBubble(@group, visualBubble, bubbleDepth); return(true); } foreach (var innerGroup in unifiedGroup.Groups) { foreach (var bubble in innerGroup.Bubbles) { if (bubble.ID != visualBubble.ID) { continue; } BubbleGroupDatabase.UpdateBubble(innerGroup, visualBubble, bubbleDepth); return(true); } } return(false); }
public Task GetBotCallbackAnswer(BubbleGroup group, VisualBubble bubble, Bots.KeyboardButton button, Action <Bots.MessagesBotCallbackAnswer> answer) { return(Task.Factory.StartNew(() => { using (var client = new FullClientDisposable(this)) { // Note: Telegram also has KeyboardButtonGame which functions as a callback also if (button is Bots.KeyboardButtonCallback) { var keyboardButtonCallback = button as Bots.KeyboardButtonCallback; var args = new MessagesGetBotCallbackAnswerArgs { MsgId = uint.Parse(bubble.IdService), Data = keyboardButtonCallback.Data, Peer = GetInputPeer(group.Address, group.IsParty, group.IsExtendedParty) }; SharpTelegram.Schema.MessagesBotCallbackAnswer telegramBotCallbackAnswer = (SharpTelegram.Schema.MessagesBotCallbackAnswer) TelegramUtils.RunSynchronously( client.Client.Methods.MessagesGetBotCallbackAnswerAsync(args)); var disaBotCallbackAnswer = new Bots.MessagesBotCallbackAnswer { Alert = telegramBotCallbackAnswer.Alert != null ? true : false, Message = telegramBotCallbackAnswer.Message }; answer(disaBotCallbackAnswer); } } })); }
public static void ForwardCopyToMediaDirectoryIfNeeded(VisualBubble vb) { if (vb is TextBubble) { return; } if (vb is LocationBubble) { return; } if (vb is ContactBubble) { return; } var videoBubble = vb as VideoBubble; if (videoBubble != null) { if (IsInMediaLocation(videoBubble.VideoPath)) { return; } var path = CopyVideoToDisaVideoLocation(videoBubble.VideoPath); if (path == null) { return; } videoBubble.VideoPath = path; } var audioBubble = vb as AudioBubble; if (audioBubble != null) { if (IsInMediaLocation(audioBubble.AudioPath)) { return; } var path = CopyAudioToDisaAudioLocation(audioBubble.AudioPath); audioBubble.AudioPath = path; } var imageBubble = vb as ImageBubble; if (imageBubble != null) { if (IsInMediaLocation(imageBubble.ImagePath)) { return; } var path = CopyPhotoToDisaPictureLocation(imageBubble.ImagePath); if (path == null) { return; } imageBubble.ImagePath = path; } }
public bool LoadBubblesComparer(VisualBubble localBubble, VisualBubble agentBubble) { if (localBubble.IdService == agentBubble.IdService) { return(true); } return(false); }
public UnifiedBubbleGroup(List <BubbleGroup> groups, BubbleGroup primaryGroup, VisualBubble initialBubble, string id = null) : base(initialBubble, id, false) { _unifiedService = initialBubble.Service; Groups = groups; PrimaryGroup = primaryGroup; _sendingGroup = primaryGroup; }
private static byte[] SerializeBubble(VisualBubble b) { using (var ms = new MemoryStream()) { Serializer.Serialize(ms, b); return(ms.ToArray()); } }
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); }
public static BubbleGroup AddNewIfNotExist(VisualBubble bubble, bool updateUi = false) { var group = BubbleGroupManager.FindWithAddress(bubble.Service, bubble.Address); if (@group != null) { return(null); } return(AddNewInternal(bubble, updateUi)); }
public static VisualBubble FetchNewestBubbleIfNotWaiting(Stream stream, Service service, int searchDepth = 10) { VisualBubble firstBubble = null; lock (OperationLock) { stream.Seek(stream.Length, SeekOrigin.Begin); for (var i = 0; i < searchDepth; i++) { if (stream.Position == 0) { break; } byte[] headerBytes; int headerBytesLength; int endPosition; BubbleGroupDatabasePrimitives.ReadBubbleHeaderType(stream, out headerBytes, out headerBytesLength, out endPosition); var guid = BubbleGroupDatabasePrimitives.ReadBubbleHeaderStruct(headerBytes, headerBytesLength, endPosition + 1, out endPosition); var bubbleData = BubbleGroupDatabasePrimitives.ReadBubbleData(stream); var visualBubble = Deserialize(bubbleData); if (visualBubble == null) { continue; } // if any of the bubbles are waiting, then make sure to perform a full load if (!(visualBubble is NewBubble) && (visualBubble.Status == Bubble.BubbleStatus.Waiting && visualBubble.Direction == Bubble.BubbleDirection.Outgoing)) { return(null); } if (firstBubble == null) { visualBubble.Service = service; visualBubble.ID = guid; firstBubble = visualBubble; } } } return(firstBubble); }
private static bool IsBubbleSending(VisualBubble bubble) { if (bubble is NewBubble) { return(false); } if (bubble.Status == Bubble.BubbleStatus.Waiting && bubble.Direction == Bubble.BubbleDirection.Outgoing) { return(true); } return(false); }
private static void FailBubbleIfPathDoesntExist(VisualBubble bubble) { var path = GetMediaFilePathIfPossible(bubble); if (String.IsNullOrWhiteSpace(path)) { return; } if (!File.Exists(path)) { throw new ServiceBubbleSendFailedException("Visual bubble media file path doesn't exist."); } }
internal static UnifiedBubbleGroup CreateUnifiedInternal(List <BubbleGroup> groups, BubbleGroup primaryGroup, string id = null) { var service = ServiceManager.GetUnified(); if (service == null) { return(null); } var newBubble = new NewBubble(Time.GetNowUnixTimestamp(), Bubble.BubbleDirection.Incoming, Guid.NewGuid() + "@unified", null, false, service); var unified = new UnifiedBubbleGroup(groups, primaryGroup, newBubble, id); if (id == null) { var unread = groups.FirstOrDefault(BubbleGroupSettingsManager.GetUnread) != null; BubbleGroupSettingsManager.SetUnread(unified, unread); } foreach (var group in groups) { @group.RegisterUnified(unified); } var associatedPartiallyLoadedGroups = groups.Where(x => x.PartiallyLoaded).ToList(); if (associatedPartiallyLoadedGroups.Any()) { VisualBubble latest = null; foreach (var innerGroup in unified.Groups) { var current = innerGroup.Bubbles.Last(); if (latest == null || current.Time > latest.Time) { latest = current; } } if (latest != null) { unified.Bubbles.Clear(); unified.Bubbles.Add(latest); } return(unified); } Populate(unified); return(unified); }
private static void RemoveNotQueued(VisualBubble bubble) { lock (_dbLock) { var bubbleId = bubble.ID; using (var db = new SqlDatabase <NotQueuedEntry>(NotQueuedLocation)) { // don't add a duplicate group into the queue foreach (var possibleGroup in db.Store.Where(x => x.Guid == bubbleId)) { db.Remove(possibleGroup); } } } }
public static string PatchPath(VisualBubble bubble) { string path = null; string newBase = null; var imageBubble = bubble as ImageBubble; var videoBubble = bubble as VideoBubble; var audioBubble = bubble as AudioBubble; var fileBubble = bubble as FileBubble; if (imageBubble != null) { path = imageBubble.ImagePathNative; newBase = Platform.GetPicturesPath(); } else if (videoBubble != null) { path = videoBubble.VideoPathNative; newBase = Platform.GetVideosPath(); } else if (audioBubble != null) { path = audioBubble.AudioPathNative; newBase = Platform.GetAudioPath(); } else if (fileBubble != null) { path = fileBubble.PathNative; newBase = Platform.GetFilesPath(); } if (path == null || newBase == null) { throw new Exception("Uknown bubble"); } var indexes = FindIndexesFromRear(path, Path.DirectorySeparatorChar); var seperators = indexes.Take(2).ToList(); if (seperators.Count < 2) { return(path); } var end = path.Substring(seperators[1] + 1); return(Path.Combine(newBase, end)); }
public static bool UpdateQuotedMessageTitle(VisualBubble bubble, Action <string> onTitleUpdated) { var service = bubble.Service; if (!ServiceManager.IsRunning(service)) { return(false); } if (string.IsNullOrWhiteSpace(bubble.QuotedAddress)) { return(false); } try { service.GetQuotedMessageTitle(bubble, result => { var bubbleGroup = BubbleGroupManager.FindWithAddress(bubble.Service, bubble.Address); if (bubbleGroup != null) { var quotedTitles = bubbleGroup.QuotedTitles == null ? new List <DisaQuotedTitle>() : bubbleGroup.QuotedTitles.ToList(); var quotedTitle = quotedTitles.FirstOrDefault(x => bubbleGroup.Service.BubbleGroupComparer(x.Address, bubble.QuotedAddress)); if (quotedTitle == null) { quotedTitles.Add(new DisaQuotedTitle { Address = bubble.QuotedAddress, Title = result, }); } else { quotedTitle.Title = result; } bubbleGroup.QuotedTitles = quotedTitles.ToArray(); } onTitleUpdated(result); }); return(true); } catch (Exception e) { Utils.DebugPrint("Error getting quoted message title " + e); return(false); } }
public InsertBubble(VisualBubble visualBubble, bool shouldInsert) { _shouldInsert = shouldInsert; _visualBubble = visualBubble; if (_shouldInsert) { _entry = Add(_visualBubble); lock (Sending) { Sending.Add(_visualBubble); } } else { _entry = null; } }
public InsertBubble(BubbleGroup group, VisualBubble visualBubble, bool shouldInsert) { _shouldInsert = shouldInsert; _visualBubble = visualBubble; if (_shouldInsert) { _entry = Add(group, _visualBubble); lock (Sending) { Sending.Add(_visualBubble); } } else { AddNotQueued(visualBubble, group); _entry = null; } }
public static BubbleGroup Find(VisualBubble bubble) { lock (BubbleGroupsLock) { var unifiedGroups = BubbleGroups.OfType <UnifiedBubbleGroup>(); foreach (var unifiedGroup in unifiedGroups) { if (unifiedGroup.Bubbles.Any(unifiedGroupBubble => unifiedGroupBubble == bubble)) { return(unifiedGroup); } } return (BubbleGroups.FirstOrDefault( group => @group.Bubbles.FirstOrDefault(secondBubble => secondBubble == bubble) != null)); } }
private uint GetMessagePtsForTime(BubbleGroup group, long fromTime, out bool queryChat, out bool lastMessageIsExtendedParty) { VisualBubble bubbleToSyncFrom = null; bool localQueryChat = false; bool localLastMessageIsExtendedParty = false; foreach (var bubble in BubbleGroupSync.ReadBubblesFromDatabase(group)) { if (bubble is PartyInformationBubble) { if ((bubble as PartyInformationBubble).Type == PartyInformationBubble.InformationType.UpgradedToExtendedParty) { localQueryChat = true; if (bubble.Time <= fromTime) { localLastMessageIsExtendedParty = true; bubbleToSyncFrom = bubble; break; } } } if (bubble.Time <= fromTime) { bubbleToSyncFrom = bubble; break; } } if (bubbleToSyncFrom != null) { if (bubbleToSyncFrom.IdService == null) { queryChat = localQueryChat; lastMessageIsExtendedParty = localLastMessageIsExtendedParty; return(1); } queryChat = localQueryChat; lastMessageIsExtendedParty = localLastMessageIsExtendedParty; return(uint.Parse(bubbleToSyncFrom.IdService)); } queryChat = localQueryChat; lastMessageIsExtendedParty = localLastMessageIsExtendedParty; return(1); }
public static void AddBubble(BubbleGroup group, VisualBubble b) { lock (OperationLock) { using (var ms = new MemoryStream()) { Serializer.Serialize(ms, b); var bubbleData = ms.ToArray(); var bubbleHeader = b.GetType().Name + ":" + b.ID + ":" + b.Time; var file = GetLocation(@group); using (var stream = File.Open(file, FileMode.Append, FileAccess.Write)) { BubbleGroupDatabasePrimitives.WriteBubbleData(stream, bubbleData); BubbleGroupDatabasePrimitives.WriteBubbleHeader(stream, bubbleHeader); } } } }
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); }