Implement dbus support for listIdentities

[signal-cli] / src / main / java / org / asamk / signal / dbus / DbusManagerImpl.java

diff --git a/src/main/java/org/asamk/signal/dbus/DbusManagerImpl.java b/src/main/java/org/asamk/signal/dbus/DbusManagerImpl.java
index 0d87cdb5a05188ef03d4f4389648685f604a6f4d..574f68c6bb1a56c05cb9ecc74cef9302d7aacfcf 100644 (file)
--- a/src/main/java/org/asamk/signal/dbus/DbusManagerImpl.java
+++ b/src/main/java/org/asamk/signal/dbus/DbusManagerImpl.java
@@ -1,56 +1,84 @@
 package org.asamk.signal.dbus;
 
 import org.asamk.Signal;
 package org.asamk.signal.dbus;
 
 import org.asamk.Signal;

-import org.asamk.signal.DbusConfig;
-import org.asamk.signal.manager.AttachmentInvalidException;

 import org.asamk.signal.manager.Manager;
 import org.asamk.signal.manager.Manager;

-import org.asamk.signal.manager.NotMasterDeviceException;
-import org.asamk.signal.manager.StickerPackInvalidException;
-import org.asamk.signal.manager.UntrustedIdentityException;
+import org.asamk.signal.manager.api.AlreadyReceivingException;
+import org.asamk.signal.manager.api.AttachmentInvalidException;
+import org.asamk.signal.manager.api.CaptchaRequiredException;
+import org.asamk.signal.manager.api.Configuration;
+import org.asamk.signal.manager.api.Contact;

 import org.asamk.signal.manager.api.Device;
 import org.asamk.signal.manager.api.Device;

+import org.asamk.signal.manager.api.DeviceLinkUrl;

 import org.asamk.signal.manager.api.Group;
 import org.asamk.signal.manager.api.Group;

+import org.asamk.signal.manager.api.GroupId;
+import org.asamk.signal.manager.api.GroupInviteLinkUrl;
+import org.asamk.signal.manager.api.GroupNotFoundException;
+import org.asamk.signal.manager.api.GroupPermission;
+import org.asamk.signal.manager.api.GroupSendingNotAllowedException;

 import org.asamk.signal.manager.api.Identity;
 import org.asamk.signal.manager.api.Identity;

+import org.asamk.signal.manager.api.IdentityVerificationCode;

 import org.asamk.signal.manager.api.InactiveGroupLinkException;
 import org.asamk.signal.manager.api.InactiveGroupLinkException;

+import org.asamk.signal.manager.api.IncorrectPinException;

 import org.asamk.signal.manager.api.InvalidDeviceLinkException;
 import org.asamk.signal.manager.api.InvalidDeviceLinkException;

+import org.asamk.signal.manager.api.InvalidStickerException;
+import org.asamk.signal.manager.api.InvalidUsernameException;
+import org.asamk.signal.manager.api.LastGroupAdminException;

 import org.asamk.signal.manager.api.Message;
 import org.asamk.signal.manager.api.Message;

+import org.asamk.signal.manager.api.MessageEnvelope;
+import org.asamk.signal.manager.api.NonNormalizedPhoneNumberException;
+import org.asamk.signal.manager.api.NotAGroupMemberException;
+import org.asamk.signal.manager.api.NotPrimaryDeviceException;

 import org.asamk.signal.manager.api.Pair;
 import org.asamk.signal.manager.api.Pair;

+import org.asamk.signal.manager.api.PinLockedException;
+import org.asamk.signal.manager.api.RateLimitException;
+import org.asamk.signal.manager.api.ReceiveConfig;
+import org.asamk.signal.manager.api.Recipient;
+import org.asamk.signal.manager.api.RecipientAddress;

 import org.asamk.signal.manager.api.RecipientIdentifier;
 import org.asamk.signal.manager.api.SendGroupMessageResults;
 import org.asamk.signal.manager.api.SendMessageResults;
 import org.asamk.signal.manager.api.RecipientIdentifier;
 import org.asamk.signal.manager.api.SendGroupMessageResults;
 import org.asamk.signal.manager.api.SendMessageResults;

+import org.asamk.signal.manager.api.StickerPack;
+import org.asamk.signal.manager.api.StickerPackId;
+import org.asamk.signal.manager.api.StickerPackInvalidException;
+import org.asamk.signal.manager.api.StickerPackUrl;
+import org.asamk.signal.manager.api.TrustLevel;

 import org.asamk.signal.manager.api.TypingAction;
 import org.asamk.signal.manager.api.TypingAction;

+import org.asamk.signal.manager.api.UnregisteredRecipientException;

 import org.asamk.signal.manager.api.UpdateGroup;
 import org.asamk.signal.manager.api.UpdateGroup;

-import org.asamk.signal.manager.groups.GroupId;
-import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
-import org.asamk.signal.manager.groups.GroupNotFoundException;
-import org.asamk.signal.manager.groups.GroupPermission;
-import org.asamk.signal.manager.groups.GroupSendingNotAllowedException;
-import org.asamk.signal.manager.groups.LastGroupAdminException;
-import org.asamk.signal.manager.groups.NotAGroupMemberException;
-import org.asamk.signal.manager.storage.recipients.Contact;
-import org.asamk.signal.manager.storage.recipients.Profile;
-import org.asamk.signal.manager.storage.recipients.RecipientAddress;
+import org.asamk.signal.manager.api.UpdateProfile;
+import org.asamk.signal.manager.api.UserStatus;
+import org.asamk.signal.manager.api.UsernameLinkUrl;
+import org.asamk.signal.manager.api.UsernameStatus;
+import org.freedesktop.dbus.DBusMap;

 import org.freedesktop.dbus.DBusPath;
 import org.freedesktop.dbus.connections.impl.DBusConnection;
 import org.freedesktop.dbus.exceptions.DBusException;
 import org.freedesktop.dbus.DBusPath;
 import org.freedesktop.dbus.connections.impl.DBusConnection;
 import org.freedesktop.dbus.exceptions.DBusException;

+import org.freedesktop.dbus.exceptions.DBusExecutionException;

 import org.freedesktop.dbus.interfaces.DBusInterface;
 import org.freedesktop.dbus.interfaces.DBusInterface;

-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
-import org.whispersystems.signalservice.api.util.UuidUtil;
+import org.freedesktop.dbus.interfaces.DBusSigHandler;
+import org.freedesktop.dbus.types.Variant;

 
 import java.io.File;
 import java.io.IOException;
 
 import java.io.File;
 import java.io.IOException;

+import java.io.InputStream;

 import java.net.URI;
 import java.net.URISyntaxException;
 import java.net.URI;
 import java.net.URISyntaxException;

+import java.time.Duration;

 import java.util.ArrayList;
 import java.util.ArrayList;

+import java.util.Collection;

 import java.util.HashMap;
 import java.util.HashMap;

+import java.util.HashSet;

 import java.util.List;
 import java.util.Map;
 import java.util.List;
 import java.util.Map;

+import java.util.Objects;

 import java.util.Optional;
 import java.util.Set;
 import java.util.Optional;
 import java.util.Set;

-import java.util.UUID;
-import java.util.concurrent.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;

 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;
 import java.util.function.Function;
 import java.util.function.Supplier;
 import java.util.stream.Collectors;

+import java.util.stream.Stream;

 
 /**
  * This class implements the Manager interface using the DBus Signal interface, where possible.
 
 /**
  * This class implements the Manager interface using the DBus Signal interface, where possible.


@@ -61,9 +89,19 @@ public class DbusManagerImpl implements Manager {
     private final Signal signal;
     private final DBusConnection connection;
 
     private final Signal signal;
     private final DBusConnection connection;
 

-    public DbusManagerImpl(final Signal signal, DBusConnection connection) {
+    private final Set<ReceiveMessageHandler> weakHandlers = new HashSet<>();
+    private final Set<ReceiveMessageHandler> messageHandlers = new HashSet<>();
+    private final List<Runnable> closedListeners = new ArrayList<>();
+    private final String busname;
+    private DBusSigHandler<Signal.MessageReceivedV2> dbusMsgHandler;
+    private DBusSigHandler<Signal.EditMessageReceived> dbusEditMsgHandler;
+    private DBusSigHandler<Signal.ReceiptReceivedV2> dbusRcptHandler;
+    private DBusSigHandler<Signal.SyncMessageReceivedV2> dbusSyncHandler;
+
+    public DbusManagerImpl(final Signal signal, DBusConnection connection, final String busname) {

         this.signal = signal;
         this.connection = connection;
         this.signal = signal;
         this.connection = connection;

+        this.busname = busname;

     }
 
     @Override
     }
 
     @Override


@@ -72,95 +110,148 @@ public class DbusManagerImpl implements Manager {
     }
 
     @Override
     }
 
     @Override

-    public void checkAccountState() throws IOException {
-        throw new UnsupportedOperationException();
-    }
-
-    @Override
-    public Map<String, Pair<String, UUID>> areUsersRegistered(final Set<String> numbers) throws IOException {
+    public Map<String, UserStatus> getUserStatus(final Set<String> numbers) throws IOException {

         final var numbersList = new ArrayList<>(numbers);
         final var registered = signal.isRegistered(numbersList);
 
         final var numbersList = new ArrayList<>(numbers);
         final var registered = signal.isRegistered(numbersList);
 

-        final var result = new HashMap<String, Pair<String, UUID>>();
+        final var result = new HashMap<String, UserStatus>();

         for (var i = 0; i < numbersList.size(); i++) {
             result.put(numbersList.get(i),
         for (var i = 0; i < numbersList.size(); i++) {
             result.put(numbersList.get(i),

-                    new Pair<>(numbersList.get(i), registered.get(i) ? UuidUtil.UNKNOWN_UUID : null));
+                    new UserStatus(numbersList.get(i),
+                            registered.get(i) ? RecipientAddress.UNKNOWN_UUID : null,
+                            false));

         }
         return result;
     }
 
     @Override
         }
         return result;
     }
 
     @Override

-    public void updateAccountAttributes(final String deviceName) throws IOException {
+    public Map<String, UsernameStatus> getUsernameStatus(final Set<String> usernames) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void updateAccountAttributes(
+            final String deviceName,
+            final Boolean unrestrictedUnidentifiedSender,
+            final Boolean discoverableByNumber,
+            final Boolean numberSharing
+    ) throws IOException {

         if (deviceName != null) {
             final var devicePath = signal.getThisDevice();
             getRemoteObject(devicePath, Signal.Device.class).Set("org.asamk.Signal.Device", "Name", deviceName);
         if (deviceName != null) {
             final var devicePath = signal.getThisDevice();
             getRemoteObject(devicePath, Signal.Device.class).Set("org.asamk.Signal.Device", "Name", deviceName);

+        } else {
+            throw new UnsupportedOperationException();

         }
     }
 
     @Override
         }
     }
 
     @Override

-    public void updateConfiguration(
-            final Boolean readReceipts,
-            final Boolean unidentifiedDeliveryIndicators,
-            final Boolean typingIndicators,
-            final Boolean linkPreviews
-    ) throws IOException {
+    public Configuration getConfiguration() {
+        final var configuration = getRemoteObject(new DBusPath(signal.getObjectPath() + "/Configuration"),
+                Signal.Configuration.class).GetAll("org.asamk.Signal.Configuration");
+        return new Configuration(Optional.of((Boolean) configuration.get("ReadReceipts").getValue()),
+                Optional.of((Boolean) configuration.get("UnidentifiedDeliveryIndicators").getValue()),
+                Optional.of((Boolean) configuration.get("TypingIndicators").getValue()),
+                Optional.of((Boolean) configuration.get("LinkPreviews").getValue()));
+    }
+
+    @Override
+    public void updateConfiguration(Configuration newConfiguration) {
+        final var configuration = getRemoteObject(new DBusPath(signal.getObjectPath() + "/Configuration"),
+                Signal.Configuration.class);
+        newConfiguration.readReceipts()
+                .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "ReadReceipts", v));
+        newConfiguration.unidentifiedDeliveryIndicators()
+                .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration",
+                        "UnidentifiedDeliveryIndicators",
+                        v));
+        newConfiguration.typingIndicators()
+                .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "TypingIndicators", v));
+        newConfiguration.linkPreviews()
+                .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "LinkPreviews", v));
+    }
+
+    @Override
+    public void updateProfile(UpdateProfile updateProfile) throws IOException {
+        signal.updateProfile(emptyIfNull(updateProfile.getGivenName()),
+                emptyIfNull(updateProfile.getFamilyName()),
+                emptyIfNull(updateProfile.getAbout()),
+                emptyIfNull(updateProfile.getAboutEmoji()),
+                updateProfile.getAvatar() == null ? "" : updateProfile.getAvatar(),
+                updateProfile.isDeleteAvatar());
+    }
+
+    @Override
+    public String getUsername() {

         throw new UnsupportedOperationException();
     }
 
     @Override
         throw new UnsupportedOperationException();
     }
 
     @Override

-    public void setProfile(
-            final String givenName,
-            final String familyName,
-            final String about,
-            final String aboutEmoji,
-            final Optional<File> avatar
-    ) throws IOException {
-        signal.updateProfile(emptyIfNull(givenName),
-                emptyIfNull(familyName),
-                emptyIfNull(about),
-                emptyIfNull(aboutEmoji),
-                avatar == null ? "" : avatar.map(File::getPath).orElse(""),
-                avatar != null && !avatar.isPresent());
+    public UsernameLinkUrl getUsernameLink() {
+        throw new UnsupportedOperationException();

     }
 
     @Override
     }
 
     @Override

-    public void unregister() throws IOException {
+    public void setUsername(final String username) throws IOException, InvalidUsernameException {

         throw new UnsupportedOperationException();
     }
 
     @Override
         throw new UnsupportedOperationException();
     }
 
     @Override

-    public void deleteAccount() throws IOException {
+    public void deleteUsername() throws IOException {

         throw new UnsupportedOperationException();
     }
 
     @Override
         throw new UnsupportedOperationException();
     }
 
     @Override

-    public void submitRateLimitRecaptchaChallenge(final String challenge, final String captcha) throws IOException {
+    public void startChangeNumber(
+            final String newNumber, final boolean voiceVerification, final String captcha
+    ) throws RateLimitException, IOException, CaptchaRequiredException, NonNormalizedPhoneNumberException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void finishChangeNumber(
+            final String newNumber, final String verificationCode, final String pin
+    ) throws IncorrectPinException, PinLockedException, IOException {

         throw new UnsupportedOperationException();
     }
 
         throw new UnsupportedOperationException();
     }
 

+    @Override
+    public void unregister() throws IOException {
+        signal.unregister();
+    }
+
+    @Override
+    public void deleteAccount() throws IOException {
+        signal.deleteAccount();
+    }
+
+    @Override
+    public void submitRateLimitRecaptchaChallenge(final String challenge, final String captcha) throws IOException {
+        signal.submitRateLimitChallenge(challenge, captcha);
+    }
+

     @Override
     public List<Device> getLinkedDevices() throws IOException {
         final var thisDevice = signal.getThisDevice();
         return signal.listDevices().stream().map(d -> {
             final var device = getRemoteObject(d.getObjectPath(),
                     Signal.Device.class).GetAll("org.asamk.Signal.Device");
     @Override
     public List<Device> getLinkedDevices() throws IOException {
         final var thisDevice = signal.getThisDevice();
         return signal.listDevices().stream().map(d -> {
             final var device = getRemoteObject(d.getObjectPath(),
                     Signal.Device.class).GetAll("org.asamk.Signal.Device");

-            return new Device((long) device.get("Id").getValue(),
+            return new Device((Integer) device.get("Id").getValue(),

                     (String) device.get("Name").getValue(),
                     (long) device.get("Created").getValue(),
                     (long) device.get("LastSeen").getValue(),
                     thisDevice.equals(d.getObjectPath()));
                     (String) device.get("Name").getValue(),
                     (long) device.get("Created").getValue(),
                     (long) device.get("LastSeen").getValue(),
                     thisDevice.equals(d.getObjectPath()));

-        }).collect(Collectors.toList());
+        }).toList();

     }
 
     @Override
     }
 
     @Override

-    public void removeLinkedDevices(final long deviceId) throws IOException {
+    public void removeLinkedDevices(final int deviceId) throws IOException {

         final var devicePath = signal.getDevice(deviceId);
         getRemoteObject(devicePath, Signal.Device.class).removeDevice();
     }
 
     @Override
         final var devicePath = signal.getDevice(deviceId);
         getRemoteObject(devicePath, Signal.Device.class).removeDevice();
     }
 
     @Override

-    public void addDeviceLink(final URI linkUri) throws IOException, InvalidDeviceLinkException {
-        signal.addDevice(linkUri.toString());
+    public void addDeviceLink(final DeviceLinkUrl linkUri) throws IOException, InvalidDeviceLinkException {
+        signal.addDevice(linkUri.createDeviceLinkUri().toString());

     }
 
     @Override
     }
 
     @Override


@@ -172,41 +263,45 @@ public class DbusManagerImpl implements Manager {
         }
     }
 
         }
     }
 

-    @Override
-    public Profile getRecipientProfile(final RecipientIdentifier.Single recipient) throws UnregisteredUserException {
-        throw new UnsupportedOperationException();
-    }
-

     @Override
     public List<Group> getGroups() {
         final var groups = signal.listGroups();
     @Override
     public List<Group> getGroups() {
         final var groups = signal.listGroups();

-        return groups.stream().map(Signal.StructGroup::getObjectPath).map(this::getGroup).collect(Collectors.toList());
+        return groups.stream().map(Signal.StructGroup::getObjectPath).map(this::getGroup).toList();

     }
 
     @Override
     public SendGroupMessageResults quitGroup(
             final GroupId groupId, final Set<RecipientIdentifier.Single> groupAdmins
     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException {
     }
 
     @Override
     public SendGroupMessageResults quitGroup(
             final GroupId groupId, final Set<RecipientIdentifier.Single> groupAdmins
     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException {

-        if (groupAdmins.size() > 0) {
+        if (!groupAdmins.isEmpty()) {

             throw new UnsupportedOperationException();
         }
         final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
             throw new UnsupportedOperationException();
         }
         final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);

-        group.quitGroup();
+        try {
+            group.quitGroup();
+        } catch (Signal.Error.GroupNotFound e) {
+            throw new GroupNotFoundException(groupId);
+        } catch (Signal.Error.NotAGroupMember e) {
+            throw new NotAGroupMemberException(groupId, group.Get("org.asamk.Signal.Group", "Name"));
+        } catch (Signal.Error.LastGroupAdmin e) {
+            throw new LastGroupAdminException(groupId, group.Get("org.asamk.Signal.Group", "Name"));
+        }

         return new SendGroupMessageResults(0, List.of());
     }
 
     @Override
     public void deleteGroup(final GroupId groupId) throws IOException {
         return new SendGroupMessageResults(0, List.of());
     }
 
     @Override
     public void deleteGroup(final GroupId groupId) throws IOException {

-        throw new UnsupportedOperationException();
+        final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
+        group.deleteGroup();

     }
 
     @Override
     public Pair<GroupId, SendGroupMessageResults> createGroup(
     }
 
     @Override
     public Pair<GroupId, SendGroupMessageResults> createGroup(

-            final String name, final Set<RecipientIdentifier.Single> members, final File avatarFile
+            final String name, final Set<RecipientIdentifier.Single> members, final String avatarFile

     ) throws IOException, AttachmentInvalidException {
         final var newGroupId = signal.createGroup(emptyIfNull(name),
     ) throws IOException, AttachmentInvalidException {
         final var newGroupId = signal.createGroup(emptyIfNull(name),

-                members.stream().map(RecipientIdentifier.Single::getIdentifier).collect(Collectors.toList()),
-                avatarFile == null ? "" : avatarFile.getPath());
+                members.stream().map(RecipientIdentifier.Single::getIdentifier).toList(),
+                avatarFile == null ? "" : avatarFile);

         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
     }
 
         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
     }
 


@@ -224,7 +319,7 @@ public class DbusManagerImpl implements Manager {
         if (updateGroup.getAvatarFile() != null) {
             group.Set("org.asamk.Signal.Group",
                     "Avatar",
         if (updateGroup.getAvatarFile() != null) {
             group.Set("org.asamk.Signal.Group",
                     "Avatar",

-                    updateGroup.getAvatarFile() == null ? "" : updateGroup.getAvatarFile().getPath());
+                    updateGroup.getAvatarFile() == null ? "" : updateGroup.getAvatarFile());

         }
         if (updateGroup.getExpirationTimer() != null) {
             group.Set("org.asamk.Signal.Group", "MessageExpirationTimer", updateGroup.getExpirationTimer());
         }
         if (updateGroup.getExpirationTimer() != null) {
             group.Set("org.asamk.Signal.Group", "MessageExpirationTimer", updateGroup.getExpirationTimer());


@@ -243,28 +338,22 @@ public class DbusManagerImpl implements Manager {
                             : GroupPermission.EVERY_MEMBER.name());
         }
         if (updateGroup.getMembers() != null) {
                             : GroupPermission.EVERY_MEMBER.name());
         }
         if (updateGroup.getMembers() != null) {

-            group.addMembers(updateGroup.getMembers()
-                    .stream()
-                    .map(RecipientIdentifier.Single::getIdentifier)
-                    .collect(Collectors.toList()));
+            group.addMembers(updateGroup.getMembers().stream().map(RecipientIdentifier.Single::getIdentifier).toList());

         }
         if (updateGroup.getRemoveMembers() != null) {
             group.removeMembers(updateGroup.getRemoveMembers()
                     .stream()
                     .map(RecipientIdentifier.Single::getIdentifier)
         }
         if (updateGroup.getRemoveMembers() != null) {
             group.removeMembers(updateGroup.getRemoveMembers()
                     .stream()
                     .map(RecipientIdentifier.Single::getIdentifier)

-                    .collect(Collectors.toList()));
+                    .toList());

         }
         if (updateGroup.getAdmins() != null) {
         }
         if (updateGroup.getAdmins() != null) {

-            group.addAdmins(updateGroup.getAdmins()
-                    .stream()
-                    .map(RecipientIdentifier.Single::getIdentifier)
-                    .collect(Collectors.toList()));
+            group.addAdmins(updateGroup.getAdmins().stream().map(RecipientIdentifier.Single::getIdentifier).toList());

         }
         if (updateGroup.getRemoveAdmins() != null) {
             group.removeAdmins(updateGroup.getRemoveAdmins()
                     .stream()
                     .map(RecipientIdentifier.Single::getIdentifier)
         }
         if (updateGroup.getRemoveAdmins() != null) {
             group.removeAdmins(updateGroup.getRemoveAdmins()
                     .stream()
                     .map(RecipientIdentifier.Single::getIdentifier)

-                    .collect(Collectors.toList()));
+                    .toList());

         }
         if (updateGroup.isResetGroupLink()) {
             group.resetLink();
         }
         if (updateGroup.isResetGroupLink()) {
             group.resetLink();


@@ -281,41 +370,50 @@ public class DbusManagerImpl implements Manager {
 
     @Override
     public Pair<GroupId, SendGroupMessageResults> joinGroup(final GroupInviteLinkUrl inviteLinkUrl) throws IOException, InactiveGroupLinkException {
 
     @Override
     public Pair<GroupId, SendGroupMessageResults> joinGroup(final GroupInviteLinkUrl inviteLinkUrl) throws IOException, InactiveGroupLinkException {

-        final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
-        return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
+        try {
+            final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
+            return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
+        } catch (DBusExecutionException e) {
+            throw new IOException("Failed to join group: " + e.getMessage() + " (" + e.getClass().getSimpleName() + ")",
+                    e);
+        }

     }
 
     @Override
     }
 
     @Override

-    public void sendTypingMessage(
+    public SendMessageResults sendTypingMessage(

             final TypingAction action, final Set<RecipientIdentifier> recipients
             final TypingAction action, final Set<RecipientIdentifier> recipients

-    ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
-        for (final var recipient : recipients) {
-            if (recipient instanceof RecipientIdentifier.Single) {
-                signal.sendTyping(((RecipientIdentifier.Single) recipient).getIdentifier(),
-                        action == TypingAction.STOP);
-            } else if (recipient instanceof RecipientIdentifier.Group) {
-                throw new UnsupportedOperationException();
-            }
-        }
+    ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
+        return handleMessage(recipients, numbers -> {
+            numbers.forEach(n -> signal.sendTyping(n, action == TypingAction.STOP));
+            return 0L;
+        }, () -> {
+            signal.sendTyping(signal.getSelfNumber(), action == TypingAction.STOP);
+            return 0L;
+        }, groupId -> {
+            signal.sendGroupTyping(groupId, action == TypingAction.STOP);
+            return 0L;
+        });

     }
 
     @Override
     }
 
     @Override

-    public void sendReadReceipt(
+    public SendMessageResults sendReadReceipt(

             final RecipientIdentifier.Single sender, final List<Long> messageIds
             final RecipientIdentifier.Single sender, final List<Long> messageIds

-    ) throws IOException, UntrustedIdentityException {
+    ) {

         signal.sendReadReceipt(sender.getIdentifier(), messageIds);
         signal.sendReadReceipt(sender.getIdentifier(), messageIds);

+        return new SendMessageResults(0, Map.of());

     }
 
     @Override
     }
 
     @Override

-    public void sendViewedReceipt(
+    public SendMessageResults sendViewedReceipt(

             final RecipientIdentifier.Single sender, final List<Long> messageIds
             final RecipientIdentifier.Single sender, final List<Long> messageIds

-    ) throws IOException, UntrustedIdentityException {
-        throw new UnsupportedOperationException();
+    ) {
+        signal.sendViewedReceipt(sender.getIdentifier(), messageIds);
+        return new SendMessageResults(0, Map.of());

     }
 
     @Override
     public SendMessageResults sendMessage(
     }
 
     @Override
     public SendMessageResults sendMessage(

-            final Message message, final Set<RecipientIdentifier> recipients
+            final Message message, final Set<RecipientIdentifier> recipients, final boolean notifySelf

     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
         return handleMessage(recipients,
                 numbers -> signal.sendMessage(message.messageText(), message.attachments(), numbers),
     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
         return handleMessage(recipients,
                 numbers -> signal.sendMessage(message.messageText(), message.attachments(), numbers),


@@ -323,6 +421,13 @@ public class DbusManagerImpl implements Manager {
                 groupId -> signal.sendGroupMessage(message.messageText(), message.attachments(), groupId));
     }
 
                 groupId -> signal.sendGroupMessage(message.messageText(), message.attachments(), groupId));
     }
 

+    @Override
+    public SendMessageResults sendEditMessage(
+            final Message message, final Set<RecipientIdentifier> recipients, final long editTargetTimestamp
+    ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException {
+        throw new UnsupportedOperationException();
+    }
+

     @Override
     public SendMessageResults sendRemoteDeleteMessage(
             final long targetSentTimestamp, final Set<RecipientIdentifier> recipients
     @Override
     public SendMessageResults sendRemoteDeleteMessage(
             final long targetSentTimestamp, final Set<RecipientIdentifier> recipients


@@ -339,7 +444,8 @@ public class DbusManagerImpl implements Manager {
             final boolean remove,
             final RecipientIdentifier.Single targetAuthor,
             final long targetSentTimestamp,
             final boolean remove,
             final RecipientIdentifier.Single targetAuthor,
             final long targetSentTimestamp,

-            final Set<RecipientIdentifier> recipients
+            final Set<RecipientIdentifier> recipients,
+            final boolean isStory

     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
         return handleMessage(recipients,
                 numbers -> signal.sendMessageReaction(emoji,
     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
         return handleMessage(recipients,
                 numbers -> signal.sendMessageReaction(emoji,


@@ -359,33 +465,65 @@ public class DbusManagerImpl implements Manager {
                         groupId));
     }
 
                         groupId));
     }
 

+    @Override
+    public SendMessageResults sendPaymentNotificationMessage(
+            final byte[] receipt, final String note, final RecipientIdentifier.Single recipient
+    ) throws IOException {
+        final var timestamp = signal.sendPaymentNotification(receipt, note, recipient.getIdentifier());
+        return new SendMessageResults(timestamp, Map.of());
+    }
+

     @Override
     public SendMessageResults sendEndSessionMessage(final Set<RecipientIdentifier.Single> recipients) throws IOException {
     @Override
     public SendMessageResults sendEndSessionMessage(final Set<RecipientIdentifier.Single> recipients) throws IOException {

-        signal.sendEndSessionMessage(recipients.stream()
-                .map(RecipientIdentifier.Single::getIdentifier)
-                .collect(Collectors.toList()));
+        signal.sendEndSessionMessage(recipients.stream().map(RecipientIdentifier.Single::getIdentifier).toList());

         return new SendMessageResults(0, Map.of());
     }
 
         return new SendMessageResults(0, Map.of());
     }
 

+    @Override
+    public SendMessageResults sendMessageRequestResponse(
+            final MessageEnvelope.Sync.MessageRequestResponse.Type type,
+            final Set<RecipientIdentifier> recipientIdentifiers
+    ) {
+        throw new UnsupportedOperationException();
+    }
+
+    public void hideRecipient(final RecipientIdentifier.Single recipient) {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public void deleteRecipient(final RecipientIdentifier.Single recipient) {
+        signal.deleteRecipient(recipient.getIdentifier());
+    }
+
+    @Override
+    public void deleteContact(final RecipientIdentifier.Single recipient) {
+        signal.deleteContact(recipient.getIdentifier());
+    }
+

     @Override
     public void setContactName(
     @Override
     public void setContactName(

-            final RecipientIdentifier.Single recipient, final String name
-    ) throws NotMasterDeviceException, UnregisteredUserException {
-        signal.setContactName(recipient.getIdentifier(), name);
+            final RecipientIdentifier.Single recipient, final String givenName, final String familyName
+    ) throws NotPrimaryDeviceException {
+        signal.setContactName(recipient.getIdentifier(), givenName);

     }
 
     @Override
     }
 
     @Override

-    public void setContactBlocked(
-            final RecipientIdentifier.Single recipient, final boolean blocked
-    ) throws NotMasterDeviceException, IOException {
-        signal.setContactBlocked(recipient.getIdentifier(), blocked);
+    public void setContactsBlocked(
+            final Collection<RecipientIdentifier.Single> recipients, final boolean blocked
+    ) throws NotPrimaryDeviceException, IOException {
+        for (final var recipient : recipients) {
+            signal.setContactBlocked(recipient.getIdentifier(), blocked);
+        }

     }
 
     @Override
     }
 
     @Override

-    public void setGroupBlocked(
-            final GroupId groupId, final boolean blocked
+    public void setGroupsBlocked(
+            final Collection<GroupId> groupIds, final boolean blocked

     ) throws GroupNotFoundException, IOException {
     ) throws GroupNotFoundException, IOException {

-        setGroupProperty(groupId, "IsBlocked", blocked);
+        for (final var groupId : groupIds) {
+            setGroupProperty(groupId, "IsBlocked", blocked);
+        }

     }
 
     private void setGroupProperty(final GroupId groupId, final String propertyName, final boolean blocked) {
     }
 
     private void setGroupProperty(final GroupId groupId, final String propertyName, final boolean blocked) {


@@ -401,54 +539,122 @@ public class DbusManagerImpl implements Manager {
     }
 
     @Override
     }
 
     @Override

-    public URI uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {
+    public StickerPackUrl uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {

         try {
         try {

-            return new URI(signal.uploadStickerPack(path.getPath()));
-        } catch (URISyntaxException e) {
+            return StickerPackUrl.fromUri(new URI(signal.uploadStickerPack(path.getPath())));
+        } catch (URISyntaxException | StickerPackUrl.InvalidStickerPackLinkException e) {

             throw new AssertionError(e);
         }
     }
 
             throw new AssertionError(e);
         }
     }
 

+    @Override
+    public void installStickerPack(final StickerPackUrl url) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public List<StickerPack> getStickerPacks() {
+        throw new UnsupportedOperationException();
+    }
+

     @Override
     public void requestAllSyncData() throws IOException {
         signal.sendSyncRequest();
     }
 
     @Override
     @Override
     public void requestAllSyncData() throws IOException {
         signal.sendSyncRequest();
     }
 
     @Override

-    public void addReceiveHandler(final ReceiveMessageHandler handler) {
-        throw new UnsupportedOperationException();
+    public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
+        synchronized (messageHandlers) {
+            if (isWeakListener) {
+                weakHandlers.add(handler);
+            } else {
+                if (messageHandlers.isEmpty()) {
+                    installMessageHandlers();
+                }
+                messageHandlers.add(handler);
+            }
+        }

     }
 
     @Override
     public void removeReceiveHandler(final ReceiveMessageHandler handler) {
     }
 
     @Override
     public void removeReceiveHandler(final ReceiveMessageHandler handler) {

-        throw new UnsupportedOperationException();
+        synchronized (messageHandlers) {
+            weakHandlers.remove(handler);
+            messageHandlers.remove(handler);
+            if (messageHandlers.isEmpty()) {
+                uninstallMessageHandlers();
+            }
+        }

     }
 
     @Override
     public boolean isReceiving() {
     }
 
     @Override
     public boolean isReceiving() {

-        throw new UnsupportedOperationException();
+        synchronized (messageHandlers) {
+            return !messageHandlers.isEmpty();
+        }

     }
 
     }
 

-    @Override
-    public void receiveMessages(final ReceiveMessageHandler handler) throws IOException {
-        throw new UnsupportedOperationException();
-    }
+    private Thread receiveThread;

 
     @Override
     public void receiveMessages(
 
     @Override
     public void receiveMessages(

-            final long timeout, final TimeUnit unit, final ReceiveMessageHandler handler
-    ) throws IOException {
-        throw new UnsupportedOperationException();
+            Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
+    ) throws IOException, AlreadyReceivingException {
+        if (receiveThread != null) {
+            throw new AlreadyReceivingException("Already receiving message.");
+        }
+        receiveThread = Thread.currentThread();
+
+        final var remainingMessages = new AtomicInteger(maxMessages.orElse(-1));
+        final var lastMessage = new AtomicLong(System.currentTimeMillis());
+        final var thread = Thread.currentThread();
+
+        final ReceiveMessageHandler receiveHandler = (envelope, e) -> {
+            lastMessage.set(System.currentTimeMillis());
+            handler.handleMessage(envelope, e);
+            if (remainingMessages.get() > 0) {
+                if (remainingMessages.decrementAndGet() <= 0) {
+                    remainingMessages.set(0);
+                    thread.interrupt();
+                }
+            }
+        };
+        addReceiveHandler(receiveHandler);
+        if (timeout.isPresent()) {
+            while (remainingMessages.get() != 0) {
+                try {
+                    final var passedTime = System.currentTimeMillis() - lastMessage.get();
+                    final var sleepTimeRemaining = timeout.get().toMillis() - passedTime;
+                    if (sleepTimeRemaining < 0) {
+                        break;
+                    }
+                    Thread.sleep(sleepTimeRemaining);
+                } catch (InterruptedException ignored) {
+                    break;
+                }
+            }
+        } else {
+            try {
+                synchronized (this) {
+                    this.wait();
+                }
+            } catch (InterruptedException ignored) {
+            }
+        }
+
+        removeReceiveHandler(receiveHandler);
+        receiveThread = null;

     }
 
     @Override
     }
 
     @Override

-    public void setIgnoreAttachments(final boolean ignoreAttachments) {
-        throw new UnsupportedOperationException();
+    public void stopReceiveMessages() {
+        if (receiveThread != null) {
+            receiveThread.interrupt();
+        }

     }
 
     @Override
     }
 
     @Override

-    public boolean hasCaughtUpWithOldMessages() {
-        throw new UnsupportedOperationException();
+    public void setReceiveConfig(final ReceiveConfig receiveConfig) {

     }
 
     @Override
     }
 
     @Override


@@ -456,19 +662,53 @@ public class DbusManagerImpl implements Manager {
         return signal.isContactBlocked(recipient.getIdentifier());
     }
 
         return signal.isContactBlocked(recipient.getIdentifier());
     }
 

-    @Override
-    public File getAttachmentFile(final String attachmentId) {
-        throw new UnsupportedOperationException();
-    }
-

     @Override
     public void sendContacts() throws IOException {
         signal.sendContacts();
     }
 
     @Override
     @Override
     public void sendContacts() throws IOException {
         signal.sendContacts();
     }
 
     @Override

-    public List<Pair<RecipientAddress, Contact>> getContacts() {
-        throw new UnsupportedOperationException();
+    public List<Recipient> getRecipients(
+            final boolean onlyContacts,
+            final Optional<Boolean> blocked,
+            final Collection<RecipientIdentifier.Single> addresses,
+            final Optional<String> name
+    ) {
+        final var numbers = addresses.stream()
+                .filter(s -> s instanceof RecipientIdentifier.Number)
+                .map(s -> ((RecipientIdentifier.Number) s).number())
+                .collect(Collectors.toSet());
+        return signal.listNumbers().stream().filter(n -> addresses.isEmpty() || numbers.contains(n)).map(n -> {
+            final var contactBlocked = signal.isContactBlocked(n);
+            if (blocked.isPresent() && blocked.get() != contactBlocked) {
+                return null;
+            }
+            final var contactName = signal.getContactName(n);
+            if (onlyContacts && contactName.isEmpty()) {
+                return null;
+            }
+            if (name.isPresent() && !name.get().equals(contactName)) {
+                return null;
+            }
+            return Recipient.newBuilder()
+                    .withAddress(new RecipientAddress(n))
+                    .withContact(new Contact(contactName,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null,
+                            null,
+                            0,
+                            0,
+                            false,
+                            contactBlocked,
+                            false,
+                            false,
+                            false,
+                            null))
+                    .build();
+        }).filter(Objects::nonNull).toList();

     }
 
     @Override
     }
 
     @Override


@@ -492,16 +732,19 @@ public class DbusManagerImpl implements Manager {
                     (String) group.get("Description").getValue(),
                     GroupInviteLinkUrl.fromUri((String) group.get("GroupInviteLink").getValue()),
                     ((List<String>) group.get("Members").getValue()).stream()
                     (String) group.get("Description").getValue(),
                     GroupInviteLinkUrl.fromUri((String) group.get("GroupInviteLink").getValue()),
                     ((List<String>) group.get("Members").getValue()).stream()

-                            .map(m -> new RecipientAddress(null, m))
+                            .map(m -> new RecipientAddress(m))

                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("PendingMembers").getValue()).stream()
                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("PendingMembers").getValue()).stream()

-                            .map(m -> new RecipientAddress(null, m))
+                            .map(m -> new RecipientAddress(m))

                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("RequestingMembers").getValue()).stream()
                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("RequestingMembers").getValue()).stream()

-                            .map(m -> new RecipientAddress(null, m))
+                            .map(m -> new RecipientAddress(m))

                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("Admins").getValue()).stream()
                             .collect(Collectors.toSet()),
                     ((List<String>) group.get("Admins").getValue()).stream()

-                            .map(m -> new RecipientAddress(null, m))
+                            .map(m -> new RecipientAddress(m))
+                            .collect(Collectors.toSet()),
+                    ((List<String>) group.get("Banned").getValue()).stream()
+                            .map(m -> new RecipientAddress(m))

                             .collect(Collectors.toSet()),
                     (boolean) group.get("IsBlocked").getValue(),
                     (int) group.get("MessageExpirationTimer").getValue(),
                             .collect(Collectors.toSet()),
                     (boolean) group.get("IsBlocked").getValue(),
                     (int) group.get("MessageExpirationTimer").getValue(),


@@ -517,40 +760,67 @@ public class DbusManagerImpl implements Manager {
 
     @Override
     public List<Identity> getIdentities() {
 
     @Override
     public List<Identity> getIdentities() {

-        throw new UnsupportedOperationException();
+        final var identities = signal.listIdentities();
+        return identities.stream().map(Signal.StructIdentity::getObjectPath).map(this::getIdentity).toList();

     }
 
     @Override
     public List<Identity> getIdentities(final RecipientIdentifier.Single recipient) {
     }
 
     @Override
     public List<Identity> getIdentities(final RecipientIdentifier.Single recipient) {

-        throw new UnsupportedOperationException();
+        final var path = signal.getIdentity(recipient.getIdentifier());
+        return List.of(getIdentity(path));

     }
 
     }
 

-    @Override
-    public boolean trustIdentityVerified(final RecipientIdentifier.Single recipient, final byte[] fingerprint) {
-        throw new UnsupportedOperationException();
+    private Identity getIdentity(final DBusPath identityPath) {
+        final var group = getRemoteObject(identityPath, Signal.Identity.class).GetAll("org.asamk.Signal.Identity");
+        final var aci = (String) group.get("Uuid").getValue();
+        final var number = (String) group.get("Number").getValue();
+        return new Identity(new RecipientAddress(aci, null, number, null),
+                (byte[]) group.get("Fingerprint").getValue(),
+                (String) group.get("SafetyNumber").getValue(),
+                (byte[]) group.get("ScannableSafetyNumber").getValue(),
+                TrustLevel.valueOf((String) group.get("TrustLevel").getValue()),
+                (Long) group.get("AddedDate").getValue());

     }
 
     @Override
     }
 
     @Override

-    public boolean trustIdentityVerifiedSafetyNumber(
-            final RecipientIdentifier.Single recipient, final String safetyNumber
+    public boolean trustIdentityVerified(
+            final RecipientIdentifier.Single recipient, final IdentityVerificationCode verificationCode

     ) {
         throw new UnsupportedOperationException();
     }
 
     @Override
     ) {
         throw new UnsupportedOperationException();
     }
 
     @Override

-    public boolean trustIdentityVerifiedSafetyNumber(
-            final RecipientIdentifier.Single recipient, final byte[] safetyNumber
-    ) {
+    public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {

         throw new UnsupportedOperationException();
     }
 
     @Override
         throw new UnsupportedOperationException();
     }
 
     @Override

-    public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {
-        throw new UnsupportedOperationException();
+    public void addAddressChangedListener(final Runnable listener) {
+    }
+
+    @Override
+    public void addClosedListener(final Runnable listener) {
+        synchronized (closedListeners) {
+            closedListeners.add(listener);
+        }

     }
 
     @Override
     }
 
     @Override

-    public void close() throws IOException {
+    public void close() {
+        synchronized (this) {
+            this.notify();
+        }
+        synchronized (messageHandlers) {
+            if (!messageHandlers.isEmpty()) {
+                uninstallMessageHandlers();
+            }
+            weakHandlers.clear();
+            messageHandlers.clear();
+        }
+        synchronized (closedListeners) {
+            closedListeners.forEach(Runnable::run);
+            closedListeners.clear();
+        }

     }
 
     private SendMessageResults handleMessage(
     }
 
     private SendMessageResults handleMessage(


@@ -564,8 +834,8 @@ public class DbusManagerImpl implements Manager {
                 .filter(r -> r instanceof RecipientIdentifier.Single)
                 .map(RecipientIdentifier.Single.class::cast)
                 .map(RecipientIdentifier.Single::getIdentifier)
                 .filter(r -> r instanceof RecipientIdentifier.Single)
                 .map(RecipientIdentifier.Single.class::cast)
                 .map(RecipientIdentifier.Single::getIdentifier)

-                .collect(Collectors.toList());
-        if (singleRecipients.size() > 0) {
+                .toList();
+        if (!singleRecipients.isEmpty()) {

             timestamp = recipientsHandler.apply(singleRecipients);
         }
 
             timestamp = recipientsHandler.apply(singleRecipients);
         }
 


@@ -576,7 +846,7 @@ public class DbusManagerImpl implements Manager {
                 .filter(r -> r instanceof RecipientIdentifier.Group)
                 .map(RecipientIdentifier.Group.class::cast)
                 .map(RecipientIdentifier.Group::groupId)
                 .filter(r -> r instanceof RecipientIdentifier.Group)
                 .map(RecipientIdentifier.Group.class::cast)
                 .map(RecipientIdentifier.Group::groupId)

-                .collect(Collectors.toList());
+                .toList();

         for (final var groupId : groupRecipients) {
             timestamp = groupHandler.apply(groupId.serialize());
         }
         for (final var groupId : groupRecipients) {
             timestamp = groupHandler.apply(groupId.serialize());
         }


@@ -587,11 +857,276 @@ public class DbusManagerImpl implements Manager {
         return string == null ? "" : string;
     }
 
         return string == null ? "" : string;
     }
 

-    private <T extends DBusInterface> T getRemoteObject(final DBusPath devicePath, final Class<T> type) {
+    private <T extends DBusInterface> T getRemoteObject(final DBusPath path, final Class<T> type) {

         try {
         try {

-            return connection.getRemoteObject(DbusConfig.getBusname(), devicePath.getPath(), type);
+            return connection.getRemoteObject(busname, path.getPath(), type);

         } catch (DBusException e) {
             throw new AssertionError(e);
         }
     }
         } catch (DBusException e) {
             throw new AssertionError(e);
         }
     }

+
+    private void installMessageHandlers() {
+        try {
+            this.dbusMsgHandler = messageReceived -> {
+                final var extras = messageReceived.getExtras();
+                final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(messageReceived.getSender())),
+                        0,
+                        messageReceived.getTimestamp(),
+                        0,
+                        0,
+                        false,
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.of(new MessageEnvelope.Data(messageReceived.getTimestamp(),
+                                messageReceived.getGroupId().length > 0
+                                        ? Optional.of(new MessageEnvelope.Data.GroupContext(GroupId.unknownVersion(
+                                        messageReceived.getGroupId()), false, 0))
+                                        : Optional.empty(),
+                                Optional.empty(),
+                                Optional.empty(),
+                                Optional.of(messageReceived.getMessage()),
+                                0,
+                                false,
+                                false,
+                                false,
+                                false,
+                                false,
+                                Optional.empty(),
+                                Optional.empty(),
+                                Optional.empty(),
+                                getAttachments(extras),
+                                Optional.empty(),
+                                Optional.empty(),
+                                List.of(),
+                                getMentions(extras),
+                                List.of(),
+                                List.of())),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty());
+                notifyMessageHandlers(envelope);
+            };
+            connection.addSigHandler(Signal.MessageReceivedV2.class, signal, this.dbusMsgHandler);
+            this.dbusEditMsgHandler = messageReceived -> {
+                final var extras = messageReceived.getExtras();
+                final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(messageReceived.getSender())),
+                        0,
+                        messageReceived.getTimestamp(),
+                        0,
+                        0,
+                        false,
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.of(new MessageEnvelope.Edit(messageReceived.getTargetSentTimestamp(),
+                                new MessageEnvelope.Data(messageReceived.getTimestamp(),
+                                        messageReceived.getGroupId().length > 0
+                                                ? Optional.of(new MessageEnvelope.Data.GroupContext(GroupId.unknownVersion(
+                                                messageReceived.getGroupId()), false, 0))
+                                                : Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.of(messageReceived.getMessage()),
+                                        0,
+                                        false,
+                                        false,
+                                        false,
+                                        false,
+                                        false,
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        getAttachments(extras),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        List.of(),
+                                        getMentions(extras),
+                                        List.of(),
+                                        List.of()))),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty());
+                notifyMessageHandlers(envelope);
+            };
+            connection.addSigHandler(Signal.EditMessageReceived.class, signal, this.dbusEditMsgHandler);
+
+            this.dbusRcptHandler = receiptReceived -> {
+                final var type = switch (receiptReceived.getReceiptType()) {
+                    case "read" -> MessageEnvelope.Receipt.Type.READ;
+                    case "viewed" -> MessageEnvelope.Receipt.Type.VIEWED;
+                    case "delivery" -> MessageEnvelope.Receipt.Type.DELIVERY;
+                    default -> MessageEnvelope.Receipt.Type.UNKNOWN;
+                };
+                final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(receiptReceived.getSender())),
+                        0,
+                        receiptReceived.getTimestamp(),
+                        0,
+                        0,
+                        false,
+                        Optional.of(new MessageEnvelope.Receipt(receiptReceived.getTimestamp(),
+                                type,
+                                List.of(receiptReceived.getTimestamp()))),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty());
+                notifyMessageHandlers(envelope);
+            };
+            connection.addSigHandler(Signal.ReceiptReceivedV2.class, signal, this.dbusRcptHandler);
+
+            this.dbusSyncHandler = syncReceived -> {
+                final var extras = syncReceived.getExtras();
+                final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(syncReceived.getSource())),
+                        0,
+                        syncReceived.getTimestamp(),
+                        0,
+                        0,
+                        false,
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.empty(),
+                        Optional.of(new MessageEnvelope.Sync(Optional.of(new MessageEnvelope.Sync.Sent(syncReceived.getTimestamp(),
+                                syncReceived.getTimestamp(),
+                                syncReceived.getDestination().isEmpty()
+                                        ? Optional.empty()
+                                        : Optional.of(new RecipientAddress(syncReceived.getDestination())),
+                                Set.of(),
+                                Optional.of(new MessageEnvelope.Data(syncReceived.getTimestamp(),
+                                        syncReceived.getGroupId().length > 0
+                                                ? Optional.of(new MessageEnvelope.Data.GroupContext(GroupId.unknownVersion(
+                                                syncReceived.getGroupId()), false, 0))
+                                                : Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.of(syncReceived.getMessage()),
+                                        0,
+                                        false,
+                                        false,
+                                        false,
+                                        false,
+                                        false,
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        getAttachments(extras),
+                                        Optional.empty(),
+                                        Optional.empty(),
+                                        List.of(),
+                                        getMentions(extras),
+                                        List.of(),
+                                        List.of())),
+                                Optional.empty(),
+                                Optional.empty())),
+                                Optional.empty(),
+                                List.of(),
+                                List.of(),
+                                Optional.empty(),
+                                Optional.empty(),
+                                Optional.empty(),
+                                Optional.empty())),
+                        Optional.empty(),
+                        Optional.empty());
+                notifyMessageHandlers(envelope);
+            };
+            connection.addSigHandler(Signal.SyncMessageReceivedV2.class, signal, this.dbusSyncHandler);
+        } catch (DBusException e) {
+            throw new RuntimeException(e);
+        }
+        signal.subscribeReceive();
+    }
+
+    private void notifyMessageHandlers(final MessageEnvelope envelope) {
+        synchronized (messageHandlers) {
+            Stream.concat(messageHandlers.stream(), weakHandlers.stream())
+                    .forEach(h -> h.handleMessage(envelope, null));
+        }
+    }
+
+    private void uninstallMessageHandlers() {
+        try {
+            signal.unsubscribeReceive();
+            connection.removeSigHandler(Signal.MessageReceivedV2.class, signal, this.dbusMsgHandler);
+            connection.removeSigHandler(Signal.EditMessageReceived.class, signal, this.dbusEditMsgHandler);
+            connection.removeSigHandler(Signal.ReceiptReceivedV2.class, signal, this.dbusRcptHandler);
+            connection.removeSigHandler(Signal.SyncMessageReceivedV2.class, signal, this.dbusSyncHandler);
+        } catch (DBusException e) {
+            throw new RuntimeException(e);
+        }
+    }
+
+    private List<MessageEnvelope.Data.Attachment> getAttachments(final Map<String, Variant<?>> extras) {
+        if (!extras.containsKey("attachments")) {
+            return List.of();
+        }
+
+        final List<DBusMap<String, Variant<?>>> attachments = getValue(extras, "attachments");
+        return attachments.stream().map(a -> {
+            final String file = a.containsKey("file") ? getValue(a, "file") : null;
+            return new MessageEnvelope.Data.Attachment(a.containsKey("remoteId")
+                    ? Optional.of(getValue(a, "remoteId"))
+                    : Optional.empty(),
+                    file != null ? Optional.of(new File(file)) : Optional.empty(),
+                    Optional.empty(),
+                    getValue(a, "contentType"),
+                    Optional.empty(),
+                    Optional.empty(),
+                    Optional.empty(),
+                    Optional.empty(),
+                    Optional.empty(),
+                    Optional.empty(),
+                    Optional.empty(),
+                    getValue(a, "isVoiceNote"),
+                    getValue(a, "isGif"),
+                    getValue(a, "isBorderless"));
+        }).toList();
+    }
+
+    private List<MessageEnvelope.Data.Mention> getMentions(final Map<String, Variant<?>> extras) {
+        if (!extras.containsKey("mentions")) {
+            return List.of();
+        }
+
+        final List<DBusMap<String, Variant<?>>> mentions = getValue(extras, "mentions");
+        return mentions.stream()
+                .map(a -> new MessageEnvelope.Data.Mention(new RecipientAddress(this.<String>getValue(a, "recipient")),
+                        getValue(a, "start"),
+                        getValue(a, "length")))
+                .toList();
+    }
+
+    @Override
+    public InputStream retrieveAttachment(final String id) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public InputStream retrieveContactAvatar(final RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public InputStream retrieveProfileAvatar(final RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public InputStream retrieveGroupAvatar(final GroupId groupId) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @Override
+    public InputStream retrieveSticker(final StickerPackId stickerPackId, final int stickerId) throws IOException {
+        throw new UnsupportedOperationException();
+    }
+
+    @SuppressWarnings("unchecked")
+    private <T> T getValue(
+            final Map<String, Variant<?>> stringVariantMap, final String field
+    ) {
+        return (T) stringVariantMap.get(field).getValue();
+    }

 }
 }