nmode's Git Repositories - signal-cli/blob - lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java

   1 /*
   2   Copyright (C) 2015-2021 AsamK and contributors
   3
   4   This program is free software: you can redistribute it and/or modify
   5   it under the terms of the GNU General Public License as published by
   6   the Free Software Foundation, either version 3 of the License, or
   7   (at your option) any later version.
   8
   9   This program is distributed in the hope that it will be useful,
  10   but WITHOUT ANY WARRANTY; without even the implied warranty of
  11   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  12   GNU General Public License for more details.
  13
  14   You should have received a copy of the GNU General Public License
  15   along with this program.  If not, see <http://www.gnu.org/licenses/>.
  16  */
  17 package org.asamk.signal.manager;
  18
  19 import org.asamk.signal.manager.api.Configuration;
  20 import org.asamk.signal.manager.api.Device;
  21 import org.asamk.signal.manager.api.Group;
  22 import org.asamk.signal.manager.api.Identity;
  23 import org.asamk.signal.manager.api.InactiveGroupLinkException;
  24 import org.asamk.signal.manager.api.InvalidDeviceLinkException;
  25 import org.asamk.signal.manager.api.Message;
  26 import org.asamk.signal.manager.api.Pair;
  27 import org.asamk.signal.manager.api.RecipientIdentifier;
  28 import org.asamk.signal.manager.api.SendGroupMessageResults;
  29 import org.asamk.signal.manager.api.SendMessageResult;
  30 import org.asamk.signal.manager.api.SendMessageResults;
  31 import org.asamk.signal.manager.api.TypingAction;
  32 import org.asamk.signal.manager.api.UnregisteredRecipientException;
  33 import org.asamk.signal.manager.api.UpdateGroup;
  34 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
  35 import org.asamk.signal.manager.groups.GroupId;
  36 import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
  37 import org.asamk.signal.manager.groups.GroupNotFoundException;
  38 import org.asamk.signal.manager.groups.GroupSendingNotAllowedException;
  39 import org.asamk.signal.manager.groups.LastGroupAdminException;
  40 import org.asamk.signal.manager.groups.NotAGroupMemberException;
  41 import org.asamk.signal.manager.helper.Context;
  42 import org.asamk.signal.manager.storage.SignalAccount;
  43 import org.asamk.signal.manager.storage.groups.GroupInfo;
  44 import org.asamk.signal.manager.storage.identities.IdentityInfo;
  45 import org.asamk.signal.manager.storage.recipients.Contact;
  46 import org.asamk.signal.manager.storage.recipients.Profile;
  47 import org.asamk.signal.manager.storage.recipients.RecipientAddress;
  48 import org.asamk.signal.manager.storage.recipients.RecipientId;
  49 import org.asamk.signal.manager.storage.stickers.Sticker;
  50 import org.asamk.signal.manager.storage.stickers.StickerPackId;
  51 import org.asamk.signal.manager.util.KeyUtils;
  52 import org.asamk.signal.manager.util.StickerUtils;
  53 import org.slf4j.Logger;
  54 import org.slf4j.LoggerFactory;
  55 import org.whispersystems.libsignal.util.guava.Optional;
  56 import org.whispersystems.signalservice.api.SignalSessionLock;
  57 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
  58 import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
  59 import org.whispersystems.signalservice.api.messages.SignalServiceTypingMessage;
  60 import org.whispersystems.signalservice.api.util.DeviceNameUtil;
  61 import org.whispersystems.signalservice.api.util.InvalidNumberException;
  62 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
  63 import org.whispersystems.signalservice.internal.util.DynamicCredentialsProvider;
  64 import org.whispersystems.signalservice.internal.util.Hex;
  65 import org.whispersystems.signalservice.internal.util.Util;
  66
  67 import java.io.File;
  68 import java.io.IOException;
  69 import java.net.URI;
  70 import java.net.URISyntaxException;
  71 import java.net.URLEncoder;
  72 import java.nio.charset.StandardCharsets;
  73 import java.time.Duration;
  74 import java.util.ArrayList;
  75 import java.util.HashMap;
  76 import java.util.HashSet;
  77 import java.util.List;
  78 import java.util.Map;
  79 import java.util.Set;
  80 import java.util.UUID;
  81 import java.util.concurrent.ExecutorService;
  82 import java.util.concurrent.Executors;
  83 import java.util.concurrent.locks.ReentrantLock;
  84 import java.util.function.Function;
  85 import java.util.stream.Collectors;
  86 import java.util.stream.Stream;
  87
  88 public class ManagerImpl implements Manager {
  89
  90     private final static Logger logger = LoggerFactory.getLogger(ManagerImpl.class);
  91
  92     private SignalAccount account;
  93     private final SignalDependencies dependencies;
  94     private final Context context;
  95
  96     private final ExecutorService executor = Executors.newCachedThreadPool();
  97
  98     private Thread receiveThread;
  99     private boolean isReceivingSynchronous;
 100     private final Set<ReceiveMessageHandler> weakHandlers = new HashSet<>();
 101     private final Set<ReceiveMessageHandler> messageHandlers = new HashSet<>();
 102     private final List<Runnable> closedListeners = new ArrayList<>();
 103
 104     ManagerImpl(
 105             SignalAccount account,
 106             PathConfig pathConfig,
 107             ServiceEnvironmentConfig serviceEnvironmentConfig,
 108             String userAgent
 109     ) {
 110         this.account = account;
 111
 112         final var credentialsProvider = new DynamicCredentialsProvider(account.getAci(),
 113                 account.getAccount(),
 114                 account.getPassword(),
 115                 account.getDeviceId());
 116         final var sessionLock = new SignalSessionLock() {
 117             private final ReentrantLock LEGACY_LOCK = new ReentrantLock();
 118
 119             @Override
 120             public Lock acquire() {
 121                 LEGACY_LOCK.lock();
 122                 return LEGACY_LOCK::unlock;
 123             }
 124         };
 125         this.dependencies = new SignalDependencies(serviceEnvironmentConfig,
 126                 userAgent,
 127                 credentialsProvider,
 128                 account.getSignalProtocolStore(),
 129                 executor,
 130                 sessionLock);
 131         final var avatarStore = new AvatarStore(pathConfig.avatarsPath());
 132         final var attachmentStore = new AttachmentStore(pathConfig.attachmentsPath());
 133         final var stickerPackStore = new StickerPackStore(pathConfig.stickerPacksPath());
 134
 135         this.context = new Context(account, dependencies, avatarStore, attachmentStore, stickerPackStore);
 136         this.context.getAccountHelper().setUnregisteredListener(this::close);
 137         this.context.getReceiveHelper().setAuthenticationFailureListener(this::close);
 138         this.context.getReceiveHelper().setCaughtUpWithOldMessagesListener(() -> {
 139             synchronized (this) {
 140                 this.notifyAll();
 141             }
 142         });
 143     }
 144
 145     @Override
 146     public String getSelfNumber() {
 147         return account.getAccount();
 148     }
 149
 150     @Override
 151     public void checkAccountState() throws IOException {
 152         context.getAccountHelper().checkAccountState();
 153     }
 154
 155     @Override
 156     public Map<String, Pair<String, UUID>> areUsersRegistered(Set<String> numbers) throws IOException {
 157         final var canonicalizedNumbers = numbers.stream().collect(Collectors.toMap(n -> n, n -> {
 158             try {
 159                 final var canonicalizedNumber = PhoneNumberFormatter.formatNumber(n, account.getAccount());
 160                 if (!canonicalizedNumber.equals(n)) {
 161                     logger.debug("Normalized number {} to {}.", n, canonicalizedNumber);
 162                 }
 163                 return canonicalizedNumber;
 164             } catch (InvalidNumberException e) {
 165                 return "";
 166             }
 167         }));
 168
 169         // Note "registeredUsers" has no optionals. It only gives us info on users who are registered
 170         final var canonicalizedNumbersSet = canonicalizedNumbers.values()
 171                 .stream()
 172                 .filter(s -> !s.isEmpty())
 173                 .collect(Collectors.toSet());
 174         final var registeredUsers = context.getRecipientHelper().getRegisteredUsers(canonicalizedNumbersSet);
 175
 176         return numbers.stream().collect(Collectors.toMap(n -> n, n -> {
 177             final var number = canonicalizedNumbers.get(n);
 178             final var aci = registeredUsers.get(number);
 179             return new Pair<>(number.isEmpty() ? null : number, aci == null ? null : aci.uuid());
 180         }));
 181     }
 182
 183     @Override
 184     public void updateAccountAttributes(String deviceName) throws IOException {
 185         if (deviceName != null) {
 186             context.getAccountHelper().setDeviceName(deviceName);
 187         }
 188         context.getAccountHelper().updateAccountAttributes();
 189     }
 190
 191     @Override
 192     public Configuration getConfiguration() {
 193         final var configurationStore = account.getConfigurationStore();
 194         return Configuration.from(configurationStore);
 195     }
 196
 197     @Override
 198     public void updateConfiguration(
 199             Configuration configuration
 200     ) throws NotMasterDeviceException {
 201         if (!account.isMasterDevice()) {
 202             throw new NotMasterDeviceException();
 203         }
 204
 205         final var configurationStore = account.getConfigurationStore();
 206         if (configuration.readReceipts().isPresent()) {
 207             configurationStore.setReadReceipts(configuration.readReceipts().get());
 208         }
 209         if (configuration.unidentifiedDeliveryIndicators().isPresent()) {
 210             configurationStore.setUnidentifiedDeliveryIndicators(configuration.unidentifiedDeliveryIndicators().get());
 211         }
 212         if (configuration.typingIndicators().isPresent()) {
 213             configurationStore.setTypingIndicators(configuration.typingIndicators().get());
 214         }
 215         if (configuration.linkPreviews().isPresent()) {
 216             configurationStore.setLinkPreviews(configuration.linkPreviews().get());
 217         }
 218         context.getSyncHelper().sendConfigurationMessage();
 219     }
 220
 221     @Override
 222     public void setProfile(
 223             String givenName, final String familyName, String about, String aboutEmoji, java.util.Optional<File> avatar
 224     ) throws IOException {
 225         context.getProfileHelper()
 226                 .setProfile(givenName,
 227                         familyName,
 228                         about,
 229                         aboutEmoji,
 230                         avatar == null ? null : Optional.fromNullable(avatar.orElse(null)));
 231         context.getSyncHelper().sendSyncFetchProfileMessage();
 232     }
 233
 234     @Override
 235     public void unregister() throws IOException {
 236         context.getAccountHelper().unregister();
 237     }
 238
 239     @Override
 240     public void deleteAccount() throws IOException {
 241         context.getAccountHelper().deleteAccount();
 242     }
 243
 244     @Override
 245     public void submitRateLimitRecaptchaChallenge(String challenge, String captcha) throws IOException {
 246         captcha = captcha == null ? null : captcha.replace("signalcaptcha://", "");
 247
 248         dependencies.getAccountManager().submitRateLimitRecaptchaChallenge(challenge, captcha);
 249     }
 250
 251     @Override
 252     public List<Device> getLinkedDevices() throws IOException {
 253         var devices = dependencies.getAccountManager().getDevices();
 254         account.setMultiDevice(devices.size() > 1);
 255         var identityKey = account.getIdentityKeyPair().getPrivateKey();
 256         return devices.stream().map(d -> {
 257             String deviceName = d.getName();
 258             if (deviceName != null) {
 259                 try {
 260                     deviceName = DeviceNameUtil.decryptDeviceName(deviceName, identityKey);
 261                 } catch (IOException e) {
 262                     logger.debug("Failed to decrypt device name, maybe plain text?", e);
 263                 }
 264             }
 265             return new Device(d.getId(),
 266                     deviceName,
 267                     d.getCreated(),
 268                     d.getLastSeen(),
 269                     d.getId() == account.getDeviceId());
 270         }).toList();
 271     }
 272
 273     @Override
 274     public void removeLinkedDevices(long deviceId) throws IOException {
 275         context.getAccountHelper().removeLinkedDevices(deviceId);
 276     }
 277
 278     @Override
 279     public void addDeviceLink(URI linkUri) throws IOException, InvalidDeviceLinkException {
 280         var deviceLinkInfo = DeviceLinkInfo.parseDeviceLinkUri(linkUri);
 281         context.getAccountHelper().addDevice(deviceLinkInfo);
 282     }
 283
 284     @Override
 285     public void setRegistrationLockPin(java.util.Optional<String> pin) throws IOException, NotMasterDeviceException {
 286         if (!account.isMasterDevice()) {
 287             throw new NotMasterDeviceException();
 288         }
 289         if (pin.isPresent()) {
 290             context.getAccountHelper().setRegistrationPin(pin.get());
 291         } else {
 292             context.getAccountHelper().removeRegistrationPin();
 293         }
 294     }
 295
 296     void refreshPreKeys() throws IOException {
 297         context.getPreKeyHelper().refreshPreKeys();
 298     }
 299
 300     @Override
 301     public Profile getRecipientProfile(RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
 302         return context.getProfileHelper().getRecipientProfile(context.getRecipientHelper().resolveRecipient(recipient));
 303     }
 304
 305     @Override
 306     public List<Group> getGroups() {
 307         return account.getGroupStore().getGroups().stream().map(this::toGroup).toList();
 308     }
 309
 310     private Group toGroup(final GroupInfo groupInfo) {
 311         if (groupInfo == null) {
 312             return null;
 313         }
 314
 315         return Group.from(groupInfo,
 316                 account.getRecipientStore()::resolveRecipientAddress,
 317                 account.getSelfRecipientId());
 318     }
 319
 320     @Override
 321     public SendGroupMessageResults quitGroup(
 322             GroupId groupId, Set<RecipientIdentifier.Single> groupAdmins
 323     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException, UnregisteredRecipientException {
 324         final var newAdmins = context.getRecipientHelper().resolveRecipients(groupAdmins);
 325         return context.getGroupHelper().quitGroup(groupId, newAdmins);
 326     }
 327
 328     @Override
 329     public void deleteGroup(GroupId groupId) throws IOException {
 330         context.getGroupHelper().deleteGroup(groupId);
 331     }
 332
 333     @Override
 334     public Pair<GroupId, SendGroupMessageResults> createGroup(
 335             String name, Set<RecipientIdentifier.Single> members, File avatarFile
 336     ) throws IOException, AttachmentInvalidException, UnregisteredRecipientException {
 337         return context.getGroupHelper()
 338                 .createGroup(name,
 339                         members == null ? null : context.getRecipientHelper().resolveRecipients(members),
 340                         avatarFile);
 341     }
 342
 343     @Override
 344     public SendGroupMessageResults updateGroup(
 345             final GroupId groupId, final UpdateGroup updateGroup
 346     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException, UnregisteredRecipientException {
 347         return context.getGroupHelper()
 348                 .updateGroup(groupId,
 349                         updateGroup.getName(),
 350                         updateGroup.getDescription(),
 351                         updateGroup.getMembers() == null
 352                                 ? null
 353                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getMembers()),
 354                         updateGroup.getRemoveMembers() == null
 355                                 ? null
 356                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveMembers()),
 357                         updateGroup.getAdmins() == null
 358                                 ? null
 359                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getAdmins()),
 360                         updateGroup.getRemoveAdmins() == null
 361                                 ? null
 362                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveAdmins()),
 363                         updateGroup.isResetGroupLink(),
 364                         updateGroup.getGroupLinkState(),
 365                         updateGroup.getAddMemberPermission(),
 366                         updateGroup.getEditDetailsPermission(),
 367                         updateGroup.getAvatarFile(),
 368                         updateGroup.getExpirationTimer(),
 369                         updateGroup.getIsAnnouncementGroup());
 370     }
 371
 372     @Override
 373     public Pair<GroupId, SendGroupMessageResults> joinGroup(
 374             GroupInviteLinkUrl inviteLinkUrl
 375     ) throws IOException, InactiveGroupLinkException {
 376         return context.getGroupHelper().joinGroup(inviteLinkUrl);
 377     }
 378
 379     private SendMessageResults sendMessage(
 380             SignalServiceDataMessage.Builder messageBuilder, Set<RecipientIdentifier> recipients
 381     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 382         var results = new HashMap<RecipientIdentifier, List<SendMessageResult>>();
 383         long timestamp = System.currentTimeMillis();
 384         messageBuilder.withTimestamp(timestamp);
 385         for (final var recipient : recipients) {
 386             if (recipient instanceof RecipientIdentifier.Single single) {
 387                 try {
 388                     final var recipientId = context.getRecipientHelper().resolveRecipient(single);
 389                     final var result = context.getSendHelper().sendMessage(messageBuilder, recipientId);
 390                     results.put(recipient, List.of(toSendMessageResult(result)));
 391                 } catch (UnregisteredRecipientException e) {
 392                     results.put(recipient,
 393                             List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress())));
 394                 }
 395             } else if (recipient instanceof RecipientIdentifier.NoteToSelf) {
 396                 final var result = context.getSendHelper().sendSelfMessage(messageBuilder);
 397                 results.put(recipient, List.of(toSendMessageResult(result)));
 398             } else if (recipient instanceof RecipientIdentifier.Group group) {
 399                 final var result = context.getSendHelper().sendAsGroupMessage(messageBuilder, group.groupId());
 400                 results.put(recipient, result.stream().map(this::toSendMessageResult).toList());
 401             }
 402         }
 403         return new SendMessageResults(timestamp, results);
 404     }
 405
 406     private SendMessageResult toSendMessageResult(final org.whispersystems.signalservice.api.messages.SendMessageResult result) {
 407         return SendMessageResult.from(result,
 408                 account.getRecipientStore(),
 409                 account.getRecipientStore()::resolveRecipientAddress);
 410     }
 411
 412     private SendMessageResults sendTypingMessage(
 413             SignalServiceTypingMessage.Action action, Set<RecipientIdentifier> recipients
 414     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 415         var results = new HashMap<RecipientIdentifier, List<SendMessageResult>>();
 416         final var timestamp = System.currentTimeMillis();
 417         for (var recipient : recipients) {
 418             if (recipient instanceof RecipientIdentifier.Single single) {
 419                 final var message = new SignalServiceTypingMessage(action, timestamp, Optional.absent());
 420                 try {
 421                     final var recipientId = context.getRecipientHelper().resolveRecipient(single);
 422                     final var result = context.getSendHelper().sendTypingMessage(message, recipientId);
 423                     results.put(recipient, List.of(toSendMessageResult(result)));
 424                 } catch (UnregisteredRecipientException e) {
 425                     results.put(recipient,
 426                             List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress())));
 427                 }
 428             } else if (recipient instanceof RecipientIdentifier.Group) {
 429                 final var groupId = ((RecipientIdentifier.Group) recipient).groupId();
 430                 final var message = new SignalServiceTypingMessage(action, timestamp, Optional.of(groupId.serialize()));
 431                 final var result = context.getSendHelper().sendGroupTypingMessage(message, groupId);
 432                 results.put(recipient, result.stream().map(this::toSendMessageResult).toList());
 433             }
 434         }
 435         return new SendMessageResults(timestamp, results);
 436     }
 437
 438     @Override
 439     public SendMessageResults sendTypingMessage(
 440             TypingAction action, Set<RecipientIdentifier> recipients
 441     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 442         return sendTypingMessage(action.toSignalService(), recipients);
 443     }
 444
 445     @Override
 446     public SendMessageResults sendReadReceipt(
 447             RecipientIdentifier.Single sender, List<Long> messageIds
 448     ) throws IOException {
 449         final var timestamp = System.currentTimeMillis();
 450         var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.READ,
 451                 messageIds,
 452                 timestamp);
 453
 454         return sendReceiptMessage(sender, timestamp, receiptMessage);
 455     }
 456
 457     @Override
 458     public SendMessageResults sendViewedReceipt(
 459             RecipientIdentifier.Single sender, List<Long> messageIds
 460     ) throws IOException {
 461         final var timestamp = System.currentTimeMillis();
 462         var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.VIEWED,
 463                 messageIds,
 464                 timestamp);
 465
 466         return sendReceiptMessage(sender, timestamp, receiptMessage);
 467     }
 468
 469     private SendMessageResults sendReceiptMessage(
 470             final RecipientIdentifier.Single sender,
 471             final long timestamp,
 472             final SignalServiceReceiptMessage receiptMessage
 473     ) throws IOException {
 474         try {
 475             final var result = context.getSendHelper()
 476                     .sendReceiptMessage(receiptMessage, context.getRecipientHelper().resolveRecipient(sender));
 477             return new SendMessageResults(timestamp, Map.of(sender, List.of(toSendMessageResult(result))));
 478         } catch (UnregisteredRecipientException e) {
 479             return new SendMessageResults(timestamp,
 480                     Map.of(sender, List.of(SendMessageResult.unregisteredFailure(sender.toPartialRecipientAddress()))));
 481         }
 482     }
 483
 484     @Override
 485     public SendMessageResults sendMessage(
 486             Message message, Set<RecipientIdentifier> recipients
 487     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException {
 488         final var messageBuilder = SignalServiceDataMessage.newBuilder();
 489         applyMessage(messageBuilder, message);
 490         return sendMessage(messageBuilder, recipients);
 491     }
 492
 493     private void applyMessage(
 494             final SignalServiceDataMessage.Builder messageBuilder, final Message message
 495     ) throws AttachmentInvalidException, IOException, UnregisteredRecipientException {
 496         messageBuilder.withBody(message.messageText());
 497         final var attachments = message.attachments();
 498         if (attachments != null) {
 499             messageBuilder.withAttachments(context.getAttachmentHelper().uploadAttachments(attachments));
 500         }
 501         if (message.mentions().size() > 0) {
 502             messageBuilder.withMentions(resolveMentions(message.mentions()));
 503         }
 504         if (message.quote().isPresent()) {
 505             final var quote = message.quote().get();
 506             messageBuilder.withQuote(new SignalServiceDataMessage.Quote(quote.timestamp(),
 507                     context.getRecipientHelper()
 508                             .resolveSignalServiceAddress(context.getRecipientHelper().resolveRecipient(quote.author())),
 509                     quote.message(),
 510                     List.of(),
 511                     resolveMentions(quote.mentions())));
 512         }
 513     }
 514
 515     private ArrayList<SignalServiceDataMessage.Mention> resolveMentions(final List<Message.Mention> mentionList) throws IOException, UnregisteredRecipientException {
 516         final var mentions = new ArrayList<SignalServiceDataMessage.Mention>();
 517         for (final var m : mentionList) {
 518             final var recipientId = context.getRecipientHelper().resolveRecipient(m.recipient());
 519             mentions.add(new SignalServiceDataMessage.Mention(context.getRecipientHelper()
 520                     .resolveSignalServiceAddress(recipientId)
 521                     .getAci(), m.start(), m.length()));
 522         }
 523         return mentions;
 524     }
 525
 526     @Override
 527     public SendMessageResults sendRemoteDeleteMessage(
 528             long targetSentTimestamp, Set<RecipientIdentifier> recipients
 529     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 530         var delete = new SignalServiceDataMessage.RemoteDelete(targetSentTimestamp);
 531         final var messageBuilder = SignalServiceDataMessage.newBuilder().withRemoteDelete(delete);
 532         return sendMessage(messageBuilder, recipients);
 533     }
 534
 535     @Override
 536     public SendMessageResults sendMessageReaction(
 537             String emoji,
 538             boolean remove,
 539             RecipientIdentifier.Single targetAuthor,
 540             long targetSentTimestamp,
 541             Set<RecipientIdentifier> recipients
 542     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException {
 543         var targetAuthorRecipientId = context.getRecipientHelper().resolveRecipient(targetAuthor);
 544         var reaction = new SignalServiceDataMessage.Reaction(emoji,
 545                 remove,
 546                 context.getRecipientHelper().resolveSignalServiceAddress(targetAuthorRecipientId),
 547                 targetSentTimestamp);
 548         final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
 549         return sendMessage(messageBuilder, recipients);
 550     }
 551
 552     @Override
 553     public SendMessageResults sendEndSessionMessage(Set<RecipientIdentifier.Single> recipients) throws IOException {
 554         var messageBuilder = SignalServiceDataMessage.newBuilder().asEndSessionMessage();
 555
 556         try {
 557             return sendMessage(messageBuilder,
 558                     recipients.stream().map(RecipientIdentifier.class::cast).collect(Collectors.toSet()));
 559         } catch (GroupNotFoundException | NotAGroupMemberException | GroupSendingNotAllowedException e) {
 560             throw new AssertionError(e);
 561         } finally {
 562             for (var recipient : recipients) {
 563                 final RecipientId recipientId;
 564                 try {
 565                     recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 566                 } catch (UnregisteredRecipientException e) {
 567                     continue;
 568                 }
 569                 account.getSessionStore().deleteAllSessions(recipientId);
 570             }
 571         }
 572     }
 573
 574     @Override
 575     public void deleteRecipient(final RecipientIdentifier.Single recipient) {
 576         account.removeRecipient(account.getRecipientStore().resolveRecipient(recipient.toPartialRecipientAddress()));
 577     }
 578
 579     @Override
 580     public void deleteContact(final RecipientIdentifier.Single recipient) {
 581         account.getContactStore()
 582                 .deleteContact(account.getRecipientStore().resolveRecipient(recipient.toPartialRecipientAddress()));
 583     }
 584
 585     @Override
 586     public void setContactName(
 587             RecipientIdentifier.Single recipient, String name
 588     ) throws NotMasterDeviceException, IOException, UnregisteredRecipientException {
 589         if (!account.isMasterDevice()) {
 590             throw new NotMasterDeviceException();
 591         }
 592         context.getContactHelper().setContactName(context.getRecipientHelper().resolveRecipient(recipient), name);
 593     }
 594
 595     @Override
 596     public void setContactBlocked(
 597             RecipientIdentifier.Single recipient, boolean blocked
 598     ) throws NotMasterDeviceException, IOException, UnregisteredRecipientException {
 599         if (!account.isMasterDevice()) {
 600             throw new NotMasterDeviceException();
 601         }
 602         context.getContactHelper().setContactBlocked(context.getRecipientHelper().resolveRecipient(recipient), blocked);
 603         // TODO cycle our profile key, if we're not together in a group with recipient
 604         context.getSyncHelper().sendBlockedList();
 605     }
 606
 607     @Override
 608     public void setGroupBlocked(
 609             final GroupId groupId, final boolean blocked
 610     ) throws GroupNotFoundException, NotMasterDeviceException {
 611         if (!account.isMasterDevice()) {
 612             throw new NotMasterDeviceException();
 613         }
 614         context.getGroupHelper().setGroupBlocked(groupId, blocked);
 615         // TODO cycle our profile key
 616         context.getSyncHelper().sendBlockedList();
 617     }
 618
 619     @Override
 620     public void setExpirationTimer(
 621             RecipientIdentifier.Single recipient, int messageExpirationTimer
 622     ) throws IOException, UnregisteredRecipientException {
 623         var recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 624         context.getContactHelper().setExpirationTimer(recipientId, messageExpirationTimer);
 625         final var messageBuilder = SignalServiceDataMessage.newBuilder().asExpirationUpdate();
 626         try {
 627             sendMessage(messageBuilder, Set.of(recipient));
 628         } catch (NotAGroupMemberException | GroupNotFoundException | GroupSendingNotAllowedException e) {
 629             throw new AssertionError(e);
 630         }
 631     }
 632
 633     @Override
 634     public URI uploadStickerPack(File path) throws IOException, StickerPackInvalidException {
 635         var manifest = StickerUtils.getSignalServiceStickerManifestUpload(path);
 636
 637         var messageSender = dependencies.getMessageSender();
 638
 639         var packKey = KeyUtils.createStickerUploadKey();
 640         var packIdString = messageSender.uploadStickerManifest(manifest, packKey);
 641         var packId = StickerPackId.deserialize(Hex.fromStringCondensed(packIdString));
 642
 643         var sticker = new Sticker(packId, packKey);
 644         account.getStickerStore().updateSticker(sticker);
 645
 646         try {
 647             return new URI("https",
 648                     "signal.art",
 649                     "/addstickers/",
 650                     "pack_id="
 651                             + URLEncoder.encode(Hex.toStringCondensed(packId.serialize()), StandardCharsets.UTF_8)
 652                             + "&pack_key="
 653                             + URLEncoder.encode(Hex.toStringCondensed(packKey), StandardCharsets.UTF_8));
 654         } catch (URISyntaxException e) {
 655             throw new AssertionError(e);
 656         }
 657     }
 658
 659     @Override
 660     public void requestAllSyncData() throws IOException {
 661         context.getSyncHelper().requestAllSyncData();
 662         retrieveRemoteStorage();
 663     }
 664
 665     void retrieveRemoteStorage() throws IOException {
 666         if (account.getStorageKey() != null) {
 667             context.getStorageHelper().readDataFromStorage();
 668         }
 669     }
 670
 671     @Override
 672     public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
 673         if (isReceivingSynchronous) {
 674             throw new IllegalStateException("Already receiving message synchronously.");
 675         }
 676         synchronized (messageHandlers) {
 677             if (isWeakListener) {
 678                 weakHandlers.add(handler);
 679             } else {
 680                 messageHandlers.add(handler);
 681                 startReceiveThreadIfRequired();
 682             }
 683         }
 684     }
 685
 686     private void startReceiveThreadIfRequired() {
 687         if (receiveThread != null) {
 688             return;
 689         }
 690         receiveThread = new Thread(() -> {
 691             logger.debug("Starting receiving messages");
 692             while (!Thread.interrupted()) {
 693                 try {
 694                     context.getReceiveHelper().receiveMessages(Duration.ofMinutes(1), false, (envelope, e) -> {
 695                         synchronized (messageHandlers) {
 696                             Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> {
 697                                 try {
 698                                     h.handleMessage(envelope, e);
 699                                 } catch (Exception ex) {
 700                                     logger.warn("Message handler failed, ignoring", ex);
 701                                 }
 702                             });
 703                         }
 704                     });
 705                     break;
 706                 } catch (IOException e) {
 707                     logger.warn("Receiving messages failed, retrying", e);
 708                 }
 709             }
 710             logger.debug("Finished receiving messages");
 711             synchronized (messageHandlers) {
 712                 receiveThread = null;
 713
 714                 // Check if in the meantime another handler has been registered
 715                 if (!messageHandlers.isEmpty()) {
 716                     logger.debug("Another handler has been registered, starting receive thread again");
 717                     startReceiveThreadIfRequired();
 718                 }
 719             }
 720         });
 721
 722         receiveThread.start();
 723     }
 724
 725     @Override
 726     public void removeReceiveHandler(final ReceiveMessageHandler handler) {
 727         final Thread thread;
 728         synchronized (messageHandlers) {
 729             weakHandlers.remove(handler);
 730             messageHandlers.remove(handler);
 731             if (!messageHandlers.isEmpty() || receiveThread == null || isReceivingSynchronous) {
 732                 return;
 733             }
 734             thread = receiveThread;
 735             receiveThread = null;
 736         }
 737
 738         stopReceiveThread(thread);
 739     }
 740
 741     private void stopReceiveThread(final Thread thread) {
 742         thread.interrupt();
 743         try {
 744             thread.join();
 745         } catch (InterruptedException ignored) {
 746         }
 747     }
 748
 749     @Override
 750     public boolean isReceiving() {
 751         if (isReceivingSynchronous) {
 752             return true;
 753         }
 754         synchronized (messageHandlers) {
 755             return messageHandlers.size() > 0;
 756         }
 757     }
 758
 759     @Override
 760     public void receiveMessages(Duration timeout, ReceiveMessageHandler handler) throws IOException {
 761         receiveMessages(timeout, true, handler);
 762     }
 763
 764     @Override
 765     public void receiveMessages(ReceiveMessageHandler handler) throws IOException {
 766         receiveMessages(Duration.ofMinutes(1), false, handler);
 767     }
 768
 769     private void receiveMessages(
 770             Duration timeout, boolean returnOnTimeout, ReceiveMessageHandler handler
 771     ) throws IOException {
 772         if (isReceiving()) {
 773             throw new IllegalStateException("Already receiving message.");
 774         }
 775         isReceivingSynchronous = true;
 776         receiveThread = Thread.currentThread();
 777         try {
 778             context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, handler);
 779         } finally {
 780             receiveThread = null;
 781             isReceivingSynchronous = false;
 782         }
 783     }
 784
 785     @Override
 786     public void setIgnoreAttachments(final boolean ignoreAttachments) {
 787         context.getReceiveHelper().setIgnoreAttachments(ignoreAttachments);
 788     }
 789
 790     @Override
 791     public boolean hasCaughtUpWithOldMessages() {
 792         return context.getReceiveHelper().hasCaughtUpWithOldMessages();
 793     }
 794
 795     @Override
 796     public boolean isContactBlocked(final RecipientIdentifier.Single recipient) {
 797         final RecipientId recipientId;
 798         try {
 799             recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 800         } catch (IOException | UnregisteredRecipientException e) {
 801             return false;
 802         }
 803         return context.getContactHelper().isContactBlocked(recipientId);
 804     }
 805
 806     @Override
 807     public void sendContacts() throws IOException {
 808         context.getSyncHelper().sendContacts();
 809     }
 810
 811     @Override
 812     public List<Pair<RecipientAddress, Contact>> getContacts() {
 813         return account.getContactStore()
 814                 .getContacts()
 815                 .stream()
 816                 .map(p -> new Pair<>(account.getRecipientStore().resolveRecipientAddress(p.first()), p.second()))
 817                 .toList();
 818     }
 819
 820     @Override
 821     public String getContactOrProfileName(RecipientIdentifier.Single recipient) {
 822         final RecipientId recipientId;
 823         try {
 824             recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 825         } catch (IOException | UnregisteredRecipientException e) {
 826             return null;
 827         }
 828
 829         final var contact = account.getContactStore().getContact(recipientId);
 830         if (contact != null && !Util.isEmpty(contact.getName())) {
 831             return contact.getName();
 832         }
 833
 834         final var profile = context.getProfileHelper().getRecipientProfile(recipientId);
 835         if (profile != null) {
 836             return profile.getDisplayName();
 837         }
 838
 839         return null;
 840     }
 841
 842     @Override
 843     public Group getGroup(GroupId groupId) {
 844         return toGroup(context.getGroupHelper().getGroup(groupId));
 845     }
 846
 847     @Override
 848     public List<Identity> getIdentities() {
 849         return account.getIdentityKeyStore().getIdentities().stream().map(this::toIdentity).toList();
 850     }
 851
 852     private Identity toIdentity(final IdentityInfo identityInfo) {
 853         if (identityInfo == null) {
 854             return null;
 855         }
 856
 857         final var address = account.getRecipientStore().resolveRecipientAddress(identityInfo.getRecipientId());
 858         final var scannableFingerprint = context.getIdentityHelper()
 859                 .computeSafetyNumberForScanning(identityInfo.getRecipientId(), identityInfo.getIdentityKey());
 860         return new Identity(address,
 861                 identityInfo.getIdentityKey(),
 862                 context.getIdentityHelper()
 863                         .computeSafetyNumber(identityInfo.getRecipientId(), identityInfo.getIdentityKey()),
 864                 scannableFingerprint == null ? null : scannableFingerprint.getSerialized(),
 865                 identityInfo.getTrustLevel(),
 866                 identityInfo.getDateAdded());
 867     }
 868
 869     @Override
 870     public List<Identity> getIdentities(RecipientIdentifier.Single recipient) {
 871         IdentityInfo identity;
 872         try {
 873             identity = account.getIdentityKeyStore()
 874                     .getIdentity(context.getRecipientHelper().resolveRecipient(recipient));
 875         } catch (IOException | UnregisteredRecipientException e) {
 876             identity = null;
 877         }
 878         return identity == null ? List.of() : List.of(toIdentity(identity));
 879     }
 880
 881     @Override
 882     public boolean trustIdentityVerified(
 883             RecipientIdentifier.Single recipient, byte[] fingerprint
 884     ) throws UnregisteredRecipientException {
 885         return trustIdentity(recipient, r -> context.getIdentityHelper().trustIdentityVerified(r, fingerprint));
 886     }
 887
 888     @Override
 889     public boolean trustIdentityVerifiedSafetyNumber(
 890             RecipientIdentifier.Single recipient, String safetyNumber
 891     ) throws UnregisteredRecipientException {
 892         return trustIdentity(recipient,
 893                 r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber));
 894     }
 895
 896     @Override
 897     public boolean trustIdentityVerifiedSafetyNumber(
 898             RecipientIdentifier.Single recipient, byte[] safetyNumber
 899     ) throws UnregisteredRecipientException {
 900         return trustIdentity(recipient,
 901                 r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber));
 902     }
 903
 904     @Override
 905     public boolean trustIdentityAllKeys(RecipientIdentifier.Single recipient) throws UnregisteredRecipientException {
 906         return trustIdentity(recipient, r -> context.getIdentityHelper().trustIdentityAllKeys(r));
 907     }
 908
 909     private boolean trustIdentity(
 910             RecipientIdentifier.Single recipient, Function<RecipientId, Boolean> trustMethod
 911     ) throws UnregisteredRecipientException {
 912         RecipientId recipientId;
 913         try {
 914             recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 915         } catch (IOException e) {
 916             return false;
 917         }
 918         final var updated = trustMethod.apply(recipientId);
 919         if (updated && this.isReceiving()) {
 920             context.getReceiveHelper().setNeedsToRetryFailedMessages(true);
 921         }
 922         return updated;
 923     }
 924
 925     @Override
 926     public void addClosedListener(final Runnable listener) {
 927         synchronized (closedListeners) {
 928             closedListeners.add(listener);
 929         }
 930     }
 931
 932     @Override
 933     public void close() {
 934         Thread thread;
 935         synchronized (messageHandlers) {
 936             weakHandlers.clear();
 937             messageHandlers.clear();
 938             thread = receiveThread;
 939             receiveThread = null;
 940         }
 941         if (thread != null) {
 942             stopReceiveThread(thread);
 943         }
 944         executor.shutdown();
 945
 946         dependencies.getSignalWebSocket().disconnect();
 947
 948         synchronized (closedListeners) {
 949             closedListeners.forEach(Runnable::run);
 950             closedListeners.clear();
 951         }
 952
 953         if (account != null) {
 954             account.close();
 955         }
 956         account = null;
 957     }
 958 }