Beginnings of disappearing messages

Use at your own risk.
Messages get fully deleted once their timer is up.
Missing things:
Messages get deleted as soon as their received, not read.
Expired messages don't get cleaned up by the background thread when it starts up.
Expired messages don't get cleaned up when the app starts.

Author: golf1052

Signal-Windows.Lib/DisappearingMessagesManager.cs

@@ -0,0 +1,99 @@
+using System;
+using System.Collections.Generic;
+using System.Diagnostics;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+using Signal_Windows.Models;
+using Signal_Windows.Storage;
+using Windows.UI.Core;
+
+namespace Signal_Windows.Lib
+{
+    public static class DisappearingMessagesManager
+    {
+        private static Dictionary<CoreDispatcher, ISignalFrontend> frames;
+
+        static DisappearingMessagesManager()
+        {
+            frames = new Dictionary<CoreDispatcher, ISignalFrontend>();
+        }
+
+        public static void AddFrontend(CoreDispatcher coreDispatcher, ISignalFrontend frontend)
+        {
+            if (!frames.ContainsKey(coreDispatcher))
+            {
+                frames.Add(coreDispatcher, frontend);
+            }
+        }
+
+        public static void RemoveFrontend(CoreDispatcher coreDispatcher)
+        {
+            if (frames.ContainsKey(coreDispatcher))
+            {
+                frames.Remove(coreDispatcher);
+            }
+        }
+
+        public static void AddMessage(SignalMessage message)
+        {
+            if (message.ExpiresAt == 0)
+            {
+                return;
+            }
+            Action deleteTask = async () =>
+            {
+                DateTimeOffset expireTime = DateTimeOffset.FromUnixTimeMilliseconds(message.ExpiresAt);
+                DateTimeOffset receivedTime = DateTimeOffset.FromUnixTimeMilliseconds(message.ReceivedTimestamp);
+                TimeSpan deleteTimeSpan = expireTime - receivedTime;
+                if (deleteTimeSpan < TimeSpan.Zero)
+                {
+                    Debug.WriteLine($"deleteTimeSpan was less than 0: {deleteTimeSpan.ToString()}");
+                    Debug.WriteLine($"Deleting message: {message.Content.Content}");
+                    await DeleteMessage(message);
+                    return;
+                }
+                Debug.WriteLine($"Deleting message in {deleteTimeSpan.TotalSeconds} seconds");
+                await Task.Delay(deleteTimeSpan);
+                Debug.WriteLine($"Deleting message: {message.Content.Content}");
+                await DeleteMessage(message);
+            };
+            Task.Run(deleteTask);
+        }
+
+        private static async Task DeleteMessage(SignalMessage message)
+        {
+            List<Task> operations = new List<Task>();
+            foreach (var dispatcher in frames.Keys)
+            {
+                var taskCompletionSource = new TaskCompletionSource<bool>();
+                await dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
+                {
+                    try
+                    {
+                        frames[dispatcher].HandleMessageDelete(message);
+                    }
+                    catch (Exception e)
+                    {
+                    }
+                    finally
+                    {
+                        taskCompletionSource.SetResult(false);
+                    }
+                });
+                operations.Add(taskCompletionSource.Task);
+            }
+
+            foreach (var t in operations)
+            {
+                await t;
+            }
+
+            foreach (var attachment in message.Attachments)
+            {
+                SignalDBContext.DeleteAttachment(attachment);
+            }
+            SignalDBContext.DeleteMessage(message);
+        }
+    }
+}

Signal-Windows.Lib/IncomingMessages.cs

@@ -322,14 +322,26 @@ private async Task HandleExpirationUpdateMessage(SignalServiceEnvelope envelope,
                     conversation = await SignalDBContext.GetOrCreateContactLocked(envelope.GetSource(), 0);
                 }
             }
+            conversation.ExpiresInSeconds = (uint)message.ExpiresInSeconds;
             SignalDBContext.UpdateExpiresInLocked(conversation, (uint)message.ExpiresInSeconds);
+            string finalMessage;
+            if (message.ExpiresInSeconds == 0)
+            {
+                finalMessage = $"{prefix} has turned off disappearing messages.";
+            }
+            else
+            {
+                finalMessage = $"{prefix} set disappearing message time to {message.ExpiresInSeconds} seconds.";
+            }
+            // Update conversations to reflect the new expires in seconds
+            await SignalLibHandle.Instance.DispatchAddOrUpdateConversation(conversation, null);
             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." },
+                Content = new SignalMessageContent() { Content = finalMessage },
                 ThreadId = conversation.ThreadId,
                 DeviceId = (uint)envelope.GetSourceDevice(),
                 Receipts = 0,
@@ -518,6 +530,15 @@ private async Task HandleGroupUpdateMessage(SignalServiceEnvelope envelope, Sign
                     composedTimestamp = envelope.GetTimestamp();
                 }
 
+                long messageExpiration;
+                if (dataMessage.ExpiresInSeconds == 0)
+                {
+                    messageExpiration = 0;
+                }
+                else
+                {
+                    messageExpiration = timestamp + (long)TimeSpan.FromSeconds(dataMessage.ExpiresInSeconds).TotalMilliseconds;
+                }
                 SignalMessage sm = new SignalMessage()
                 {
                     Direction = type,
@@ -530,6 +551,7 @@ private async Task HandleGroupUpdateMessage(SignalServiceEnvelope envelope, Sign
                     Receipts = 0,
                     ComposedTimestamp = composedTimestamp,
                     ReceivedTimestamp = timestamp,
+                    ExpiresAt = messageExpiration
                 };
                 SignalDBContext.SaveMessageLocked(sm);
                 dbgroup.MessagesCount += 1;
@@ -615,6 +637,15 @@ private async Task HandleSignalMessage(SignalServiceEnvelope envelope, SignalSer
                 return;
             }
 
+            long messageExpiration;
+            if (dataMessage.ExpiresInSeconds == 0)
+            {
+                messageExpiration = 0;
+            }
+            else
+            {
+                messageExpiration = timestamp + (long)TimeSpan.FromSeconds(dataMessage.ExpiresInSeconds).TotalMilliseconds;
+            }
             List<SignalAttachment> attachments = new List<SignalAttachment>();
             SignalMessage message = new SignalMessage()
             {
@@ -627,6 +658,7 @@ private async Task HandleSignalMessage(SignalServiceEnvelope envelope, SignalSer
                 Receipts = 0,
                 ComposedTimestamp = composedTimestamp,
                 ReceivedTimestamp = timestamp,
+                ExpiresAt = messageExpiration,
                 AttachmentsCount = (uint)attachments.Count,
                 Attachments = attachments
             };
@@ -654,6 +686,7 @@ private async Task HandleSignalMessage(SignalServiceEnvelope envelope, SignalSer
                 // Make sure to update attachments count
                 message.AttachmentsCount = (uint)attachments.Count;
             }
+            DisappearingMessagesManager.AddMessage(message);
             await SignalLibHandle.Instance.SaveAndDispatchSignalMessage(message, conversation);
         }
     }

Signal-Windows.Lib/Migrations/SignalDB/SignalDBContextModelSnapshot.cs

@@ -4,7 +4,6 @@
 using Microsoft.EntityFrameworkCore.Metadata;
 using Microsoft.EntityFrameworkCore.Migrations;
 using Signal_Windows.Storage;
-using Signal_Windows.Models;
 
 namespace Signal_Windows.Migrations
 {

Signal-Windows.Lib/Models/SignalMessage.cs

@@ -19,7 +19,7 @@ public class SignalMessage
         public uint Receipts { get; set; }
         public long ReceivedTimestamp { get; set; }
         public long ComposedTimestamp { get; set; }
-        public uint ExpiresAt { get; set; }
+        public long ExpiresAt { get; set; }
         public uint AttachmentsCount { get; set; }
         public List<SignalAttachment> Attachments { get; set; } = new List<SignalAttachment>();
     }

Signal-Windows.Lib/OutgoingMessages.cs

@@ -80,6 +80,8 @@ public async Task HandleOutgoingMessages()
                         if (!Token.IsCancellationRequested)
                         {
                             await MessageSender.SendMessage(Token, new SignalServiceAddress(outgoingSignalMessage.ThreadId), message);
+                            UpdateExpiresAt(outgoingSignalMessage);
+                            DisappearingMessagesManager.AddMessage(outgoingSignalMessage);
                             outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
                         }
                     }
@@ -102,6 +104,8 @@ public async Task HandleOutgoingMessages()
                         if (!Token.IsCancellationRequested)
                         {
                             await SendMessage(recipients, message);
+                            UpdateExpiresAt(outgoingSignalMessage);
+                            DisappearingMessagesManager.AddMessage(outgoingSignalMessage);
                             outgoingSignalMessage.Status = SignalMessageStatus.Confirmed;
                         }
                     }
@@ -150,5 +154,24 @@ public async Task HandleOutgoingMessages()
             }
             Logger.LogInformation("HandleOutgoingMessages() finished");
         }
+
+        /// <summary>
+        /// Updates a message ExpiresAt to be a timestamp instead of a relative value.
+        /// </summary>
+        /// <param name="message">The message to update</param>
+        private void UpdateExpiresAt(SignalMessage message)
+        {
+            // We update here instead of earlier because we only want to start the timer once the message is actually sent.
+            long messageExpiration;
+            if (message.ExpiresAt == 0)
+            {
+                messageExpiration = 0;
+            }
+            else
+            {
+                messageExpiration = Util.CurrentTimeMillis() + (long)TimeSpan.FromSeconds(message.ExpiresAt).TotalMilliseconds;
+            }
+            message.ExpiresAt = messageExpiration;
+        }
     }
 }

Signal-Windows.Lib/Signal-Windows.Lib.csproj

@@ -106,6 +106,7 @@
     <RestoreProjectStyle>PackageReference</RestoreProjectStyle>
   </PropertyGroup>
   <ItemGroup>
+    <Compile Include="DisappearingMessagesManager.cs" />
     <Compile Include="Events\SignalMessageEventArgs.cs" />
     <Compile Include="GlobalSettingsManager.cs" />
     <Compile Include="IncomingMessages.cs" />

Signal-Windows.Lib/SignalLibHandle.cs

@@ -48,6 +48,7 @@ public interface ISignalFrontend
         Task HandleAuthFailure();
         void HandleAttachmentStatusChanged(SignalAttachment sa);
         void HandleBlockedContacts(List<SignalContact> blockedContacts);
+        void HandleMessageDelete(SignalMessage messsage);
     }
 
     public interface ISignalLibHandle
@@ -131,6 +132,7 @@ public bool AddFrontend(CoreDispatcher d, ISignalFrontend w)
                     Logger.LogInformation("Registering frontend of dispatcher {0}", w.GetHashCode());
                     Frames.Add(d, w);
                     w.ReplaceConversationList(GetConversations());
+                    DisappearingMessagesManager.AddFrontend(d, w);
                     return true;
                 }
                 else
@@ -152,6 +154,7 @@ public void RemoveFrontend(CoreDispatcher d)
             SemaphoreSlim.Wait(CancelSource.Token);
             Logger.LogTrace("RemoveFrontend() locked");
             Logger.LogInformation("Unregistering frontend of dispatcher {0}", d.GetHashCode());
+            DisappearingMessagesManager.RemoveFrontend(d);
             Frames.Remove(d);
             SemaphoreSlim.Release();
             Logger.LogTrace("RemoveFrontend() released");

Signal-Windows.Lib/Storage/DB.cs

@@ -919,6 +919,33 @@ public static SignalMessage IncreaseReceiptCountLocked(SignalServiceEnvelope env
             return set_mark? m : null;
         }
 
+        public static void DeleteMessage(SignalMessage message)
+        {
+            lock (DBLock)
+            {
+                using (var ctx = new SignalDBContext())
+                {
+                    ctx.Remove(message);
+                    SignalConversation conversation = ctx.Contacts
+                        .Where(c => c.ThreadId == message.ThreadId)
+                        .Single();
+                    conversation.MessagesCount -= 1;
+                    conversation.LastMessage = null;
+                    conversation.LastMessageId = null;
+                    conversation.LastSeenMessage = null;
+                    conversation.LastSeenMessageIndex = ctx.Messages
+                        .Where(m => m.ThreadId == conversation.ThreadId)
+                        .Count() - 1;
+
+                    // also delete fts message
+                    SignalMessageContent ftsMessage = ctx.Messages_fts.Where(m => m == message.Content)
+                        .Single();
+                    ctx.Remove(ftsMessage);
+                    ctx.SaveChanges();
+                }
+            }
+        }
+
         #endregion Messages
 
         #region Attachments
@@ -936,6 +963,18 @@ public static SignalAttachment GetAttachmentByGuidNameLocked(string guid)
             }
         }
 
+        public static void DeleteAttachment(SignalAttachment attachment)
+        {
+            lock (DBLock)
+            {
+                using (var ctx = new SignalDBContext())
+                {
+                    ctx.Remove(attachment);
+                    ctx.SaveChanges();
+                }
+            }
+        }
+
         internal static void UpdateAttachmentGuid(SignalAttachment attachment)
         {
             lock (DBLock)

Signal-Windows/App.xaml.cs

@@ -260,6 +260,7 @@ await newView.Dispatcher.RunAsync(CoreDispatcherPriority.Normal, () =>
             if (success)
             {
                 Views.Add(newViewId, frontend);
+                DisappearingMessagesManager.AddFrontend(frontend.Dispatcher, frontend);
                 await switcher.ShowAsStandaloneAsync(newViewId);
                 Logger.LogInformation("CreateSecondaryWindow() added view {0}", newViewId);
             }
@@ -316,6 +317,7 @@ private async Task<bool> CreateMainWindow(string conversationId)
                 }
                 var frontend = new SignalWindowsFrontend(Window.Current.Dispatcher, (ViewModelLocator)Resources["Locator"], currView.Id);
                 Views.Add(currView.Id, frontend);
+                DisappearingMessagesManager.AddFrontend(frontend.Dispatcher, frontend);
                 MainViewId = currView.Id;
                 SetupTopBar();
 
@@ -359,6 +361,7 @@ private void CurrView_Consolidated(ApplicationView sender, ApplicationViewConsol
             var signalWindowsFrontend = Views[sender.Id];
             Handle.RemoveFrontend(signalWindowsFrontend.Dispatcher);
             Views.Remove(sender.Id);
+            DisappearingMessagesManager.RemoveFrontend(signalWindowsFrontend.Dispatcher);
             if (sender.Id != MainViewId)
             {
                 Window.Current.Close();

Signal-Windows/Controls/Conversation.xaml.cs

@@ -280,6 +280,11 @@ public AppendResult Append(Message sm)
             }
             return result;
         }
+
+        public void HandleDeleteMesage(SignalMessage message)
+        {
+            Collection.Remove(message);
+        }
 
         private async void TextBox_KeyDown(object sender, KeyRoutedEventArgs e)
         {