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.manager.AttachmentInvalidException;
   5 import org.asamk.signal.manager.Manager;
   6 import org.asamk.signal.manager.NotMasterDeviceException;
   7 import org.asamk.signal.manager.StickerPackInvalidException;
   8 import org.asamk.signal.manager.UntrustedIdentityException;
   9 import org.asamk.signal.manager.api.Device;
  10 import org.asamk.signal.manager.api.Group;
  11 import org.asamk.signal.manager.api.Identity;
  12 import org.asamk.signal.manager.api.Message;
  13 import org.asamk.signal.manager.api.RecipientIdentifier;
  14 import org.asamk.signal.manager.api.SendGroupMessageResults;
  15 import org.asamk.signal.manager.api.SendMessageResults;
  16 import org.asamk.signal.manager.api.TypingAction;
  17 import org.asamk.signal.manager.groups.GroupId;
  18 import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
  19 import org.asamk.signal.manager.groups.GroupLinkState;
  20 import org.asamk.signal.manager.groups.GroupNotFoundException;
  21 import org.asamk.signal.manager.groups.GroupPermission;
  22 import org.asamk.signal.manager.groups.GroupSendingNotAllowedException;
  23 import org.asamk.signal.manager.groups.LastGroupAdminException;
  24 import org.asamk.signal.manager.groups.NotAGroupMemberException;
  25 import org.asamk.signal.manager.storage.recipients.Contact;
  26 import org.asamk.signal.manager.storage.recipients.Profile;
  27 import org.asamk.signal.manager.storage.recipients.RecipientAddress;
  28 import org.whispersystems.libsignal.IdentityKey;
  29 import org.whispersystems.libsignal.InvalidKeyException;
  30 import org.whispersystems.libsignal.util.Pair;
  31 import org.whispersystems.libsignal.util.guava.Optional;
  32 import org.whispersystems.signalservice.api.groupsv2.GroupLinkNotActiveException;
  33 import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId;
  34 import org.whispersystems.signalservice.api.push.SignalServiceAddress;
  35 import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
  36 import org.whispersystems.signalservice.api.util.UuidUtil;
  37 import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException;
  38
  39 import java.io.File;
  40 import java.io.IOException;
  41 import java.net.URI;
  42 import java.net.URISyntaxException;
  43 import java.util.ArrayList;
  44 import java.util.HashMap;
  45 import java.util.List;
  46 import java.util.Map;
  47 import java.util.Set;
  48 import java.util.UUID;
  49 import java.util.concurrent.TimeUnit;
  50 import java.util.function.Function;
  51 import java.util.function.Supplier;
  52 import java.util.stream.Collectors;
  53
  54 /**
  55  * This class implements the Manager interface using the DBus Signal interface, where possible.
  56  * It's used for the signal-cli dbus client mode (--dbus, --dbus-system)
  57  */
  58 public class DbusManagerImpl implements Manager {
  59
  60     private final Signal signal;
  61
  62     public DbusManagerImpl(final Signal signal) {
  63         this.signal = signal;
  64     }
  65
  66     @Override
  67     public String getSelfNumber() {
  68         return signal.getSelfNumber();
  69     }
  70
  71     @Override
  72     public void checkAccountState() throws IOException {
  73         throw new UnsupportedOperationException();
  74     }
  75
  76     @Override
  77     public Map<String, Pair<String, UUID>> areUsersRegistered(final Set<String> numbers) throws IOException {
  78         final var numbersList = new ArrayList<>(numbers);
  79         final var registered = signal.isRegistered(numbersList);
  80
  81         final var result = new HashMap<String, Pair<String, UUID>>();
  82         for (var i = 0; i < numbersList.size(); i++) {
  83             result.put(numbersList.get(i),
  84                     new Pair<>(numbersList.get(i), registered.get(i) ? UuidUtil.UNKNOWN_UUID : null));
  85         }
  86         return result;
  87     }
  88
  89     @Override
  90     public void updateAccountAttributes(final String deviceName) throws IOException {
  91         if (deviceName != null) {
  92             signal.updateDeviceName(deviceName);
  93         }
  94     }
  95
  96     @Override
  97     public void updateConfiguration(
  98             final Boolean readReceipts,
  99             final Boolean unidentifiedDeliveryIndicators,
 100             final Boolean typingIndicators,
 101             final Boolean linkPreviews
 102     ) throws IOException {
 103         throw new UnsupportedOperationException();
 104     }
 105
 106     @Override
 107     public void setProfile(
 108             final String givenName,
 109             final String familyName,
 110             final String about,
 111             final String aboutEmoji,
 112             final Optional<File> avatar
 113     ) throws IOException {
 114         signal.updateProfile(emptyIfNull(givenName),
 115                 emptyIfNull(familyName),
 116                 emptyIfNull(about),
 117                 emptyIfNull(aboutEmoji),
 118                 avatar == null ? "" : avatar.transform(File::getPath).or(""),
 119                 avatar != null && !avatar.isPresent());
 120     }
 121
 122     @Override
 123     public void unregister() throws IOException {
 124         throw new UnsupportedOperationException();
 125     }
 126
 127     @Override
 128     public void deleteAccount() throws IOException {
 129         throw new UnsupportedOperationException();
 130     }
 131
 132     @Override
 133     public void submitRateLimitRecaptchaChallenge(final String challenge, final String captcha) throws IOException {
 134         throw new UnsupportedOperationException();
 135     }
 136
 137     @Override
 138     public List<Device> getLinkedDevices() throws IOException {
 139         return signal.listDevices()
 140                 .stream()
 141                 .map(name -> new Device(-1, name, 0, 0, false))
 142                 .collect(Collectors.toList());
 143     }
 144
 145     @Override
 146     public void removeLinkedDevices(final int deviceId) throws IOException {
 147         signal.removeDevice(deviceId);
 148     }
 149
 150     @Override
 151     public void addDeviceLink(final URI linkUri) throws IOException, InvalidKeyException {
 152         signal.addDevice(linkUri.toString());
 153     }
 154
 155     @Override
 156     public void setRegistrationLockPin(final Optional<String> pin) throws IOException, UnauthenticatedResponseException {
 157         if (pin.isPresent()) {
 158             signal.setPin(pin.get());
 159         } else {
 160             signal.removePin();
 161         }
 162     }
 163
 164     @Override
 165     public Profile getRecipientProfile(final RecipientIdentifier.Single recipient) throws UnregisteredUserException {
 166         throw new UnsupportedOperationException();
 167     }
 168
 169     @Override
 170     public List<Group> getGroups() {
 171         final var groupIds = signal.getGroupIds();
 172         return groupIds.stream().map(id -> getGroup(GroupId.unknownVersion(id))).collect(Collectors.toList());
 173     }
 174
 175     @Override
 176     public SendGroupMessageResults quitGroup(
 177             final GroupId groupId, final Set<RecipientIdentifier.Single> groupAdmins
 178     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException {
 179         if (groupAdmins.size() > 0) {
 180             throw new UnsupportedOperationException();
 181         }
 182         signal.quitGroup(groupId.serialize());
 183         return new SendGroupMessageResults(0, List.of());
 184     }
 185
 186     @Override
 187     public void deleteGroup(final GroupId groupId) throws IOException {
 188         throw new UnsupportedOperationException();
 189     }
 190
 191     @Override
 192     public Pair<GroupId, SendGroupMessageResults> createGroup(
 193             final String name, final Set<RecipientIdentifier.Single> members, final File avatarFile
 194     ) throws IOException, AttachmentInvalidException {
 195         final var newGroupId = signal.updateGroup(new byte[0],
 196                 emptyIfNull(name),
 197                 members.stream().map(RecipientIdentifier.Single::getIdentifier).collect(Collectors.toList()),
 198                 avatarFile == null ? "" : avatarFile.getPath());
 199         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
 200     }
 201
 202     @Override
 203     public SendGroupMessageResults updateGroup(
 204             final GroupId groupId,
 205             final String name,
 206             final String description,
 207             final Set<RecipientIdentifier.Single> members,
 208             final Set<RecipientIdentifier.Single> removeMembers,
 209             final Set<RecipientIdentifier.Single> admins,
 210             final Set<RecipientIdentifier.Single> removeAdmins,
 211             final boolean resetGroupLink,
 212             final GroupLinkState groupLinkState,
 213             final GroupPermission addMemberPermission,
 214             final GroupPermission editDetailsPermission,
 215             final File avatarFile,
 216             final Integer expirationTimer,
 217             final Boolean isAnnouncementGroup
 218     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException {
 219         signal.updateGroup(groupId.serialize(),
 220                 emptyIfNull(name),
 221                 members.stream().map(RecipientIdentifier.Single::getIdentifier).collect(Collectors.toList()),
 222                 avatarFile == null ? "" : avatarFile.getPath());
 223         return new SendGroupMessageResults(0, List.of());
 224     }
 225
 226     @Override
 227     public Pair<GroupId, SendGroupMessageResults> joinGroup(final GroupInviteLinkUrl inviteLinkUrl) throws IOException, GroupLinkNotActiveException {
 228         final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
 229         return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
 230     }
 231
 232     @Override
 233     public void sendTypingMessage(
 234             final TypingAction action, final Set<RecipientIdentifier> recipients
 235     ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 236         for (final var recipient : recipients) {
 237             if (recipient instanceof RecipientIdentifier.Single) {
 238                 signal.sendTyping(((RecipientIdentifier.Single) recipient).getIdentifier(),
 239                         action == TypingAction.STOP);
 240             } else if (recipient instanceof RecipientIdentifier.Group) {
 241                 throw new UnsupportedOperationException();
 242             }
 243         }
 244     }
 245
 246     @Override
 247     public void sendReadReceipt(
 248             final RecipientIdentifier.Single sender, final List<Long> messageIds
 249     ) throws IOException, UntrustedIdentityException {
 250         signal.sendReadReceipt(sender.getIdentifier(), messageIds);
 251     }
 252
 253     @Override
 254     public void sendViewedReceipt(
 255             final RecipientIdentifier.Single sender, final List<Long> messageIds
 256     ) throws IOException, UntrustedIdentityException {
 257         throw new UnsupportedOperationException();
 258     }
 259
 260     @Override
 261     public SendMessageResults sendMessage(
 262             final Message message, final Set<RecipientIdentifier> recipients
 263     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 264         return handleMessage(recipients,
 265                 numbers -> signal.sendMessage(message.getMessageText(), message.getAttachments(), numbers),
 266                 () -> signal.sendNoteToSelfMessage(message.getMessageText(), message.getAttachments()),
 267                 groupId -> signal.sendGroupMessage(message.getMessageText(), message.getAttachments(), groupId));
 268     }
 269
 270     @Override
 271     public SendMessageResults sendRemoteDeleteMessage(
 272             final long targetSentTimestamp, final Set<RecipientIdentifier> recipients
 273     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 274         return handleMessage(recipients,
 275                 numbers -> signal.sendRemoteDeleteMessage(targetSentTimestamp, numbers),
 276                 () -> signal.sendRemoteDeleteMessage(targetSentTimestamp, signal.getSelfNumber()),
 277                 groupId -> signal.sendGroupRemoteDeleteMessage(targetSentTimestamp, groupId));
 278     }
 279
 280     @Override
 281     public SendMessageResults sendMessageReaction(
 282             final String emoji,
 283             final boolean remove,
 284             final RecipientIdentifier.Single targetAuthor,
 285             final long targetSentTimestamp,
 286             final Set<RecipientIdentifier> recipients
 287     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 288         return handleMessage(recipients,
 289                 numbers -> signal.sendMessageReaction(emoji,
 290                         remove,
 291                         targetAuthor.getIdentifier(),
 292                         targetSentTimestamp,
 293                         numbers),
 294                 () -> signal.sendMessageReaction(emoji,
 295                         remove,
 296                         targetAuthor.getIdentifier(),
 297                         targetSentTimestamp,
 298                         signal.getSelfNumber()),
 299                 groupId -> signal.sendGroupMessageReaction(emoji,
 300                         remove,
 301                         targetAuthor.getIdentifier(),
 302                         targetSentTimestamp,
 303                         groupId));
 304     }
 305
 306     @Override
 307     public SendMessageResults sendEndSessionMessage(final Set<RecipientIdentifier.Single> recipients) throws IOException {
 308         signal.sendEndSessionMessage(recipients.stream()
 309                 .map(RecipientIdentifier.Single::getIdentifier)
 310                 .collect(Collectors.toList()));
 311         return new SendMessageResults(0, Map.of());
 312     }
 313
 314     @Override
 315     public void setContactName(
 316             final RecipientIdentifier.Single recipient, final String name
 317     ) throws NotMasterDeviceException, UnregisteredUserException {
 318         signal.setContactName(recipient.getIdentifier(), name);
 319     }
 320
 321     @Override
 322     public void setContactBlocked(
 323             final RecipientIdentifier.Single recipient, final boolean blocked
 324     ) throws NotMasterDeviceException, IOException {
 325         signal.setContactBlocked(recipient.getIdentifier(), blocked);
 326     }
 327
 328     @Override
 329     public void setGroupBlocked(
 330             final GroupId groupId, final boolean blocked
 331     ) throws GroupNotFoundException, IOException {
 332         signal.setGroupBlocked(groupId.serialize(), blocked);
 333     }
 334
 335     @Override
 336     public void setExpirationTimer(
 337             final RecipientIdentifier.Single recipient, final int messageExpirationTimer
 338     ) throws IOException {
 339         signal.setExpirationTimer(recipient.getIdentifier(), messageExpirationTimer);
 340     }
 341
 342     @Override
 343     public URI uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {
 344         try {
 345             return new URI(signal.uploadStickerPack(path.getPath()));
 346         } catch (URISyntaxException e) {
 347             throw new AssertionError(e);
 348         }
 349     }
 350
 351     @Override
 352     public void requestAllSyncData() throws IOException {
 353         signal.sendSyncRequest();
 354     }
 355
 356     @Override
 357     public void receiveMessages(
 358             final long timeout,
 359             final TimeUnit unit,
 360             final boolean returnOnTimeout,
 361             final boolean ignoreAttachments,
 362             final ReceiveMessageHandler handler
 363     ) throws IOException {
 364         throw new UnsupportedOperationException();
 365     }
 366
 367     @Override
 368     public boolean hasCaughtUpWithOldMessages() {
 369         throw new UnsupportedOperationException();
 370     }
 371
 372     @Override
 373     public boolean isContactBlocked(final RecipientIdentifier.Single recipient) {
 374         return signal.isContactBlocked(recipient.getIdentifier());
 375     }
 376
 377     @Override
 378     public File getAttachmentFile(final SignalServiceAttachmentRemoteId attachmentId) {
 379         throw new UnsupportedOperationException();
 380     }
 381
 382     @Override
 383     public void sendContacts() throws IOException {
 384         signal.sendContacts();
 385     }
 386
 387     @Override
 388     public List<Pair<RecipientAddress, Contact>> getContacts() {
 389         throw new UnsupportedOperationException();
 390     }
 391
 392     @Override
 393     public String getContactOrProfileName(final RecipientIdentifier.Single recipient) {
 394         return signal.getContactName(recipient.getIdentifier());
 395     }
 396
 397     @Override
 398     public Group getGroup(final GroupId groupId) {
 399         final var id = groupId.serialize();
 400         return new Group(groupId,
 401                 signal.getGroupName(id),
 402                 null,
 403                 null,
 404                 signal.getGroupMembers(id).stream().map(m -> new RecipientAddress(null, m)).collect(Collectors.toSet()),
 405                 Set.of(),
 406                 Set.of(),
 407                 Set.of(),
 408                 signal.isGroupBlocked(id),
 409                 0,
 410                 false,
 411                 signal.isMember(id));
 412     }
 413
 414     @Override
 415     public List<Identity> getIdentities() {
 416         throw new UnsupportedOperationException();
 417     }
 418
 419     @Override
 420     public List<Identity> getIdentities(final RecipientIdentifier.Single recipient) {
 421         throw new UnsupportedOperationException();
 422     }
 423
 424     @Override
 425     public boolean trustIdentityVerified(final RecipientIdentifier.Single recipient, final byte[] fingerprint) {
 426         throw new UnsupportedOperationException();
 427     }
 428
 429     @Override
 430     public boolean trustIdentityVerifiedSafetyNumber(
 431             final RecipientIdentifier.Single recipient, final String safetyNumber
 432     ) {
 433         throw new UnsupportedOperationException();
 434     }
 435
 436     @Override
 437     public boolean trustIdentityVerifiedSafetyNumber(
 438             final RecipientIdentifier.Single recipient, final byte[] safetyNumber
 439     ) {
 440         throw new UnsupportedOperationException();
 441     }
 442
 443     @Override
 444     public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {
 445         throw new UnsupportedOperationException();
 446     }
 447
 448     @Override
 449     public String computeSafetyNumber(
 450             final SignalServiceAddress theirAddress, final IdentityKey theirIdentityKey
 451     ) {
 452         throw new UnsupportedOperationException();
 453     }
 454
 455     @Override
 456     public SignalServiceAddress resolveSignalServiceAddress(final SignalServiceAddress address) {
 457         return address;
 458     }
 459
 460     @Override
 461     public void close() throws IOException {
 462     }
 463
 464     private SendMessageResults handleMessage(
 465             Set<RecipientIdentifier> recipients,
 466             Function<List<String>, Long> recipientsHandler,
 467             Supplier<Long> noteToSelfHandler,
 468             Function<byte[], Long> groupHandler
 469     ) {
 470         long timestamp = 0;
 471         final var singleRecipients = recipients.stream()
 472                 .filter(r -> r instanceof RecipientIdentifier.Single)
 473                 .map(RecipientIdentifier.Single.class::cast)
 474                 .map(RecipientIdentifier.Single::getIdentifier)
 475                 .collect(Collectors.toList());
 476         if (singleRecipients.size() > 0) {
 477             timestamp = recipientsHandler.apply(singleRecipients);
 478         }
 479
 480         if (recipients.contains(RecipientIdentifier.NoteToSelf.INSTANCE)) {
 481             timestamp = noteToSelfHandler.get();
 482         }
 483         final var groupRecipients = recipients.stream()
 484                 .filter(r -> r instanceof RecipientIdentifier.Group)
 485                 .map(RecipientIdentifier.Group.class::cast)
 486                 .map(g -> g.groupId)
 487                 .collect(Collectors.toList());
 488         for (final var groupId : groupRecipients) {
 489             timestamp = groupHandler.apply(groupId.serialize());
 490         }
 491         return new SendMessageResults(timestamp, Map.of());
 492     }
 493
 494     private String emptyIfNull(final String string) {
 495         return string == null ? "" : string;
 496     }
 497 }