nmode's Git Repositories - signal-cli/blob - src/main/java/org/asamk/signal/dbus/DbusManagerImpl.java

   1 package org.asamk.signal.dbus;
   2
   3 import org.asamk.Signal;
   4 import org.asamk.signal.DbusConfig;
   5 import org.asamk.signal.manager.AttachmentInvalidException;
   6 import org.asamk.signal.manager.Manager;
   7 import org.asamk.signal.manager.NotMasterDeviceException;
   8 import org.asamk.signal.manager.StickerPackInvalidException;
   9 import org.asamk.signal.manager.UntrustedIdentityException;
  10 import org.asamk.signal.manager.api.Device;
  11 import org.asamk.signal.manager.api.Group;
  12 import org.asamk.signal.manager.api.Identity;
  13 import org.asamk.signal.manager.api.Message;
  14 import org.asamk.signal.manager.api.RecipientIdentifier;
  15 import org.asamk.signal.manager.api.SendGroupMessageResults;
  16 import org.asamk.signal.manager.api.SendMessageResults;
  17 import org.asamk.signal.manager.api.TypingAction;
  18 import org.asamk.signal.manager.api.UpdateGroup;
  19 import org.asamk.signal.manager.groups.GroupId;
  20 import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
  21 import org.asamk.signal.manager.groups.GroupNotFoundException;
  22 import org.asamk.signal.manager.groups.GroupPermission;
  23 import org.asamk.signal.manager.groups.GroupSendingNotAllowedException;
  24 import org.asamk.signal.manager.groups.LastGroupAdminException;
  25 import org.asamk.signal.manager.groups.NotAGroupMemberException;
  26 import org.asamk.signal.manager.storage.recipients.Contact;
  27 import org.asamk.signal.manager.storage.recipients.Profile;
  28 import org.asamk.signal.manager.storage.recipients.RecipientAddress;
  29 import org.freedesktop.dbus.DBusPath;
  30 import org.freedesktop.dbus.connections.impl.DBusConnection;
  31 import org.freedesktop.dbus.exceptions.DBusException;
  32 import org.freedesktop.dbus.interfaces.DBusInterface;
  33 import org.whispersystems.libsignal.InvalidKeyException;
  34 import org.whispersystems.libsignal.util.Pair;
  35 import org.whispersystems.libsignal.util.guava.Optional;
  36 import org.whispersystems.signalservice.api.groupsv2.GroupLinkNotActiveException;
  37 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId;
  38 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  39 import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
  40 import org.whispersystems.signalservice.api.util.UuidUtil;
  41 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException;
  42
  43 import java.io.File;
  44 import java.io.IOException;
  45 import java.net.URI;
  46 import java.net.URISyntaxException;
  47 import java.util.ArrayList;
  48 import java.util.HashMap;
  49 import java.util.List;
  50 import java.util.Map;
  51 import java.util.Set;
  52 import java.util.UUID;
  53 import java.util.concurrent.TimeUnit;
  54 import java.util.function.Function;
  55 import java.util.function.Supplier;
  56 import java.util.stream.Collectors;
  57
  58 /**
  59  * This class implements the Manager interface using the DBus Signal interface, where possible.
  60  * It's used for the signal-cli dbus client mode (--dbus, --dbus-system)
  61  */
  62 public class DbusManagerImpl implements Manager {
  63
  64     private final Signal signal;
  65     private final DBusConnection connection;
  66
  67     public DbusManagerImpl(final Signal signal, DBusConnection connection) {
  68         this.signal = signal;
  69         this.connection = connection;
  70     }
  71
  72     @Override
  73     public String getSelfNumber() {
  74         return signal.getSelfNumber();
  75     }
  76
  77     @Override
  78     public void checkAccountState() throws IOException {
  79         throw new UnsupportedOperationException();
  80     }
  81
  82     @Override
  83     public Map<String, Pair<String, UUID>> areUsersRegistered(final Set<String> numbers) throws IOException {
  84         final var numbersList = new ArrayList<>(numbers);
  85         final var registered = signal.isRegistered(numbersList);
  86
  87         final var result = new HashMap<String, Pair<String, UUID>>();
  88         for (var i = 0; i < numbersList.size(); i++) {
  89             result.put(numbersList.get(i),
  90                     new Pair<>(numbersList.get(i), registered.get(i) ? UuidUtil.UNKNOWN_UUID : null));
  91         }
  92         return result;
  93     }
  94
  95     @Override
  96     public void updateAccountAttributes(final String deviceName) throws IOException {
  97         if (deviceName != null) {
  98             final var devicePath = signal.getThisDevice();
  99             getRemoteObject(devicePath, Signal.Device.class).Set("org.asamk.Signal.Device", "Name", deviceName);
 100         }
 101     }
 102
 103     @Override
 104     public void updateConfiguration(
 105             final Boolean readReceipts,
 106             final Boolean unidentifiedDeliveryIndicators,
 107             final Boolean typingIndicators,
 108             final Boolean linkPreviews
 109     ) throws IOException {
 110         throw new UnsupportedOperationException();
 111     }
 112
 113     @Override
 114     public void setProfile(
 115             final String givenName,
 116             final String familyName,
 117             final String about,
 118             final String aboutEmoji,
 119             final Optional<File> avatar
 120     ) throws IOException {
 121         signal.updateProfile(emptyIfNull(givenName),
 122                 emptyIfNull(familyName),
 123                 emptyIfNull(about),
 124                 emptyIfNull(aboutEmoji),
 125                 avatar == null ? "" : avatar.transform(File::getPath).or(""),
 126                 avatar != null && !avatar.isPresent());
 127     }
 128
 129     @Override
 130     public void unregister() throws IOException {
 131         throw new UnsupportedOperationException();
 132     }
 133
 134     @Override
 135     public void deleteAccount() throws IOException {
 136         throw new UnsupportedOperationException();
 137     }
 138
 139     @Override
 140     public void submitRateLimitRecaptchaChallenge(final String challenge, final String captcha) throws IOException {
 141         throw new UnsupportedOperationException();
 142     }
 143
 144     @Override
 145     public List<Device> getLinkedDevices() throws IOException {
 146         final var thisDevice = signal.getThisDevice();
 147         return signal.listDevices().stream().map(d -> {
 148             final var device = getRemoteObject(d.getObjectPath(),
 149                     Signal.Device.class).GetAll("org.asamk.Signal.Device");
 150             return new Device((long) device.get("Id").getValue(),
 151                     (String) device.get("Name").getValue(),
 152                     (long) device.get("Created").getValue(),
 153                     (long) device.get("LastSeen").getValue(),
 154                     thisDevice.equals(d.getObjectPath()));
 155         }).collect(Collectors.toList());
 156     }
 157
 158     @Override
 159     public void removeLinkedDevices(final long deviceId) throws IOException {
 160         final var devicePath = signal.getDevice(deviceId);
 161         getRemoteObject(devicePath, Signal.Device.class).removeDevice();
 162     }
 163
 164     @Override
 165     public void addDeviceLink(final URI linkUri) throws IOException, InvalidKeyException {
 166         signal.addDevice(linkUri.toString());
 167     }
 168
 169     @Override
 170     public void setRegistrationLockPin(final Optional<String> pin) throws IOException, UnauthenticatedResponseException {
 171         if (pin.isPresent()) {
 172             signal.setPin(pin.get());
 173         } else {
 174             signal.removePin();
 175         }
 176     }
 177
 178     @Override
 179     public Profile getRecipientProfile(final RecipientIdentifier.Single recipient) throws UnregisteredUserException {
 180         throw new UnsupportedOperationException();
 181     }
 182
 183     @Override
 184     public List<Group> getGroups() {
 185         final var groups = signal.listGroups();
 186         return groups.stream().map(Signal.StructGroup::getObjectPath).map(this::getGroup).collect(Collectors.toList());
 187     }
 188
 189     @Override
 190     public SendGroupMessageResults quitGroup(
 191             final GroupId groupId, final Set<RecipientIdentifier.Single> groupAdmins
 192     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException {
 193         if (groupAdmins.size() > 0) {
 194             throw new UnsupportedOperationException();
 195         }
 196         final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
 197         group.quitGroup();
 198         return new SendGroupMessageResults(0, List.of());
 199     }
 200
 201     @Override
 202     public void deleteGroup(final GroupId groupId) throws IOException {
 203         throw new UnsupportedOperationException();
 204     }
 205
 206     @Override
 207     public Pair<GroupId, SendGroupMessageResults> createGroup(
 208             final String name, final Set<RecipientIdentifier.Single> members, final File avatarFile
 209     ) throws IOException, AttachmentInvalidException {
 210         final var newGroupId = signal.createGroup(emptyIfNull(name),
 211                 members.stream().map(RecipientIdentifier.Single::getIdentifier).collect(Collectors.toList()),
 212                 avatarFile == null ? "" : avatarFile.getPath());
 213         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
 214     }
 215
 216     @Override
 217     public SendGroupMessageResults updateGroup(
 218             final GroupId groupId, final UpdateGroup updateGroup
 219     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException {
 220         final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
 221         if (updateGroup.getName() != null) {
 222             group.Set("org.asamk.Signal.Group", "Name", updateGroup.getName());
 223         }
 224         if (updateGroup.getDescription() != null) {
 225             group.Set("org.asamk.Signal.Group", "Description", updateGroup.getDescription());
 226         }
 227         if (updateGroup.getAvatarFile() != null) {
 228             group.Set("org.asamk.Signal.Group",
 229                     "Avatar",
 230                     updateGroup.getAvatarFile() == null ? "" : updateGroup.getAvatarFile().getPath());
 231         }
 232         if (updateGroup.getExpirationTimer() != null) {
 233             group.Set("org.asamk.Signal.Group", "MessageExpirationTimer", updateGroup.getExpirationTimer());
 234         }
 235         if (updateGroup.getAddMemberPermission() != null) {
 236             group.Set("org.asamk.Signal.Group", "PermissionAddMember", updateGroup.getAddMemberPermission().name());
 237         }
 238         if (updateGroup.getEditDetailsPermission() != null) {
 239             group.Set("org.asamk.Signal.Group", "PermissionEditDetails", updateGroup.getEditDetailsPermission().name());
 240         }
 241         if (updateGroup.getIsAnnouncementGroup() != null) {
 242             group.Set("org.asamk.Signal.Group",
 243                     "PermissionSendMessage",
 244                     updateGroup.getIsAnnouncementGroup()
 245                             ? GroupPermission.ONLY_ADMINS.name()
 246                             : GroupPermission.EVERY_MEMBER.name());
 247         }
 248         if (updateGroup.getMembers() != null) {
 249             group.addMembers(updateGroup.getMembers()
 250                     .stream()
 251                     .map(RecipientIdentifier.Single::getIdentifier)
 252                     .collect(Collectors.toList()));
 253         }
 254         if (updateGroup.getRemoveMembers() != null) {
 255             group.removeMembers(updateGroup.getRemoveMembers()
 256                     .stream()
 257                     .map(RecipientIdentifier.Single::getIdentifier)
 258                     .collect(Collectors.toList()));
 259         }
 260         if (updateGroup.getAdmins() != null) {
 261             group.addAdmins(updateGroup.getAdmins()
 262                     .stream()
 263                     .map(RecipientIdentifier.Single::getIdentifier)
 264                     .collect(Collectors.toList()));
 265         }
 266         if (updateGroup.getRemoveAdmins() != null) {
 267             group.removeAdmins(updateGroup.getRemoveAdmins()
 268                     .stream()
 269                     .map(RecipientIdentifier.Single::getIdentifier)
 270                     .collect(Collectors.toList()));
 271         }
 272         if (updateGroup.isResetGroupLink()) {
 273             group.resetLink();
 274         }
 275         if (updateGroup.getGroupLinkState() != null) {
 276             switch (updateGroup.getGroupLinkState()) {
 277                 case DISABLED:
 278                     group.disableLink();
 279                     break;
 280                 case ENABLED:
 281                     group.enableLink(false);
 282                     break;
 283                 case ENABLED_WITH_APPROVAL:
 284                     group.enableLink(true);
 285                     break;
 286             }
 287         }
 288         return new SendGroupMessageResults(0, List.of());
 289     }
 290
 291     @Override
 292     public Pair<GroupId, SendGroupMessageResults> joinGroup(final GroupInviteLinkUrl inviteLinkUrl) throws IOException, GroupLinkNotActiveException {
 293         final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
 294         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
 295     }
 296
 297     @Override
 298     public void sendTypingMessage(
 299             final TypingAction action, final Set<RecipientIdentifier> recipients
 300     ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 301         for (final var recipient : recipients) {
 302             if (recipient instanceof RecipientIdentifier.Single) {
 303                 signal.sendTyping(((RecipientIdentifier.Single) recipient).getIdentifier(),
 304                         action == TypingAction.STOP);
 305             } else if (recipient instanceof RecipientIdentifier.Group) {
 306                 throw new UnsupportedOperationException();
 307             }
 308         }
 309     }
 310
 311     @Override
 312     public void sendReadReceipt(
 313             final RecipientIdentifier.Single sender, final List<Long> messageIds
 314     ) throws IOException, UntrustedIdentityException {
 315         signal.sendReadReceipt(sender.getIdentifier(), messageIds);
 316     }
 317
 318     @Override
 319     public void sendViewedReceipt(
 320             final RecipientIdentifier.Single sender, final List<Long> messageIds
 321     ) throws IOException, UntrustedIdentityException {
 322         throw new UnsupportedOperationException();
 323     }
 324
 325     @Override
 326     public SendMessageResults sendMessage(
 327             final Message message, final Set<RecipientIdentifier> recipients
 328     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 329         return handleMessage(recipients,
 330                 numbers -> signal.sendMessage(message.getMessageText(), message.getAttachments(), numbers),
 331                 () -> signal.sendNoteToSelfMessage(message.getMessageText(), message.getAttachments()),
 332                 groupId -> signal.sendGroupMessage(message.getMessageText(), message.getAttachments(), groupId));
 333     }
 334
 335     @Override
 336     public SendMessageResults sendRemoteDeleteMessage(
 337             final long targetSentTimestamp, final Set<RecipientIdentifier> recipients
 338     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 339         return handleMessage(recipients,
 340                 numbers -> signal.sendRemoteDeleteMessage(targetSentTimestamp, numbers),
 341                 () -> signal.sendRemoteDeleteMessage(targetSentTimestamp, signal.getSelfNumber()),
 342                 groupId -> signal.sendGroupRemoteDeleteMessage(targetSentTimestamp, groupId));
 343     }
 344
 345     @Override
 346     public SendMessageResults sendMessageReaction(
 347             final String emoji,
 348             final boolean remove,
 349             final RecipientIdentifier.Single targetAuthor,
 350             final long targetSentTimestamp,
 351             final Set<RecipientIdentifier> recipients
 352     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 353         return handleMessage(recipients,
 354                 numbers -> signal.sendMessageReaction(emoji,
 355                         remove,
 356                         targetAuthor.getIdentifier(),
 357                         targetSentTimestamp,
 358                         numbers),
 359                 () -> signal.sendMessageReaction(emoji,
 360                         remove,
 361                         targetAuthor.getIdentifier(),
 362                         targetSentTimestamp,
 363                         signal.getSelfNumber()),
 364                 groupId -> signal.sendGroupMessageReaction(emoji,
 365                         remove,
 366                         targetAuthor.getIdentifier(),
 367                         targetSentTimestamp,
 368                         groupId));
 369     }
 370
 371     @Override
 372     public SendMessageResults sendEndSessionMessage(final Set<RecipientIdentifier.Single> recipients) throws IOException {
 373         signal.sendEndSessionMessage(recipients.stream()
 374                 .map(RecipientIdentifier.Single::getIdentifier)
 375                 .collect(Collectors.toList()));
 376         return new SendMessageResults(0, Map.of());
 377     }
 378
 379     @Override
 380     public void setContactName(
 381             final RecipientIdentifier.Single recipient, final String name
 382     ) throws NotMasterDeviceException, UnregisteredUserException {
 383         signal.setContactName(recipient.getIdentifier(), name);
 384     }
 385
 386     @Override
 387     public void setContactBlocked(
 388             final RecipientIdentifier.Single recipient, final boolean blocked
 389     ) throws NotMasterDeviceException, IOException {
 390         signal.setContactBlocked(recipient.getIdentifier(), blocked);
 391     }
 392
 393     @Override
 394     public void setGroupBlocked(
 395             final GroupId groupId, final boolean blocked
 396     ) throws GroupNotFoundException, IOException {
 397         setGroupProperty(groupId, "IsBlocked", blocked);
 398     }
 399
 400     private void setGroupProperty(final GroupId groupId, final String propertyName, final boolean blocked) {
 401         final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
 402         group.Set("org.asamk.Signal.Group", propertyName, blocked);
 403     }
 404
 405     @Override
 406     public void setExpirationTimer(
 407             final RecipientIdentifier.Single recipient, final int messageExpirationTimer
 408     ) throws IOException {
 409         signal.setExpirationTimer(recipient.getIdentifier(), messageExpirationTimer);
 410     }
 411
 412     @Override
 413     public URI uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {
 414         try {
 415             return new URI(signal.uploadStickerPack(path.getPath()));
 416         } catch (URISyntaxException e) {
 417             throw new AssertionError(e);
 418         }
 419     }
 420
 421     @Override
 422     public void requestAllSyncData() throws IOException {
 423         signal.sendSyncRequest();
 424     }
 425
 426     @Override
 427     public void receiveMessages(
 428             final long timeout, final TimeUnit unit, final boolean returnOnTimeout, final ReceiveMessageHandler handler
 429     ) throws IOException {
 430         throw new UnsupportedOperationException();
 431     }
 432
 433     @Override
 434     public void setIgnoreAttachments(final boolean ignoreAttachments) {
 435         throw new UnsupportedOperationException();
 436     }
 437
 438     @Override
 439     public boolean hasCaughtUpWithOldMessages() {
 440         throw new UnsupportedOperationException();
 441     }
 442
 443     @Override
 444     public boolean isContactBlocked(final RecipientIdentifier.Single recipient) {
 445         return signal.isContactBlocked(recipient.getIdentifier());
 446     }
 447
 448     @Override
 449     public File getAttachmentFile(final SignalServiceAttachmentRemoteId attachmentId) {
 450         throw new UnsupportedOperationException();
 451     }
 452
 453     @Override
 454     public void sendContacts() throws IOException {
 455         signal.sendContacts();
 456     }
 457
 458     @Override
 459     public List<Pair<RecipientAddress, Contact>> getContacts() {
 460         throw new UnsupportedOperationException();
 461     }
 462
 463     @Override
 464     public String getContactOrProfileName(final RecipientIdentifier.Single recipient) {
 465         return signal.getContactName(recipient.getIdentifier());
 466     }
 467
 468     @Override
 469     public Group getGroup(final GroupId groupId) {
 470         final var groupPath = signal.getGroup(groupId.serialize());
 471         return getGroup(groupPath);
 472     }
 473
 474     @SuppressWarnings("unchecked")
 475     private Group getGroup(final DBusPath groupPath) {
 476         final var group = getRemoteObject(groupPath, Signal.Group.class).GetAll("org.asamk.Signal.Group");
 477         final var id = (byte[]) group.get("Id").getValue();
 478         try {
 479             return new Group(GroupId.unknownVersion(id),
 480                     (String) group.get("Name").getValue(),
 481                     (String) group.get("Description").getValue(),
 482                     GroupInviteLinkUrl.fromUri((String) group.get("GroupInviteLink").getValue()),
 483                     ((List<String>) group.get("Members").getValue()).stream()
 484                             .map(m -> new RecipientAddress(null, m))
 485                             .collect(Collectors.toSet()),
 486                     ((List<String>) group.get("PendingMembers").getValue()).stream()
 487                             .map(m -> new RecipientAddress(null, m))
 488                             .collect(Collectors.toSet()),
 489                     ((List<String>) group.get("RequestingMembers").getValue()).stream()
 490                             .map(m -> new RecipientAddress(null, m))
 491                             .collect(Collectors.toSet()),
 492                     ((List<String>) group.get("Admins").getValue()).stream()
 493                             .map(m -> new RecipientAddress(null, m))
 494                             .collect(Collectors.toSet()),
 495                     (boolean) group.get("IsBlocked").getValue(),
 496                     (int) group.get("MessageExpirationTimer").getValue(),
 497                     GroupPermission.valueOf((String) group.get("PermissionAddMember").getValue()),
 498                     GroupPermission.valueOf((String) group.get("PermissionEditDetails").getValue()),
 499                     GroupPermission.valueOf((String) group.get("PermissionSendMessage").getValue()),
 500                     (boolean) group.get("IsMember").getValue(),
 501                     (boolean) group.get("IsAdmin").getValue());
 502         } catch (GroupInviteLinkUrl.InvalidGroupLinkException | GroupInviteLinkUrl.UnknownGroupLinkVersionException e) {
 503             throw new AssertionError(e);
 504         }
 505     }
 506
 507     @Override
 508     public List<Identity> getIdentities() {
 509         throw new UnsupportedOperationException();
 510     }
 511
 512     @Override
 513     public List<Identity> getIdentities(final RecipientIdentifier.Single recipient) {
 514         throw new UnsupportedOperationException();
 515     }
 516
 517     @Override
 518     public boolean trustIdentityVerified(final RecipientIdentifier.Single recipient, final byte[] fingerprint) {
 519         throw new UnsupportedOperationException();
 520     }
 521
 522     @Override
 523     public boolean trustIdentityVerifiedSafetyNumber(
 524             final RecipientIdentifier.Single recipient, final String safetyNumber
 525     ) {
 526         throw new UnsupportedOperationException();
 527     }
 528
 529     @Override
 530     public boolean trustIdentityVerifiedSafetyNumber(
 531             final RecipientIdentifier.Single recipient, final byte[] safetyNumber
 532     ) {
 533         throw new UnsupportedOperationException();
 534     }
 535
 536     @Override
 537     public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {
 538         throw new UnsupportedOperationException();
 539     }
 540
 541     @Override
 542     public SignalServiceAddress resolveSignalServiceAddress(final SignalServiceAddress address) {
 543         return address;
 544     }
 545
 546     @Override
 547     public void close() throws IOException {
 548     }
 549
 550     private SendMessageResults handleMessage(
 551             Set<RecipientIdentifier> recipients,
 552             Function<List<String>, Long> recipientsHandler,
 553             Supplier<Long> noteToSelfHandler,
 554             Function<byte[], Long> groupHandler
 555     ) {
 556         long timestamp = 0;
 557         final var singleRecipients = recipients.stream()
 558                 .filter(r -> r instanceof RecipientIdentifier.Single)
 559                 .map(RecipientIdentifier.Single.class::cast)
 560                 .map(RecipientIdentifier.Single::getIdentifier)
 561                 .collect(Collectors.toList());
 562         if (singleRecipients.size() > 0) {
 563             timestamp = recipientsHandler.apply(singleRecipients);
 564         }
 565
 566         if (recipients.contains(RecipientIdentifier.NoteToSelf.INSTANCE)) {
 567             timestamp = noteToSelfHandler.get();
 568         }
 569         final var groupRecipients = recipients.stream()
 570                 .filter(r -> r instanceof RecipientIdentifier.Group)
 571                 .map(RecipientIdentifier.Group.class::cast)
 572                 .map(g -> g.groupId)
 573                 .collect(Collectors.toList());
 574         for (final var groupId : groupRecipients) {
 575             timestamp = groupHandler.apply(groupId.serialize());
 576         }
 577         return new SendMessageResults(timestamp, Map.of());
 578     }
 579
 580     private String emptyIfNull(final String string) {
 581         return string == null ? "" : string;
 582     }
 583
 584     private <T extends DBusInterface> T getRemoteObject(final DBusPath devicePath, final Class<T> type) {
 585         try {
 586             return connection.getRemoteObject(DbusConfig.getBusname(), devicePath.getPath(), type);
 587         } catch (DBusException e) {
 588             throw new AssertionError(e);
 589         }
 590     }
 591 }