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

   1 /*
   2   Copyright (C) 2015-2022 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.internal;
  18
  19 import org.asamk.signal.manager.Manager;
  20 import org.asamk.signal.manager.api.AlreadyReceivingException;
  21 import org.asamk.signal.manager.api.AttachmentInvalidException;
  22 import org.asamk.signal.manager.api.Configuration;
  23 import org.asamk.signal.manager.api.Device;
  24 import org.asamk.signal.manager.api.DeviceLinkUrl;
  25 import org.asamk.signal.manager.api.Group;
  26 import org.asamk.signal.manager.api.GroupId;
  27 import org.asamk.signal.manager.api.GroupInviteLinkUrl;
  28 import org.asamk.signal.manager.api.GroupNotFoundException;
  29 import org.asamk.signal.manager.api.GroupSendingNotAllowedException;
  30 import org.asamk.signal.manager.api.Identity;
  31 import org.asamk.signal.manager.api.IdentityVerificationCode;
  32 import org.asamk.signal.manager.api.InactiveGroupLinkException;
  33 import org.asamk.signal.manager.api.InvalidDeviceLinkException;
  34 import org.asamk.signal.manager.api.InvalidStickerException;
  35 import org.asamk.signal.manager.api.InvalidUsernameException;
  36 import org.asamk.signal.manager.api.LastGroupAdminException;
  37 import org.asamk.signal.manager.api.Message;
  38 import org.asamk.signal.manager.api.MessageEnvelope;
  39 import org.asamk.signal.manager.api.NotAGroupMemberException;
  40 import org.asamk.signal.manager.api.NotPrimaryDeviceException;
  41 import org.asamk.signal.manager.api.Pair;
  42 import org.asamk.signal.manager.api.PendingAdminApprovalException;
  43 import org.asamk.signal.manager.api.Profile;
  44 import org.asamk.signal.manager.api.ReceiveConfig;
  45 import org.asamk.signal.manager.api.Recipient;
  46 import org.asamk.signal.manager.api.RecipientIdentifier;
  47 import org.asamk.signal.manager.api.SendGroupMessageResults;
  48 import org.asamk.signal.manager.api.SendMessageResult;
  49 import org.asamk.signal.manager.api.SendMessageResults;
  50 import org.asamk.signal.manager.api.StickerPackId;
  51 import org.asamk.signal.manager.api.StickerPackInvalidException;
  52 import org.asamk.signal.manager.api.StickerPackUrl;
  53 import org.asamk.signal.manager.api.TextStyle;
  54 import org.asamk.signal.manager.api.TypingAction;
  55 import org.asamk.signal.manager.api.UnregisteredRecipientException;
  56 import org.asamk.signal.manager.api.UpdateGroup;
  57 import org.asamk.signal.manager.api.UpdateProfile;
  58 import org.asamk.signal.manager.api.UserStatus;
  59 import org.asamk.signal.manager.config.ServiceEnvironmentConfig;
  60 import org.asamk.signal.manager.helper.AccountFileUpdater;
  61 import org.asamk.signal.manager.helper.Context;
  62 import org.asamk.signal.manager.storage.AttachmentStore;
  63 import org.asamk.signal.manager.storage.AvatarStore;
  64 import org.asamk.signal.manager.storage.SignalAccount;
  65 import org.asamk.signal.manager.storage.groups.GroupInfo;
  66 import org.asamk.signal.manager.storage.identities.IdentityInfo;
  67 import org.asamk.signal.manager.storage.recipients.RecipientId;
  68 import org.asamk.signal.manager.storage.stickerPacks.JsonStickerPack;
  69 import org.asamk.signal.manager.storage.stickerPacks.StickerPackStore;
  70 import org.asamk.signal.manager.storage.stickers.StickerPack;
  71 import org.asamk.signal.manager.util.AttachmentUtils;
  72 import org.asamk.signal.manager.util.KeyUtils;
  73 import org.asamk.signal.manager.util.MimeUtils;
  74 import org.asamk.signal.manager.util.StickerUtils;
  75 import org.signal.libsignal.usernames.BaseUsernameException;
  76 import org.slf4j.Logger;
  77 import org.slf4j.LoggerFactory;
  78 import org.whispersystems.signalservice.api.SignalSessionLock;
  79 import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
  80 import org.whispersystems.signalservice.api.messages.SignalServicePreview;
  81 import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
  82 import org.whispersystems.signalservice.api.messages.SignalServiceTypingMessage;
  83 import org.whispersystems.signalservice.api.push.ACI;
  84 import org.whispersystems.signalservice.api.push.ServiceId;
  85 import org.whispersystems.signalservice.api.util.DeviceNameUtil;
  86 import org.whispersystems.signalservice.api.util.InvalidNumberException;
  87 import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
  88 import org.whispersystems.signalservice.api.util.StreamDetails;
  89 import org.whispersystems.signalservice.internal.util.Hex;
  90 import org.whispersystems.signalservice.internal.util.Util;
  91
  92 import java.io.ByteArrayInputStream;
  93 import java.io.File;
  94 import java.io.IOException;
  95 import java.io.InputStream;
  96 import java.nio.charset.StandardCharsets;
  97 import java.time.Duration;
  98 import java.util.ArrayList;
  99 import java.util.Collection;
 100 import java.util.HashMap;
 101 import java.util.HashSet;
 102 import java.util.List;
 103 import java.util.Map;
 104 import java.util.Objects;
 105 import java.util.Optional;
 106 import java.util.Set;
 107 import java.util.concurrent.ExecutorService;
 108 import java.util.concurrent.Executors;
 109 import java.util.concurrent.atomic.AtomicInteger;
 110 import java.util.concurrent.locks.ReentrantLock;
 111 import java.util.function.Function;
 112 import java.util.stream.Collectors;
 113 import java.util.stream.Stream;
 114
 115 import io.reactivex.rxjava3.disposables.CompositeDisposable;
 116
 117 public class ManagerImpl implements Manager {
 118
 119     private final static Logger logger = LoggerFactory.getLogger(ManagerImpl.class);
 120
 121     private SignalAccount account;
 122     private final SignalDependencies dependencies;
 123     private final Context context;
 124
 125     private final ExecutorService executor = Executors.newCachedThreadPool();
 126
 127     private Thread receiveThread;
 128     private boolean isReceivingSynchronous;
 129     private final Set<ReceiveMessageHandler> weakHandlers = new HashSet<>();
 130     private final Set<ReceiveMessageHandler> messageHandlers = new HashSet<>();
 131     private final List<Runnable> closedListeners = new ArrayList<>();
 132     private final List<Runnable> addressChangedListeners = new ArrayList<>();
 133     private final CompositeDisposable disposable = new CompositeDisposable();
 134
 135     public ManagerImpl(
 136             SignalAccount account,
 137             PathConfig pathConfig,
 138             AccountFileUpdater accountFileUpdater,
 139             ServiceEnvironmentConfig serviceEnvironmentConfig,
 140             String userAgent
 141     ) {
 142         this.account = account;
 143
 144         final var sessionLock = new SignalSessionLock() {
 145             private final ReentrantLock LEGACY_LOCK = new ReentrantLock();
 146
 147             @Override
 148             public Lock acquire() {
 149                 LEGACY_LOCK.lock();
 150                 return LEGACY_LOCK::unlock;
 151             }
 152         };
 153         this.dependencies = new SignalDependencies(serviceEnvironmentConfig,
 154                 userAgent,
 155                 account.getCredentialsProvider(),
 156                 account.getSignalServiceDataStore(),
 157                 executor,
 158                 sessionLock);
 159         final var avatarStore = new AvatarStore(pathConfig.avatarsPath());
 160         final var attachmentStore = new AttachmentStore(pathConfig.attachmentsPath());
 161         final var stickerPackStore = new StickerPackStore(pathConfig.stickerPacksPath());
 162
 163         this.context = new Context(account, new AccountFileUpdater() {
 164             @Override
 165             public void updateAccountIdentifiers(final String number, final ACI aci) {
 166                 accountFileUpdater.updateAccountIdentifiers(number, aci);
 167                 synchronized (addressChangedListeners) {
 168                     addressChangedListeners.forEach(Runnable::run);
 169                 }
 170             }
 171
 172             @Override
 173             public void removeAccount() {
 174                 accountFileUpdater.removeAccount();
 175             }
 176         }, dependencies, avatarStore, attachmentStore, stickerPackStore);
 177         this.context.getAccountHelper().setUnregisteredListener(this::close);
 178         this.context.getReceiveHelper().setAuthenticationFailureListener(this::close);
 179         this.context.getReceiveHelper().setCaughtUpWithOldMessagesListener(() -> {
 180             synchronized (this) {
 181                 this.notifyAll();
 182             }
 183         });
 184         disposable.add(account.getIdentityKeyStore().getIdentityChanges().subscribe(serviceId -> {
 185             logger.trace("Archiving old sessions for {}", serviceId);
 186             account.getAciSessionStore().archiveSessions(serviceId);
 187             account.getPniSessionStore().archiveSessions(serviceId);
 188             account.getSenderKeyStore().deleteSharedWith(serviceId);
 189             final var recipientId = account.getRecipientResolver().resolveRecipient(serviceId);
 190             final var profile = account.getProfileStore().getProfile(recipientId);
 191             if (profile != null) {
 192                 account.getProfileStore()
 193                         .storeProfile(recipientId,
 194                                 Profile.newBuilder(profile)
 195                                         .withUnidentifiedAccessMode(Profile.UnidentifiedAccessMode.UNKNOWN)
 196                                         .withLastUpdateTimestamp(0)
 197                                         .build());
 198             }
 199         }));
 200     }
 201
 202     @Override
 203     public String getSelfNumber() {
 204         return account.getNumber();
 205     }
 206
 207     public void checkAccountState() throws IOException {
 208         context.getAccountHelper().checkAccountState();
 209     }
 210
 211     @Override
 212     public Map<String, UserStatus> getUserStatus(Set<String> numbers) throws IOException {
 213         final var canonicalizedNumbers = numbers.stream().collect(Collectors.toMap(n -> n, n -> {
 214             try {
 215                 final var canonicalizedNumber = PhoneNumberFormatter.formatNumber(n, account.getNumber());
 216                 if (!canonicalizedNumber.equals(n)) {
 217                     logger.debug("Normalized number {} to {}.", n, canonicalizedNumber);
 218                 }
 219                 return canonicalizedNumber;
 220             } catch (InvalidNumberException e) {
 221                 return "";
 222             }
 223         }));
 224
 225         // Note "registeredUsers" has no optionals. It only gives us info on users who are registered
 226         final var canonicalizedNumbersSet = canonicalizedNumbers.values()
 227                 .stream()
 228                 .filter(s -> !s.isEmpty())
 229                 .collect(Collectors.toSet());
 230         final var registeredUsers = context.getRecipientHelper().getRegisteredUsers(canonicalizedNumbersSet);
 231
 232         return numbers.stream().collect(Collectors.toMap(n -> n, n -> {
 233             final var number = canonicalizedNumbers.get(n);
 234             final var user = registeredUsers.get(number);
 235             final var serviceId = user == null ? null : user.getServiceId();
 236             final var profile = serviceId == null
 237                     ? null
 238                     : context.getProfileHelper()
 239                             .getRecipientProfile(account.getRecipientResolver().resolveRecipient(serviceId));
 240             return new UserStatus(number.isEmpty() ? null : number,
 241                     serviceId == null ? null : serviceId.uuid(),
 242                     profile != null
 243                             && profile.getUnidentifiedAccessMode() == Profile.UnidentifiedAccessMode.UNRESTRICTED);
 244         }));
 245     }
 246
 247     @Override
 248     public void updateAccountAttributes(String deviceName) throws IOException {
 249         if (deviceName != null) {
 250             context.getAccountHelper().setDeviceName(deviceName);
 251         }
 252         context.getAccountHelper().updateAccountAttributes();
 253         context.getAccountHelper().checkWhoAmiI();
 254     }
 255
 256     @Override
 257     public Configuration getConfiguration() {
 258         final var configurationStore = account.getConfigurationStore();
 259         return Configuration.from(configurationStore);
 260     }
 261
 262     @Override
 263     public void updateConfiguration(
 264             Configuration configuration
 265     ) throws NotPrimaryDeviceException {
 266         if (!account.isPrimaryDevice()) {
 267             throw new NotPrimaryDeviceException();
 268         }
 269
 270         final var configurationStore = account.getConfigurationStore();
 271         if (configuration.readReceipts().isPresent()) {
 272             configurationStore.setReadReceipts(configuration.readReceipts().get());
 273         }
 274         if (configuration.unidentifiedDeliveryIndicators().isPresent()) {
 275             configurationStore.setUnidentifiedDeliveryIndicators(configuration.unidentifiedDeliveryIndicators().get());
 276         }
 277         if (configuration.typingIndicators().isPresent()) {
 278             configurationStore.setTypingIndicators(configuration.typingIndicators().get());
 279         }
 280         if (configuration.linkPreviews().isPresent()) {
 281             configurationStore.setLinkPreviews(configuration.linkPreviews().get());
 282         }
 283         context.getSyncHelper().sendConfigurationMessage();
 284     }
 285
 286     @Override
 287     public void updateProfile(UpdateProfile updateProfile) throws IOException {
 288         context.getProfileHelper()
 289                 .setProfile(updateProfile.getGivenName(),
 290                         updateProfile.getFamilyName(),
 291                         updateProfile.getAbout(),
 292                         updateProfile.getAboutEmoji(),
 293                         updateProfile.isDeleteAvatar()
 294                                 ? Optional.empty()
 295                                 : updateProfile.getAvatar() == null ? null : Optional.of(updateProfile.getAvatar()),
 296                         updateProfile.getMobileCoinAddress());
 297         context.getSyncHelper().sendSyncFetchProfileMessage();
 298     }
 299
 300     void refreshCurrentUsername() throws IOException, BaseUsernameException {
 301         context.getAccountHelper().refreshCurrentUsername();
 302     }
 303
 304     @Override
 305     public String setUsername(final String username) throws IOException, InvalidUsernameException {
 306         try {
 307             return context.getAccountHelper().reserveUsername(username);
 308         } catch (BaseUsernameException e) {
 309             throw new InvalidUsernameException(e.getMessage() + " (" + e.getClass().getSimpleName() + ")", e);
 310         }
 311     }
 312
 313     @Override
 314     public void deleteUsername() throws IOException {
 315         context.getAccountHelper().deleteUsername();
 316     }
 317
 318     @Override
 319     public void unregister() throws IOException {
 320         context.getAccountHelper().unregister();
 321     }
 322
 323     @Override
 324     public void deleteAccount() throws IOException {
 325         context.getAccountHelper().deleteAccount();
 326     }
 327
 328     @Override
 329     public void submitRateLimitRecaptchaChallenge(String challenge, String captcha) throws IOException {
 330         captcha = captcha == null ? null : captcha.replace("signalcaptcha://", "");
 331
 332         dependencies.getAccountManager().submitRateLimitRecaptchaChallenge(challenge, captcha);
 333     }
 334
 335     @Override
 336     public List<Device> getLinkedDevices() throws IOException {
 337         var devices = dependencies.getAccountManager().getDevices();
 338         account.setMultiDevice(devices.size() > 1);
 339         var identityKey = account.getAciIdentityKeyPair().getPrivateKey();
 340         return devices.stream().map(d -> {
 341             String deviceName = d.getName();
 342             if (deviceName != null) {
 343                 try {
 344                     deviceName = DeviceNameUtil.decryptDeviceName(deviceName, identityKey);
 345                 } catch (IOException e) {
 346                     logger.debug("Failed to decrypt device name, maybe plain text?", e);
 347                 }
 348             }
 349             return new Device(d.getId(),
 350                     deviceName,
 351                     d.getCreated(),
 352                     d.getLastSeen(),
 353                     d.getId() == account.getDeviceId());
 354         }).toList();
 355     }
 356
 357     @Override
 358     public void removeLinkedDevices(int deviceId) throws IOException {
 359         context.getAccountHelper().removeLinkedDevices(deviceId);
 360     }
 361
 362     @Override
 363     public void addDeviceLink(DeviceLinkUrl linkUrl) throws IOException, InvalidDeviceLinkException {
 364         context.getAccountHelper().addDevice(linkUrl);
 365     }
 366
 367     @Override
 368     public void setRegistrationLockPin(Optional<String> pin) throws IOException, NotPrimaryDeviceException {
 369         if (!account.isPrimaryDevice()) {
 370             throw new NotPrimaryDeviceException();
 371         }
 372         if (pin.isPresent()) {
 373             context.getAccountHelper().setRegistrationPin(pin.get());
 374         } else {
 375             context.getAccountHelper().removeRegistrationPin();
 376         }
 377     }
 378
 379     void refreshPreKeys() throws IOException {
 380         context.getPreKeyHelper().refreshPreKeys();
 381     }
 382
 383     @Override
 384     public List<Group> getGroups() {
 385         return account.getGroupStore().getGroups().stream().map(this::toGroup).toList();
 386     }
 387
 388     private Group toGroup(final GroupInfo groupInfo) {
 389         if (groupInfo == null) {
 390             return null;
 391         }
 392
 393         return Group.from(groupInfo, account.getRecipientAddressResolver(), account.getSelfRecipientId());
 394     }
 395
 396     @Override
 397     public SendGroupMessageResults quitGroup(
 398             GroupId groupId, Set<RecipientIdentifier.Single> groupAdmins
 399     ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException, UnregisteredRecipientException {
 400         final var newAdmins = context.getRecipientHelper().resolveRecipients(groupAdmins);
 401         return context.getGroupHelper().quitGroup(groupId, newAdmins);
 402     }
 403
 404     @Override
 405     public void deleteGroup(GroupId groupId) throws IOException {
 406         final var group = context.getGroupHelper().getGroup(groupId);
 407         if (group.isMember(account.getSelfRecipientId())) {
 408             throw new IOException(
 409                     "The local group information cannot be removed, as the user is still a member of the group");
 410         }
 411         context.getGroupHelper().deleteGroup(groupId);
 412     }
 413
 414     @Override
 415     public Pair<GroupId, SendGroupMessageResults> createGroup(
 416             String name, Set<RecipientIdentifier.Single> members, String avatarFile
 417     ) throws IOException, AttachmentInvalidException, UnregisteredRecipientException {
 418         return context.getGroupHelper()
 419                 .createGroup(name,
 420                         members == null ? null : context.getRecipientHelper().resolveRecipients(members),
 421                         avatarFile);
 422     }
 423
 424     @Override
 425     public SendGroupMessageResults updateGroup(
 426             final GroupId groupId, final UpdateGroup updateGroup
 427     ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException, UnregisteredRecipientException {
 428         return context.getGroupHelper()
 429                 .updateGroup(groupId,
 430                         updateGroup.getName(),
 431                         updateGroup.getDescription(),
 432                         updateGroup.getMembers() == null
 433                                 ? null
 434                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getMembers()),
 435                         updateGroup.getRemoveMembers() == null
 436                                 ? null
 437                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveMembers()),
 438                         updateGroup.getAdmins() == null
 439                                 ? null
 440                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getAdmins()),
 441                         updateGroup.getRemoveAdmins() == null
 442                                 ? null
 443                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveAdmins()),
 444                         updateGroup.getBanMembers() == null
 445                                 ? null
 446                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getBanMembers()),
 447                         updateGroup.getUnbanMembers() == null
 448                                 ? null
 449                                 : context.getRecipientHelper().resolveRecipients(updateGroup.getUnbanMembers()),
 450                         updateGroup.isResetGroupLink(),
 451                         updateGroup.getGroupLinkState(),
 452                         updateGroup.getAddMemberPermission(),
 453                         updateGroup.getEditDetailsPermission(),
 454                         updateGroup.getAvatarFile(),
 455                         updateGroup.getExpirationTimer(),
 456                         updateGroup.getIsAnnouncementGroup());
 457     }
 458
 459     @Override
 460     public Pair<GroupId, SendGroupMessageResults> joinGroup(
 461             GroupInviteLinkUrl inviteLinkUrl
 462     ) throws IOException, InactiveGroupLinkException, PendingAdminApprovalException {
 463         return context.getGroupHelper().joinGroup(inviteLinkUrl);
 464     }
 465
 466     private SendMessageResults sendMessage(
 467             SignalServiceDataMessage.Builder messageBuilder, Set<RecipientIdentifier> recipients
 468     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 469         return sendMessage(messageBuilder, recipients, Optional.empty());
 470     }
 471
 472     private SendMessageResults sendMessage(
 473             SignalServiceDataMessage.Builder messageBuilder,
 474             Set<RecipientIdentifier> recipients,
 475             Optional<Long> editTargetTimestamp
 476     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 477         var results = new HashMap<RecipientIdentifier, List<SendMessageResult>>();
 478         long timestamp = System.currentTimeMillis();
 479         messageBuilder.withTimestamp(timestamp);
 480         for (final var recipient : recipients) {
 481             if (recipient instanceof RecipientIdentifier.Single single) {
 482                 try {
 483                     final var recipientId = context.getRecipientHelper().resolveRecipient(single);
 484                     final var result = context.getSendHelper()
 485                             .sendMessage(messageBuilder, recipientId, editTargetTimestamp);
 486                     results.put(recipient, List.of(toSendMessageResult(result)));
 487                 } catch (UnregisteredRecipientException e) {
 488                     results.put(recipient,
 489                             List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress())));
 490                 }
 491             } else if (recipient instanceof RecipientIdentifier.NoteToSelf) {
 492                 final var result = context.getSendHelper().sendSelfMessage(messageBuilder, editTargetTimestamp);
 493                 results.put(recipient, List.of(toSendMessageResult(result)));
 494             } else if (recipient instanceof RecipientIdentifier.Group group) {
 495                 final var result = context.getSendHelper()
 496                         .sendAsGroupMessage(messageBuilder, group.groupId(), editTargetTimestamp);
 497                 results.put(recipient, result.stream().map(this::toSendMessageResult).toList());
 498             }
 499         }
 500         return new SendMessageResults(timestamp, results);
 501     }
 502
 503     private SendMessageResult toSendMessageResult(final org.whispersystems.signalservice.api.messages.SendMessageResult result) {
 504         return SendMessageResult.from(result, account.getRecipientResolver(), account.getRecipientAddressResolver());
 505     }
 506
 507     private SendMessageResults sendTypingMessage(
 508             SignalServiceTypingMessage.Action action, Set<RecipientIdentifier> recipients
 509     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 510         var results = new HashMap<RecipientIdentifier, List<SendMessageResult>>();
 511         final var timestamp = System.currentTimeMillis();
 512         for (var recipient : recipients) {
 513             if (recipient instanceof RecipientIdentifier.Single single) {
 514                 final var message = new SignalServiceTypingMessage(action, timestamp, Optional.empty());
 515                 try {
 516                     final var recipientId = context.getRecipientHelper().resolveRecipient(single);
 517                     final var result = context.getSendHelper().sendTypingMessage(message, recipientId);
 518                     results.put(recipient, List.of(toSendMessageResult(result)));
 519                 } catch (UnregisteredRecipientException e) {
 520                     results.put(recipient,
 521                             List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress())));
 522                 }
 523             } else if (recipient instanceof RecipientIdentifier.Group) {
 524                 final var groupId = ((RecipientIdentifier.Group) recipient).groupId();
 525                 final var message = new SignalServiceTypingMessage(action, timestamp, Optional.of(groupId.serialize()));
 526                 final var result = context.getSendHelper().sendGroupTypingMessage(message, groupId);
 527                 results.put(recipient, result.stream().map(this::toSendMessageResult).toList());
 528             }
 529         }
 530         return new SendMessageResults(timestamp, results);
 531     }
 532
 533     @Override
 534     public SendMessageResults sendTypingMessage(
 535             TypingAction action, Set<RecipientIdentifier> recipients
 536     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 537         return sendTypingMessage(action.toSignalService(), recipients);
 538     }
 539
 540     @Override
 541     public SendMessageResults sendReadReceipt(
 542             RecipientIdentifier.Single sender, List<Long> messageIds
 543     ) {
 544         final var timestamp = System.currentTimeMillis();
 545         var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.READ,
 546                 messageIds,
 547                 timestamp);
 548
 549         return sendReceiptMessage(sender, timestamp, receiptMessage);
 550     }
 551
 552     @Override
 553     public SendMessageResults sendViewedReceipt(
 554             RecipientIdentifier.Single sender, List<Long> messageIds
 555     ) {
 556         final var timestamp = System.currentTimeMillis();
 557         var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.VIEWED,
 558                 messageIds,
 559                 timestamp);
 560
 561         return sendReceiptMessage(sender, timestamp, receiptMessage);
 562     }
 563
 564     private SendMessageResults sendReceiptMessage(
 565             final RecipientIdentifier.Single sender,
 566             final long timestamp,
 567             final SignalServiceReceiptMessage receiptMessage
 568     ) {
 569         try {
 570             final var result = context.getSendHelper()
 571                     .sendReceiptMessage(receiptMessage, context.getRecipientHelper().resolveRecipient(sender));
 572             return new SendMessageResults(timestamp, Map.of(sender, List.of(toSendMessageResult(result))));
 573         } catch (UnregisteredRecipientException e) {
 574             return new SendMessageResults(timestamp,
 575                     Map.of(sender, List.of(SendMessageResult.unregisteredFailure(sender.toPartialRecipientAddress()))));
 576         }
 577     }
 578
 579     @Override
 580     public SendMessageResults sendMessage(
 581             Message message, Set<RecipientIdentifier> recipients
 582     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException {
 583         final var selfProfile = context.getProfileHelper().getSelfProfile();
 584         if (selfProfile == null || selfProfile.getDisplayName().isEmpty()) {
 585             logger.warn(
 586                     "No profile name set. When sending a message it's recommended to set a profile name with the updateProfile command. This may become mandatory in the future.");
 587         }
 588         final var messageBuilder = SignalServiceDataMessage.newBuilder();
 589         applyMessage(messageBuilder, message);
 590         return sendMessage(messageBuilder, recipients);
 591     }
 592
 593     @Override
 594     public SendMessageResults sendEditMessage(
 595             Message message, Set<RecipientIdentifier> recipients, long editTargetTimestamp
 596     ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException {
 597         final var messageBuilder = SignalServiceDataMessage.newBuilder();
 598         applyMessage(messageBuilder, message);
 599         return sendMessage(messageBuilder, recipients, Optional.of(editTargetTimestamp));
 600     }
 601
 602     private void applyMessage(
 603             final SignalServiceDataMessage.Builder messageBuilder, final Message message
 604     ) throws AttachmentInvalidException, IOException, UnregisteredRecipientException, InvalidStickerException {
 605         if (message.messageText().length() > 2000) {
 606             final var messageBytes = message.messageText().getBytes(StandardCharsets.UTF_8);
 607             final var textAttachment = AttachmentUtils.createAttachmentStream(new StreamDetails(new ByteArrayInputStream(
 608                     messageBytes), MimeUtils.LONG_TEXT, messageBytes.length), Optional.empty());
 609             messageBuilder.withBody(message.messageText().substring(0, 2000));
 610             messageBuilder.withAttachment(context.getAttachmentHelper().uploadAttachment(textAttachment));
 611         } else {
 612             messageBuilder.withBody(message.messageText());
 613         }
 614         if (message.attachments().size() > 0) {
 615             messageBuilder.withAttachments(context.getAttachmentHelper().uploadAttachments(message.attachments()));
 616         }
 617         if (message.mentions().size() > 0) {
 618             messageBuilder.withMentions(resolveMentions(message.mentions()));
 619         }
 620         if (message.textStyles().size() > 0) {
 621             messageBuilder.withBodyRanges(message.textStyles().stream().map(TextStyle::toBodyRange).toList());
 622         }
 623         if (message.quote().isPresent()) {
 624             final var quote = message.quote().get();
 625             messageBuilder.withQuote(new SignalServiceDataMessage.Quote(quote.timestamp(),
 626                     context.getRecipientHelper()
 627                             .resolveSignalServiceAddress(context.getRecipientHelper().resolveRecipient(quote.author()))
 628                             .getServiceId(),
 629                     quote.message(),
 630                     List.of(),
 631                     resolveMentions(quote.mentions()),
 632                     SignalServiceDataMessage.Quote.Type.NORMAL,
 633                     quote.textStyles().stream().map(TextStyle::toBodyRange).toList()));
 634         }
 635         if (message.sticker().isPresent()) {
 636             final var sticker = message.sticker().get();
 637             final var packId = StickerPackId.deserialize(sticker.packId());
 638             final var stickerId = sticker.stickerId();
 639
 640             final var stickerPack = context.getAccount().getStickerStore().getStickerPack(packId);
 641             if (stickerPack == null) {
 642                 throw new InvalidStickerException("Sticker pack not found");
 643             }
 644             final var manifest = context.getStickerHelper().getOrRetrieveStickerPack(packId, stickerPack.packKey());
 645             if (manifest.stickers().size() <= stickerId) {
 646                 throw new InvalidStickerException("Sticker id not part of this pack");
 647             }
 648             final var manifestSticker = manifest.stickers().get(stickerId);
 649             final var streamDetails = context.getStickerPackStore().retrieveSticker(packId, stickerId);
 650             if (streamDetails == null) {
 651                 throw new InvalidStickerException("Missing local sticker file");
 652             }
 653             messageBuilder.withSticker(new SignalServiceDataMessage.Sticker(packId.serialize(),
 654                     stickerPack.packKey(),
 655                     stickerId,
 656                     manifestSticker.emoji(),
 657                     AttachmentUtils.createAttachmentStream(streamDetails, Optional.empty())));
 658         }
 659         if (message.previews().size() > 0) {
 660             final var previews = new ArrayList<SignalServicePreview>(message.previews().size());
 661             for (final var p : message.previews()) {
 662                 final var image = p.image().isPresent() ? context.getAttachmentHelper()
 663                         .uploadAttachment(p.image().get()) : null;
 664                 previews.add(new SignalServicePreview(p.url(),
 665                         p.title(),
 666                         p.description(),
 667                         0,
 668                         Optional.ofNullable(image)));
 669             }
 670             messageBuilder.withPreviews(previews);
 671         }
 672         if (message.storyReply().isPresent()) {
 673             final var storyReply = message.storyReply().get();
 674             final var authorServiceId = context.getRecipientHelper()
 675                     .resolveSignalServiceAddress(context.getRecipientHelper().resolveRecipient(storyReply.author()))
 676                     .getServiceId();
 677             messageBuilder.withStoryContext(new SignalServiceDataMessage.StoryContext(authorServiceId,
 678                     storyReply.timestamp()));
 679         }
 680     }
 681
 682     private ArrayList<SignalServiceDataMessage.Mention> resolveMentions(final List<Message.Mention> mentionList) throws UnregisteredRecipientException {
 683         final var mentions = new ArrayList<SignalServiceDataMessage.Mention>();
 684         for (final var m : mentionList) {
 685             final var recipientId = context.getRecipientHelper().resolveRecipient(m.recipient());
 686             mentions.add(new SignalServiceDataMessage.Mention(context.getRecipientHelper()
 687                     .resolveSignalServiceAddress(recipientId)
 688                     .getServiceId(), m.start(), m.length()));
 689         }
 690         return mentions;
 691     }
 692
 693     @Override
 694     public SendMessageResults sendRemoteDeleteMessage(
 695             long targetSentTimestamp, Set<RecipientIdentifier> recipients
 696     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
 697         var delete = new SignalServiceDataMessage.RemoteDelete(targetSentTimestamp);
 698         final var messageBuilder = SignalServiceDataMessage.newBuilder().withRemoteDelete(delete);
 699         for (final var recipient : recipients) {
 700             if (recipient instanceof RecipientIdentifier.Uuid u) {
 701                 account.getMessageSendLogStore()
 702                         .deleteEntryForRecipientNonGroup(targetSentTimestamp, ServiceId.from(u.uuid()));
 703             } else if (recipient instanceof RecipientIdentifier.Single r) {
 704                 try {
 705                     final var recipientId = context.getRecipientHelper().resolveRecipient(r);
 706                     final var address = account.getRecipientAddressResolver().resolveRecipientAddress(recipientId);
 707                     if (address.serviceId().isPresent()) {
 708                         account.getMessageSendLogStore()
 709                                 .deleteEntryForRecipientNonGroup(targetSentTimestamp, address.serviceId().get());
 710                     }
 711                 } catch (UnregisteredRecipientException ignored) {
 712                 }
 713             } else if (recipient instanceof RecipientIdentifier.Group r) {
 714                 account.getMessageSendLogStore().deleteEntryForGroup(targetSentTimestamp, r.groupId());
 715             }
 716         }
 717         return sendMessage(messageBuilder, recipients);
 718     }
 719
 720     @Override
 721     public SendMessageResults sendMessageReaction(
 722             String emoji,
 723             boolean remove,
 724             RecipientIdentifier.Single targetAuthor,
 725             long targetSentTimestamp,
 726             Set<RecipientIdentifier> recipients,
 727             final boolean isStory
 728     ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException {
 729         var targetAuthorRecipientId = context.getRecipientHelper().resolveRecipient(targetAuthor);
 730         final var authorServiceId = context.getRecipientHelper()
 731                 .resolveSignalServiceAddress(targetAuthorRecipientId)
 732                 .getServiceId();
 733         var reaction = new SignalServiceDataMessage.Reaction(emoji, remove, authorServiceId, targetSentTimestamp);
 734         final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction);
 735         if (isStory) {
 736             messageBuilder.withStoryContext(new SignalServiceDataMessage.StoryContext(authorServiceId,
 737                     targetSentTimestamp));
 738         }
 739         return sendMessage(messageBuilder, recipients);
 740     }
 741
 742     @Override
 743     public SendMessageResults sendPaymentNotificationMessage(
 744             byte[] receipt, String note, RecipientIdentifier.Single recipient
 745     ) throws IOException {
 746         final var paymentNotification = new SignalServiceDataMessage.PaymentNotification(receipt, note);
 747         final var payment = new SignalServiceDataMessage.Payment(paymentNotification, null);
 748         final var messageBuilder = SignalServiceDataMessage.newBuilder().withPayment(payment);
 749         try {
 750             return sendMessage(messageBuilder, Set.of(recipient));
 751         } catch (NotAGroupMemberException | GroupNotFoundException | GroupSendingNotAllowedException e) {
 752             throw new AssertionError(e);
 753         }
 754     }
 755
 756     @Override
 757     public SendMessageResults sendEndSessionMessage(Set<RecipientIdentifier.Single> recipients) throws IOException {
 758         var messageBuilder = SignalServiceDataMessage.newBuilder().asEndSessionMessage();
 759
 760         try {
 761             return sendMessage(messageBuilder,
 762                     recipients.stream().map(RecipientIdentifier.class::cast).collect(Collectors.toSet()));
 763         } catch (GroupNotFoundException | NotAGroupMemberException | GroupSendingNotAllowedException e) {
 764             throw new AssertionError(e);
 765         } finally {
 766             for (var recipient : recipients) {
 767                 final RecipientId recipientId;
 768                 try {
 769                     recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 770                 } catch (UnregisteredRecipientException e) {
 771                     continue;
 772                 }
 773                 final var serviceId = context.getAccount()
 774                         .getRecipientAddressResolver()
 775                         .resolveRecipientAddress(recipientId)
 776                         .serviceId();
 777                 if (serviceId.isPresent()) {
 778                     account.getAciSessionStore().deleteAllSessions(serviceId.get());
 779                 }
 780             }
 781         }
 782     }
 783
 784     @Override
 785     public void deleteRecipient(final RecipientIdentifier.Single recipient) {
 786         final var recipientIdOptional = context.getRecipientHelper().resolveRecipientOptional(recipient);
 787         if (recipientIdOptional.isPresent()) {
 788             account.removeRecipient(recipientIdOptional.get());
 789         }
 790     }
 791
 792     @Override
 793     public void deleteContact(final RecipientIdentifier.Single recipient) {
 794         final var recipientIdOptional = context.getRecipientHelper().resolveRecipientOptional(recipient);
 795         if (recipientIdOptional.isPresent()) {
 796             account.getContactStore().deleteContact(recipientIdOptional.get());
 797         }
 798     }
 799
 800     @Override
 801     public void setContactName(
 802             RecipientIdentifier.Single recipient, String givenName, final String familyName
 803     ) throws NotPrimaryDeviceException, UnregisteredRecipientException {
 804         if (!account.isPrimaryDevice()) {
 805             throw new NotPrimaryDeviceException();
 806         }
 807         context.getContactHelper()
 808                 .setContactName(context.getRecipientHelper().resolveRecipient(recipient), givenName, familyName);
 809     }
 810
 811     @Override
 812     public void setContactsBlocked(
 813             Collection<RecipientIdentifier.Single> recipients, boolean blocked
 814     ) throws NotPrimaryDeviceException, IOException, UnregisteredRecipientException {
 815         if (!account.isPrimaryDevice()) {
 816             throw new NotPrimaryDeviceException();
 817         }
 818         if (recipients.size() == 0) {
 819             return;
 820         }
 821         final var recipientIds = context.getRecipientHelper().resolveRecipients(recipients);
 822         final var selfRecipientId = account.getSelfRecipientId();
 823         boolean shouldRotateProfileKey = false;
 824         for (final var recipientId : recipientIds) {
 825             if (context.getContactHelper().isContactBlocked(recipientId) == blocked) {
 826                 continue;
 827             }
 828             context.getContactHelper().setContactBlocked(recipientId, blocked);
 829             // if we don't have a common group with the blocked contact we need to rotate the profile key
 830             shouldRotateProfileKey = blocked && (
 831                     shouldRotateProfileKey || account.getGroupStore()
 832                             .getGroups()
 833                             .stream()
 834                             .noneMatch(g -> g.isMember(selfRecipientId) && g.isMember(recipientId))
 835             );
 836         }
 837         if (shouldRotateProfileKey) {
 838             context.getProfileHelper().rotateProfileKey();
 839         }
 840         context.getSyncHelper().sendBlockedList();
 841     }
 842
 843     @Override
 844     public void setGroupsBlocked(
 845             final Collection<GroupId> groupIds, final boolean blocked
 846     ) throws GroupNotFoundException, NotPrimaryDeviceException, IOException {
 847         if (!account.isPrimaryDevice()) {
 848             throw new NotPrimaryDeviceException();
 849         }
 850         if (groupIds.size() == 0) {
 851             return;
 852         }
 853         boolean shouldRotateProfileKey = false;
 854         for (final var groupId : groupIds) {
 855             if (context.getGroupHelper().isGroupBlocked(groupId) == blocked) {
 856                 continue;
 857             }
 858             context.getGroupHelper().setGroupBlocked(groupId, blocked);
 859             shouldRotateProfileKey = blocked;
 860         }
 861         if (shouldRotateProfileKey) {
 862             context.getProfileHelper().rotateProfileKey();
 863         }
 864         context.getSyncHelper().sendBlockedList();
 865     }
 866
 867     @Override
 868     public void setExpirationTimer(
 869             RecipientIdentifier.Single recipient, int messageExpirationTimer
 870     ) throws IOException, UnregisteredRecipientException {
 871         var recipientId = context.getRecipientHelper().resolveRecipient(recipient);
 872         context.getContactHelper().setExpirationTimer(recipientId, messageExpirationTimer);
 873         final var messageBuilder = SignalServiceDataMessage.newBuilder().asExpirationUpdate();
 874         try {
 875             sendMessage(messageBuilder, Set.of(recipient));
 876         } catch (NotAGroupMemberException | GroupNotFoundException | GroupSendingNotAllowedException e) {
 877             throw new AssertionError(e);
 878         }
 879     }
 880
 881     @Override
 882     public StickerPackUrl uploadStickerPack(File path) throws IOException, StickerPackInvalidException {
 883         var manifest = StickerUtils.getSignalServiceStickerManifestUpload(path);
 884
 885         var messageSender = dependencies.getMessageSender();
 886
 887         var packKey = KeyUtils.createStickerUploadKey();
 888         var packIdString = messageSender.uploadStickerManifest(manifest, packKey);
 889         var packId = StickerPackId.deserialize(Hex.fromStringCondensed(packIdString));
 890
 891         var sticker = new StickerPack(packId, packKey);
 892         account.getStickerStore().addStickerPack(sticker);
 893
 894         return new StickerPackUrl(packId, packKey);
 895     }
 896
 897     @Override
 898     public List<org.asamk.signal.manager.api.StickerPack> getStickerPacks() {
 899         final var stickerPackStore = context.getStickerPackStore();
 900         return account.getStickerStore().getStickerPacks().stream().map(pack -> {
 901             if (stickerPackStore.existsStickerPack(pack.packId())) {
 902                 try {
 903                     final var manifest = stickerPackStore.retrieveManifest(pack.packId());
 904                     return new org.asamk.signal.manager.api.StickerPack(pack.packId(),
 905                             new StickerPackUrl(pack.packId(), pack.packKey()),
 906                             pack.isInstalled(),
 907                             manifest.title(),
 908                             manifest.author(),
 909                             Optional.ofNullable(manifest.cover() == null ? null : manifest.cover().toApi()),
 910                             manifest.stickers().stream().map(JsonStickerPack.JsonSticker::toApi).toList());
 911                 } catch (Exception e) {
 912                     logger.warn("Failed to read local sticker pack manifest: {}", e.getMessage(), e);
 913                 }
 914             }
 915
 916             return new org.asamk.signal.manager.api.StickerPack(pack.packId(), pack.packKey(), pack.isInstalled());
 917         }).toList();
 918     }
 919
 920     @Override
 921     public void requestAllSyncData() throws IOException {
 922         context.getSyncHelper().requestAllSyncData();
 923         retrieveRemoteStorage();
 924     }
 925
 926     void retrieveRemoteStorage() throws IOException {
 927         context.getStorageHelper().readDataFromStorage();
 928     }
 929
 930     @Override
 931     public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
 932         synchronized (messageHandlers) {
 933             if (isWeakListener) {
 934                 weakHandlers.add(handler);
 935             } else {
 936                 messageHandlers.add(handler);
 937                 startReceiveThreadIfRequired();
 938             }
 939         }
 940     }
 941
 942     private static final AtomicInteger threadNumber = new AtomicInteger(0);
 943
 944     private void startReceiveThreadIfRequired() {
 945         if (receiveThread != null || isReceivingSynchronous) {
 946             return;
 947         }
 948         receiveThread = new Thread(() -> {
 949             logger.debug("Starting receiving messages");
 950             context.getReceiveHelper().receiveMessagesContinuously(this::passReceivedMessageToHandlers);
 951             logger.debug("Finished receiving messages");
 952             synchronized (messageHandlers) {
 953                 receiveThread = null;
 954
 955                 // Check if in the meantime another handler has been registered
 956                 if (!messageHandlers.isEmpty()) {
 957                     logger.debug("Another handler has been registered, starting receive thread again");
 958                     startReceiveThreadIfRequired();
 959                 }
 960             }
 961         });
 962         receiveThread.setName("receive-" + threadNumber.getAndIncrement());
 963
 964         receiveThread.start();
 965     }
 966
 967     private void passReceivedMessageToHandlers(MessageEnvelope envelope, Throwable e) {
 968         synchronized (messageHandlers) {
 969             Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> {
 970                 try {
 971                     h.handleMessage(envelope, e);
 972                 } catch (Throwable ex) {
 973                     logger.warn("Message handler failed, ignoring", ex);
 974                 }
 975             });
 976         }
 977     }
 978
 979     @Override
 980     public void removeReceiveHandler(final ReceiveMessageHandler handler) {
 981         final Thread thread;
 982         synchronized (messageHandlers) {
 983             weakHandlers.remove(handler);
 984             messageHandlers.remove(handler);
 985             if (!messageHandlers.isEmpty() || receiveThread == null || isReceivingSynchronous) {
 986                 return;
 987             }
 988             thread = receiveThread;
 989             receiveThread = null;
 990         }
 991
 992         stopReceiveThread(thread);
 993     }
 994
 995     private void stopReceiveThread(final Thread thread) {
 996         if (context.getReceiveHelper().requestStopReceiveMessages()) {
 997             logger.debug("Receive stop requested, interrupting read from server.");
 998             thread.interrupt();
 999         }
1000         try {
1001             thread.join();
1002         } catch (InterruptedException ignored) {
1003         }
1004     }
1005
1006     @Override
1007     public boolean isReceiving() {
1008         if (isReceivingSynchronous) {
1009             return true;
1010         }
1011         synchronized (messageHandlers) {
1012             return messageHandlers.size() > 0;
1013         }
1014     }
1015
1016     @Override
1017     public void receiveMessages(
1018             Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
1019     ) throws IOException, AlreadyReceivingException {
1020         receiveMessages(timeout.orElse(Duration.ofMinutes(1)), timeout.isPresent(), maxMessages.orElse(null), handler);
1021     }
1022
1023     private void receiveMessages(
1024             Duration timeout, boolean returnOnTimeout, Integer maxMessages, ReceiveMessageHandler handler
1025     ) throws IOException, AlreadyReceivingException {
1026         synchronized (messageHandlers) {
1027             if (isReceiving()) {
1028                 throw new AlreadyReceivingException("Already receiving message.");
1029             }
1030             isReceivingSynchronous = true;
1031             receiveThread = Thread.currentThread();
1032         }
1033         try {
1034             context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, (envelope, e) -> {
1035                 passReceivedMessageToHandlers(envelope, e);
1036                 handler.handleMessage(envelope, e);
1037             });
1038         } finally {
1039             synchronized (messageHandlers) {
1040                 receiveThread = null;
1041                 isReceivingSynchronous = false;
1042                 if (messageHandlers.size() > 0) {
1043                     startReceiveThreadIfRequired();
1044                 }
1045             }
1046         }
1047     }
1048
1049     @Override
1050     public void setReceiveConfig(final ReceiveConfig receiveConfig) {
1051         context.getReceiveHelper().setReceiveConfig(receiveConfig);
1052     }
1053
1054     @Override
1055     public boolean isContactBlocked(final RecipientIdentifier.Single recipient) {
1056         final RecipientId recipientId;
1057         try {
1058             recipientId = context.getRecipientHelper().resolveRecipient(recipient);
1059         } catch (UnregisteredRecipientException e) {
1060             return false;
1061         }
1062         return context.getContactHelper().isContactBlocked(recipientId);
1063     }
1064
1065     @Override
1066     public void sendContacts() throws IOException {
1067         context.getSyncHelper().sendContacts();
1068     }
1069
1070     @Override
1071     public List<Recipient> getRecipients(
1072             boolean onlyContacts,
1073             Optional<Boolean> blocked,
1074             Collection<RecipientIdentifier.Single> recipients,
1075             Optional<String> name
1076     ) {
1077         final var recipientIds = recipients.stream().map(a -> {
1078             try {
1079                 return context.getRecipientHelper().resolveRecipient(a);
1080             } catch (UnregisteredRecipientException e) {
1081                 return null;
1082             }
1083         }).filter(Objects::nonNull).collect(Collectors.toSet());
1084         if (!recipients.isEmpty() && recipientIds.isEmpty()) {
1085             return List.of();
1086         }
1087         // refresh profiles of explicitly given recipients
1088         context.getProfileHelper().refreshRecipientProfiles(recipientIds);
1089         return account.getRecipientStore()
1090                 .getRecipients(onlyContacts, blocked, recipientIds, name)
1091                 .stream()
1092                 .map(s -> new Recipient(s.getRecipientId(),
1093                         s.getAddress().toApiRecipientAddress(),
1094                         s.getContact(),
1095                         s.getProfileKey(),
1096                         s.getExpiringProfileKeyCredential(),
1097                         s.getProfile()))
1098                 .toList();
1099     }
1100
1101     @Override
1102     public String getContactOrProfileName(RecipientIdentifier.Single recipient) {
1103         final RecipientId recipientId;
1104         try {
1105             recipientId = context.getRecipientHelper().resolveRecipient(recipient);
1106         } catch (UnregisteredRecipientException e) {
1107             return null;
1108         }
1109
1110         final var contact = account.getContactStore().getContact(recipientId);
1111         if (contact != null && !Util.isEmpty(contact.getName())) {
1112             return contact.getName();
1113         }
1114
1115         final var profile = context.getProfileHelper().getRecipientProfile(recipientId);
1116         if (profile != null) {
1117             return profile.getDisplayName();
1118         }
1119
1120         return null;
1121     }
1122
1123     @Override
1124     public Group getGroup(GroupId groupId) {
1125         return toGroup(context.getGroupHelper().getGroup(groupId));
1126     }
1127
1128     @Override
1129     public List<Identity> getIdentities() {
1130         return account.getIdentityKeyStore().getIdentities().stream().map(this::toIdentity).toList();
1131     }
1132
1133     private Identity toIdentity(final IdentityInfo identityInfo) {
1134         if (identityInfo == null) {
1135             return null;
1136         }
1137
1138         final var address = account.getRecipientAddressResolver()
1139                 .resolveRecipientAddress(account.getRecipientResolver().resolveRecipient(identityInfo.getServiceId()));
1140         final var scannableFingerprint = context.getIdentityHelper()
1141                 .computeSafetyNumberForScanning(identityInfo.getServiceId(), identityInfo.getIdentityKey());
1142         return new Identity(address.toApiRecipientAddress(),
1143                 identityInfo.getIdentityKey(),
1144                 context.getIdentityHelper()
1145                         .computeSafetyNumber(identityInfo.getServiceId(), identityInfo.getIdentityKey()),
1146                 scannableFingerprint == null ? null : scannableFingerprint.getSerialized(),
1147                 identityInfo.getTrustLevel(),
1148                 identityInfo.getDateAddedTimestamp());
1149     }
1150
1151     @Override
1152     public List<Identity> getIdentities(RecipientIdentifier.Single recipient) {
1153         ServiceId serviceId;
1154         try {
1155             final var address = account.getRecipientAddressResolver()
1156                     .resolveRecipientAddress(context.getRecipientHelper().resolveRecipient(recipient));
1157             if (address.serviceId().isEmpty()) {
1158                 return List.of();
1159             }
1160             serviceId = address.serviceId().get();
1161         } catch (UnregisteredRecipientException e) {
1162             return List.of();
1163         }
1164         final var identity = account.getIdentityKeyStore().getIdentityInfo(serviceId);
1165         return identity == null ? List.of() : List.of(toIdentity(identity));
1166     }
1167
1168     @Override
1169     public boolean trustIdentityVerified(
1170             RecipientIdentifier.Single recipient, IdentityVerificationCode verificationCode
1171     ) throws UnregisteredRecipientException {
1172         if (verificationCode instanceof IdentityVerificationCode.Fingerprint fingerprint) {
1173             return trustIdentity(recipient,
1174                     r -> context.getIdentityHelper().trustIdentityVerified(r, fingerprint.fingerprint()));
1175         } else if (verificationCode instanceof IdentityVerificationCode.SafetyNumber safetyNumber) {
1176             return trustIdentity(recipient,
1177                     r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber.safetyNumber()));
1178         } else if (verificationCode instanceof IdentityVerificationCode.ScannableSafetyNumber safetyNumber) {
1179             return trustIdentity(recipient,
1180                     r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber.safetyNumber()));
1181         } else {
1182             throw new AssertionError("Invalid verification code type");
1183         }
1184     }
1185
1186     @Override
1187     public boolean trustIdentityAllKeys(RecipientIdentifier.Single recipient) throws UnregisteredRecipientException {
1188         return trustIdentity(recipient, r -> context.getIdentityHelper().trustIdentityAllKeys(r));
1189     }
1190
1191     private boolean trustIdentity(
1192             RecipientIdentifier.Single recipient, Function<RecipientId, Boolean> trustMethod
1193     ) throws UnregisteredRecipientException {
1194         final var recipientId = context.getRecipientHelper().resolveRecipient(recipient);
1195         final var updated = trustMethod.apply(recipientId);
1196         if (updated && this.isReceiving()) {
1197             context.getReceiveHelper().setNeedsToRetryFailedMessages(true);
1198         }
1199         return updated;
1200     }
1201
1202     @Override
1203     public void addAddressChangedListener(final Runnable listener) {
1204         synchronized (addressChangedListeners) {
1205             addressChangedListeners.add(listener);
1206         }
1207     }
1208
1209     @Override
1210     public void addClosedListener(final Runnable listener) {
1211         synchronized (closedListeners) {
1212             closedListeners.add(listener);
1213         }
1214     }
1215
1216     @Override
1217     public InputStream retrieveAttachment(final String id) throws IOException {
1218         return context.getAttachmentHelper().retrieveAttachment(id).getStream();
1219     }
1220
1221     @Override
1222     public void close() {
1223         Thread thread;
1224         synchronized (messageHandlers) {
1225             weakHandlers.clear();
1226             messageHandlers.clear();
1227             thread = receiveThread;
1228             receiveThread = null;
1229         }
1230         if (thread != null) {
1231             stopReceiveThread(thread);
1232         }
1233         executor.shutdown();
1234
1235         dependencies.getSignalWebSocket().disconnect();
1236         disposable.dispose();
1237
1238         if (account != null) {
1239             account.close();
1240         }
1241
1242         synchronized (closedListeners) {
1243             closedListeners.forEach(Runnable::run);
1244             closedListeners.clear();
1245         }
1246
1247         account = null;
1248     }
1249 }