expiration timer handling updated

app/src/main/java/org/thoughtcrime/securesms/service/ExpiringMessageManager.java

@@ -4,8 +4,10 @@ import android.content.Context;
 
 import org.jetbrains.annotations.NotNull;
 import org.jetbrains.annotations.Nullable;
+import org.session.libsession.messaging.messages.control.ExpirationTimerUpdate;
 import org.session.libsession.messaging.threads.Address;
 import org.session.libsession.messaging.threads.recipients.Recipient;
+import org.session.libsession.utilities.GroupUtil;
 import org.session.libsession.utilities.SSKEnvironment;
 import org.session.libsignal.libsignal.util.guava.Optional;
 import org.session.libsignal.service.api.messages.SignalServiceGroup;
@@ -20,6 +22,7 @@ import org.thoughtcrime.securesms.database.model.MessageRecord;
 import org.session.libsession.messaging.messages.signal.IncomingMediaMessage;
 import org.thoughtcrime.securesms.mms.MmsException;
 
+import java.io.IOException;
 import java.util.Comparator;
 import java.util.TreeSet;
 import java.util.concurrent.Executor;
@@ -65,20 +68,30 @@ public class ExpiringMessageManager implements SSKEnvironment.MessageExpirationM
   }
 
   @Override
-  public void setExpirationTimer(@Nullable Long messageID, int duration, @NotNull String senderPublicKey, @NotNull SignalServiceProtos.Content content) {
+  public void setExpirationTimer(@NotNull ExpirationTimerUpdate message) {
+    MmsDatabase database = DatabaseFactory.getMmsDatabase(context);
+
+    String senderPublicKey = message.getSender();
+    int duration = message.getDuration();
+    String groupPK = message.getGroupPublicKey();
+    Long sentTimestamp = message.getSentTimestamp();
+
+    Optional<SignalServiceGroup> groupInfo = Optional.absent();
+    Address address;
+
     try {
-      MmsDatabase          database     = DatabaseFactory.getMmsDatabase(context);
+      if (groupPK != null) {
-      Address              address      = Address.fromSerialized(senderPublicKey);
+        String groupID = GroupUtil.doubleEncodeGroupID(groupPK);
+        groupInfo = Optional.of(new SignalServiceGroup(GroupUtil.getDecodedGroupIDAsData(groupID), SignalServiceGroup.GroupType.SIGNAL));
+        address      = Address.fromSerialized(groupID);
+      } else {
+        address      = Address.fromSerialized(senderPublicKey);
+      }
       Recipient            recipient    = Recipient.from(context, address, false);
 
       if (recipient.isBlocked()) return;
 
-      Optional<SignalServiceGroup> groupInfo = Optional.absent();
+      IncomingMediaMessage mediaMessage = new IncomingMediaMessage(address, sentTimestamp, -1,
-      if (content.getDataMessage().hasGroup()) {
-        GroupContext groupContext = content.getDataMessage().getGroup();
-        groupInfo = Optional.of(new SignalServiceGroup(groupContext.getId().toByteArray(), SignalServiceGroup.GroupType.SIGNAL));
-      }
-      IncomingMediaMessage mediaMessage = new IncomingMediaMessage(address, content.getDataMessage().getTimestamp(), -1,
               duration * 1000L, true,
               false,
               Optional.absent(),
@@ -87,22 +100,24 @@ public class ExpiringMessageManager implements SSKEnvironment.MessageExpirationM
               Optional.absent(),
               Optional.absent(),
               Optional.absent());
-
+      //insert the timer update message
       database.insertSecureDecryptedMessageInbox(mediaMessage, -1);
-
+      //set the timer to the conversation
       DatabaseFactory.getRecipientDatabase(context).setExpireMessages(recipient, duration);
 
-      if (messageID != null) {
+      if (message.getId() != null) {
-        DatabaseFactory.getSmsDatabase(context).deleteMessage(messageID);
+        DatabaseFactory.getSmsDatabase(context).deleteMessage(message.getId());
       }
     } catch (MmsException e) {
       Log.e("Loki", "Failed to insert expiration update message.");
+    } catch (IOException ioe) {
+      Log.e("Loki", "Failed to insert expiration update message.");
     }
   }
 
   @Override
-  public void disableExpirationTimer(@Nullable Long messageID, @NotNull String senderPublicKey, @NotNull SignalServiceProtos.Content content) {
+  public void disableExpirationTimer(@NotNull ExpirationTimerUpdate message) {
-    setExpirationTimer(messageID, 0, senderPublicKey, content);
+    setExpirationTimer(message);
   }
 
   @Override

libsession/src/main/java/org/session/libsession/messaging/sending_receiving/MessageReceiverHandler.kt

@@ -41,7 +41,7 @@ fun MessageReceiver.handle(message: Message, proto: SignalServiceProtos.Content,
         is ReadReceipt -> handleReadReceipt(message)
         is TypingIndicator -> handleTypingIndicator(message)
         is ClosedGroupControlMessage -> handleClosedGroupControlMessage(message)
-        is ExpirationTimerUpdate -> handleExpirationTimerUpdate(message, proto)
+        is ExpirationTimerUpdate -> handleExpirationTimerUpdate(message)
         is ConfigurationMessage -> handleConfigurationMessage(message)
         is VisibleMessage -> handleVisibleMessage(message, proto, openGroupID)
     }
@@ -80,27 +80,14 @@ fun MessageReceiver.cancelTypingIndicatorsIfNeeded(senderPublicKey: String) {
     SSKEnvironment.shared.typingIndicators.didReceiveIncomingMessage(context, threadID, address, 1)
 }
 
-private fun MessageReceiver.handleExpirationTimerUpdate(message: ExpirationTimerUpdate, proto: SignalServiceProtos.Content) {
+private fun MessageReceiver.handleExpirationTimerUpdate(message: ExpirationTimerUpdate) {
     if (message.duration!! > 0) {
-        setExpirationTimer(message, proto)
+        SSKEnvironment.shared.messageExpirationManager.setExpirationTimer(message)
     } else {
-        disableExpirationTimer(message, proto)
+        SSKEnvironment.shared.messageExpirationManager.disableExpirationTimer(message)
     }
 }
 
-fun MessageReceiver.setExpirationTimer(message: ExpirationTimerUpdate, proto: SignalServiceProtos.Content) {
-    val id = message.id
-    val duration = message.duration!!
-    val senderPublicKey = message.sender!!
-    SSKEnvironment.shared.messageExpirationManager.setExpirationTimer(id, duration, senderPublicKey, proto)
-}
-
-fun MessageReceiver.disableExpirationTimer(message: ExpirationTimerUpdate, proto: SignalServiceProtos.Content) {
-    val id = message.id
-    val senderPublicKey = message.sender!!
-    SSKEnvironment.shared.messageExpirationManager.disableExpirationTimer(id, senderPublicKey, proto)
-}
-
 private fun MessageReceiver.handleConfigurationMessage(message: ConfigurationMessage) {
     val context = MessagingConfiguration.shared.context
     val storage = MessagingConfiguration.shared.storage

libsession/src/main/java/org/session/libsession/utilities/SSKEnvironment.kt

@@ -1,6 +1,7 @@
 package org.session.libsession.utilities
 
 import android.content.Context
+import org.session.libsession.messaging.messages.control.ExpirationTimerUpdate
 import org.session.libsession.messaging.sending_receiving.notifications.MessageNotifier
 import org.session.libsession.messaging.threads.Address
 import org.session.libsession.messaging.threads.recipients.Recipient
@@ -36,8 +37,8 @@ class SSKEnvironment(
     }
 
     interface MessageExpirationManagerProtocol {
-        fun setExpirationTimer(messageID: Long?, duration: Int, senderPublicKey: String, content: SignalServiceProtos.Content)
+        fun setExpirationTimer(message: ExpirationTimerUpdate)
-        fun disableExpirationTimer(messageID: Long?, senderPublicKey: String, content: SignalServiceProtos.Content)
+        fun disableExpirationTimer(message: ExpirationTimerUpdate)
         fun startAnyExpiration(timestamp: Long, author: String)
     }