X-Git-Url: https://git.nmode.ca/signal-cli/blobdiff_plain/8aab644db9baa4feb5ccef4f43144313278f4691..8a31b7f2c153e89532010b9ab58eb045ddfe43fe:/lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java diff --git a/lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java b/lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java index a648b188..1cc0629b 100644 --- a/lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java +++ b/lib/src/main/java/org/asamk/signal/manager/ManagerImpl.java @@ -1,5 +1,5 @@ /* - Copyright (C) 2015-2021 AsamK and contributors + Copyright (C) 2015-2022 AsamK and contributors This program is free software: you can redistribute it and/or modify it under the terms of the GNU General Public License as published by @@ -16,22 +16,35 @@ */ package org.asamk.signal.manager; -import org.asamk.signal.manager.actions.HandleAction; +import org.asamk.signal.manager.api.AlreadyReceivingException; +import org.asamk.signal.manager.api.AttachmentInvalidException; import org.asamk.signal.manager.api.Configuration; import org.asamk.signal.manager.api.Device; import org.asamk.signal.manager.api.Group; import org.asamk.signal.manager.api.Identity; import org.asamk.signal.manager.api.InactiveGroupLinkException; import org.asamk.signal.manager.api.InvalidDeviceLinkException; +import org.asamk.signal.manager.api.InvalidStickerException; +import org.asamk.signal.manager.api.InvalidUsernameException; import org.asamk.signal.manager.api.Message; +import org.asamk.signal.manager.api.MessageEnvelope; +import org.asamk.signal.manager.api.NotPrimaryDeviceException; import org.asamk.signal.manager.api.Pair; +import org.asamk.signal.manager.api.PendingAdminApprovalException; +import org.asamk.signal.manager.api.ReceiveConfig; +import org.asamk.signal.manager.api.Recipient; import org.asamk.signal.manager.api.RecipientIdentifier; import org.asamk.signal.manager.api.SendGroupMessageResults; import org.asamk.signal.manager.api.SendMessageResult; import org.asamk.signal.manager.api.SendMessageResults; +import org.asamk.signal.manager.api.StickerPackId; +import org.asamk.signal.manager.api.StickerPackInvalidException; +import org.asamk.signal.manager.api.StickerPackUrl; import org.asamk.signal.manager.api.TypingAction; +import org.asamk.signal.manager.api.UnregisteredRecipientException; import org.asamk.signal.manager.api.UpdateGroup; -import org.asamk.signal.manager.config.ServiceConfig; +import org.asamk.signal.manager.api.UpdateProfile; +import org.asamk.signal.manager.api.UserStatus; import org.asamk.signal.manager.config.ServiceEnvironmentConfig; import org.asamk.signal.manager.groups.GroupId; import org.asamk.signal.manager.groups.GroupInviteLinkUrl; @@ -39,126 +52,90 @@ import org.asamk.signal.manager.groups.GroupNotFoundException; import org.asamk.signal.manager.groups.GroupSendingNotAllowedException; import org.asamk.signal.manager.groups.LastGroupAdminException; import org.asamk.signal.manager.groups.NotAGroupMemberException; -import org.asamk.signal.manager.helper.AttachmentHelper; -import org.asamk.signal.manager.helper.ContactHelper; -import org.asamk.signal.manager.helper.GroupHelper; -import org.asamk.signal.manager.helper.GroupV2Helper; -import org.asamk.signal.manager.helper.IdentityHelper; -import org.asamk.signal.manager.helper.IncomingMessageHandler; -import org.asamk.signal.manager.helper.PinHelper; -import org.asamk.signal.manager.helper.PreKeyHelper; -import org.asamk.signal.manager.helper.ProfileHelper; -import org.asamk.signal.manager.helper.SendHelper; -import org.asamk.signal.manager.helper.StorageHelper; -import org.asamk.signal.manager.helper.SyncHelper; -import org.asamk.signal.manager.helper.UnidentifiedAccessHelper; -import org.asamk.signal.manager.jobs.Context; +import org.asamk.signal.manager.helper.AccountFileUpdater; +import org.asamk.signal.manager.helper.Context; import org.asamk.signal.manager.storage.SignalAccount; import org.asamk.signal.manager.storage.groups.GroupInfo; import org.asamk.signal.manager.storage.identities.IdentityInfo; -import org.asamk.signal.manager.storage.messageCache.CachedMessage; -import org.asamk.signal.manager.storage.recipients.Contact; import org.asamk.signal.manager.storage.recipients.Profile; -import org.asamk.signal.manager.storage.recipients.RecipientAddress; import org.asamk.signal.manager.storage.recipients.RecipientId; -import org.asamk.signal.manager.storage.stickers.Sticker; -import org.asamk.signal.manager.storage.stickers.StickerPackId; +import org.asamk.signal.manager.storage.stickerPacks.JsonStickerPack; +import org.asamk.signal.manager.storage.stickerPacks.StickerPackStore; +import org.asamk.signal.manager.storage.stickers.StickerPack; +import org.asamk.signal.manager.util.AttachmentUtils; import org.asamk.signal.manager.util.KeyUtils; +import org.asamk.signal.manager.util.MimeUtils; import org.asamk.signal.manager.util.StickerUtils; +import org.signal.libsignal.usernames.BaseUsernameException; import org.slf4j.Logger; import org.slf4j.LoggerFactory; -import org.whispersystems.libsignal.InvalidKeyException; -import org.whispersystems.libsignal.ecc.ECPublicKey; -import org.whispersystems.libsignal.util.guava.Optional; import org.whispersystems.signalservice.api.SignalSessionLock; import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage; -import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope; +import org.whispersystems.signalservice.api.messages.SignalServicePreview; import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage; import org.whispersystems.signalservice.api.messages.SignalServiceTypingMessage; import org.whispersystems.signalservice.api.push.ACI; -import org.whispersystems.signalservice.api.push.SignalServiceAddress; +import org.whispersystems.signalservice.api.push.ServiceId; import org.whispersystems.signalservice.api.util.DeviceNameUtil; import org.whispersystems.signalservice.api.util.InvalidNumberException; import org.whispersystems.signalservice.api.util.PhoneNumberFormatter; -import org.whispersystems.signalservice.api.websocket.WebSocketUnavailableException; -import org.whispersystems.signalservice.internal.contacts.crypto.Quote; -import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedQuoteException; -import org.whispersystems.signalservice.internal.contacts.crypto.UnauthenticatedResponseException; -import org.whispersystems.signalservice.internal.util.DynamicCredentialsProvider; +import org.whispersystems.signalservice.api.util.StreamDetails; import org.whispersystems.signalservice.internal.util.Hex; import org.whispersystems.signalservice.internal.util.Util; +import java.io.ByteArrayInputStream; import java.io.File; import java.io.IOException; +import java.io.InputStream; import java.net.URI; -import java.net.URISyntaxException; -import java.net.URLEncoder; import java.nio.charset.StandardCharsets; -import java.security.SignatureException; +import java.time.Duration; import java.util.ArrayList; import java.util.Collection; import java.util.HashMap; import java.util.HashSet; import java.util.List; import java.util.Map; +import java.util.Objects; +import java.util.Optional; import java.util.Set; -import java.util.UUID; import java.util.concurrent.ExecutorService; import java.util.concurrent.Executors; -import java.util.concurrent.TimeUnit; -import java.util.concurrent.TimeoutException; +import java.util.concurrent.atomic.AtomicInteger; import java.util.concurrent.locks.ReentrantLock; +import java.util.function.Function; import java.util.stream.Collectors; import java.util.stream.Stream; -import static org.asamk.signal.manager.config.ServiceConfig.capabilities; +import io.reactivex.rxjava3.disposables.CompositeDisposable; -public class ManagerImpl implements Manager { +class ManagerImpl implements Manager { private final static Logger logger = LoggerFactory.getLogger(ManagerImpl.class); - private final ServiceEnvironmentConfig serviceEnvironmentConfig; - private final SignalDependencies dependencies; - private SignalAccount account; + private final SignalDependencies dependencies; + private final Context context; private final ExecutorService executor = Executors.newCachedThreadPool(); - private final ProfileHelper profileHelper; - private final PinHelper pinHelper; - private final StorageHelper storageHelper; - private final SendHelper sendHelper; - private final SyncHelper syncHelper; - private final AttachmentHelper attachmentHelper; - private final GroupHelper groupHelper; - private final ContactHelper contactHelper; - private final IncomingMessageHandler incomingMessageHandler; - private final PreKeyHelper preKeyHelper; - private final IdentityHelper identityHelper; - - private final Context context; - private boolean hasCaughtUpWithOldMessages = false; - private boolean ignoreAttachments = false; - private Thread receiveThread; + private boolean isReceivingSynchronous; private final Set weakHandlers = new HashSet<>(); private final Set messageHandlers = new HashSet<>(); private final List closedListeners = new ArrayList<>(); - private boolean isReceivingSynchronous; + private final List addressChangedListeners = new ArrayList<>(); + private final CompositeDisposable disposable = new CompositeDisposable(); ManagerImpl( SignalAccount account, PathConfig pathConfig, + AccountFileUpdater accountFileUpdater, ServiceEnvironmentConfig serviceEnvironmentConfig, String userAgent ) { this.account = account; - this.serviceEnvironmentConfig = serviceEnvironmentConfig; - final var credentialsProvider = new DynamicCredentialsProvider(account.getAci(), - account.getAccount(), - account.getPassword(), - account.getDeviceId()); final var sessionLock = new SignalSessionLock() { private final ReentrantLock LEGACY_LOCK = new ReentrantLock(); @@ -170,178 +147,119 @@ public class ManagerImpl implements Manager { }; this.dependencies = new SignalDependencies(serviceEnvironmentConfig, userAgent, - credentialsProvider, - account.getSignalProtocolStore(), + account.getCredentialsProvider(), + account.getSignalServiceDataStore(), executor, sessionLock); final var avatarStore = new AvatarStore(pathConfig.avatarsPath()); final var attachmentStore = new AttachmentStore(pathConfig.attachmentsPath()); final var stickerPackStore = new StickerPackStore(pathConfig.stickerPacksPath()); - this.attachmentHelper = new AttachmentHelper(dependencies, attachmentStore); - this.pinHelper = new PinHelper(dependencies.getKeyBackupService()); - final var unidentifiedAccessHelper = new UnidentifiedAccessHelper(account, - dependencies, - account::getProfileKey, - this::getRecipientProfile); - this.profileHelper = new ProfileHelper(account, - dependencies, - avatarStore, - unidentifiedAccessHelper::getAccessFor, - this::resolveSignalServiceAddress); - final GroupV2Helper groupV2Helper = new GroupV2Helper(profileHelper::getRecipientProfileKeyCredential, - this::getRecipientProfile, - account::getSelfRecipientId, - dependencies.getGroupsV2Operations(), - dependencies.getGroupsV2Api(), - this::resolveSignalServiceAddress); - this.sendHelper = new SendHelper(account, - dependencies, - unidentifiedAccessHelper, - this::resolveSignalServiceAddress, - account.getRecipientStore(), - this::handleIdentityFailure, - this::getGroupInfo, - this::refreshRegisteredUser); - this.groupHelper = new GroupHelper(account, - dependencies, - attachmentHelper, - sendHelper, - groupV2Helper, - avatarStore, - this::resolveSignalServiceAddress, - account.getRecipientStore()); - this.storageHelper = new StorageHelper(account, dependencies, groupHelper, profileHelper); - this.contactHelper = new ContactHelper(account); - this.syncHelper = new SyncHelper(account, - attachmentHelper, - sendHelper, - groupHelper, - avatarStore, - this::resolveSignalServiceAddress); - preKeyHelper = new PreKeyHelper(account, dependencies); - - this.context = new Context(account, - dependencies, - stickerPackStore, - sendHelper, - groupHelper, - syncHelper, - profileHelper, - storageHelper, - preKeyHelper); - var jobExecutor = new JobExecutor(context); - - this.incomingMessageHandler = new IncomingMessageHandler(account, - dependencies, - account.getRecipientStore(), - this::resolveSignalServiceAddress, - groupHelper, - contactHelper, - attachmentHelper, - syncHelper, - this::getRecipientProfile, - jobExecutor); - this.identityHelper = new IdentityHelper(account, - dependencies, - this::resolveSignalServiceAddress, - syncHelper, - profileHelper); + this.context = new Context(account, new AccountFileUpdater() { + @Override + public void updateAccountIdentifiers(final String number, final ACI aci) { + accountFileUpdater.updateAccountIdentifiers(number, aci); + synchronized (addressChangedListeners) { + addressChangedListeners.forEach(Runnable::run); + } + } + + @Override + public void removeAccount() { + accountFileUpdater.removeAccount(); + } + }, dependencies, avatarStore, attachmentStore, stickerPackStore); + this.context.getAccountHelper().setUnregisteredListener(this::close); + this.context.getReceiveHelper().setAuthenticationFailureListener(this::close); + this.context.getReceiveHelper().setCaughtUpWithOldMessagesListener(() -> { + synchronized (this) { + this.notifyAll(); + } + }); + disposable.add(account.getIdentityKeyStore().getIdentityChanges().subscribe(serviceId -> { + logger.trace("Archiving old sessions for {}", serviceId); + account.getAciSessionStore().archiveSessions(serviceId); + account.getPniSessionStore().archiveSessions(serviceId); + account.getSenderKeyStore().deleteSharedWith(serviceId); + final var recipientId = account.getRecipientResolver().resolveRecipient(serviceId); + final var profile = account.getProfileStore().getProfile(recipientId); + if (profile != null) { + account.getProfileStore() + .storeProfile(recipientId, + Profile.newBuilder(profile) + .withUnidentifiedAccessMode(Profile.UnidentifiedAccessMode.UNKNOWN) + .withLastUpdateTimestamp(0) + .build()); + } + })); } @Override public String getSelfNumber() { - return account.getAccount(); + return account.getNumber(); } - @Override - public void checkAccountState() throws IOException { - if (account.getLastReceiveTimestamp() == 0) { - logger.info("The Signal protocol expects that incoming messages are regularly received."); - } else { - var diffInMilliseconds = System.currentTimeMillis() - account.getLastReceiveTimestamp(); - long days = TimeUnit.DAYS.convert(diffInMilliseconds, TimeUnit.MILLISECONDS); - if (days > 7) { - logger.warn( - "Messages have been last received {} days ago. The Signal protocol expects that incoming messages are regularly received.", - days); - } - } - preKeyHelper.refreshPreKeysIfNecessary(); - if (account.getAci() == null) { - account.setAci(dependencies.getAccountManager().getOwnAci()); - } - updateAccountAttributes(null); + void checkAccountState() throws IOException { + context.getAccountHelper().checkAccountState(); } - /** - * This is used for checking a set of phone numbers for registration on Signal - * - * @param numbers The set of phone number in question - * @return A map of numbers to canonicalized number and uuid. If a number is not registered the uuid is null. - * @throws IOException if its unable to get the contacts to check if they're registered - */ @Override - public Map> areUsersRegistered(Set numbers) throws IOException { - Map canonicalizedNumbers = numbers.stream().collect(Collectors.toMap(n -> n, n -> { + public Map getUserStatus(Set numbers) throws IOException { + final var canonicalizedNumbers = numbers.stream().collect(Collectors.toMap(n -> n, n -> { try { - return PhoneNumberFormatter.formatNumber(n, account.getAccount()); + final var canonicalizedNumber = PhoneNumberFormatter.formatNumber(n, account.getNumber()); + if (!canonicalizedNumber.equals(n)) { + logger.debug("Normalized number {} to {}.", n, canonicalizedNumber); + } + return canonicalizedNumber; } catch (InvalidNumberException e) { return ""; } })); // Note "registeredUsers" has no optionals. It only gives us info on users who are registered - var registeredUsers = getRegisteredUsers(canonicalizedNumbers.values() + final var canonicalizedNumbersSet = canonicalizedNumbers.values() .stream() .filter(s -> !s.isEmpty()) - .collect(Collectors.toSet())); + .collect(Collectors.toSet()); + final var registeredUsers = context.getRecipientHelper().getRegisteredUsers(canonicalizedNumbersSet); return numbers.stream().collect(Collectors.toMap(n -> n, n -> { final var number = canonicalizedNumbers.get(n); - final var aci = registeredUsers.get(number); - return new Pair<>(number.isEmpty() ? null : number, aci == null ? null : aci.uuid()); + final var user = registeredUsers.get(number); + final var serviceId = user == null ? null : user.getServiceId(); + final var profile = serviceId == null + ? null + : context.getProfileHelper() + .getRecipientProfile(account.getRecipientResolver().resolveRecipient(serviceId)); + return new UserStatus(number.isEmpty() ? null : number, + serviceId == null ? null : serviceId.uuid(), + profile != null + && profile.getUnidentifiedAccessMode() == Profile.UnidentifiedAccessMode.UNRESTRICTED); })); } @Override public void updateAccountAttributes(String deviceName) throws IOException { - final String encryptedDeviceName; - if (deviceName == null) { - encryptedDeviceName = account.getEncryptedDeviceName(); - } else { - final var privateKey = account.getIdentityKeyPair().getPrivateKey(); - encryptedDeviceName = DeviceNameUtil.encryptDeviceName(deviceName, privateKey); - account.setEncryptedDeviceName(encryptedDeviceName); + if (deviceName != null) { + context.getAccountHelper().setDeviceName(deviceName); } - dependencies.getAccountManager() - .setAccountAttributes(encryptedDeviceName, - null, - account.getLocalRegistrationId(), - true, - null, - account.getPinMasterKey() == null ? null : account.getPinMasterKey().deriveRegistrationLock(), - account.getSelfUnidentifiedAccessKey(), - account.isUnrestrictedUnidentifiedAccess(), - capabilities, - account.isDiscoverableByPhoneNumber()); + context.getAccountHelper().updateAccountAttributes(); + context.getAccountHelper().checkWhoAmiI(); } @Override public Configuration getConfiguration() { final var configurationStore = account.getConfigurationStore(); - return new Configuration(java.util.Optional.ofNullable(configurationStore.getReadReceipts()), - java.util.Optional.ofNullable(configurationStore.getUnidentifiedDeliveryIndicators()), - java.util.Optional.ofNullable(configurationStore.getTypingIndicators()), - java.util.Optional.ofNullable(configurationStore.getLinkPreviews())); + return Configuration.from(configurationStore); } @Override public void updateConfiguration( Configuration configuration - ) throws IOException, NotMasterDeviceException { - if (!account.isMasterDevice()) { - throw new NotMasterDeviceException(); + ) throws NotPrimaryDeviceException { + if (!account.isPrimaryDevice()) { + throw new NotPrimaryDeviceException(); } final var configurationStore = account.getConfigurationStore(); @@ -357,52 +275,49 @@ public class ManagerImpl implements Manager { if (configuration.linkPreviews().isPresent()) { configurationStore.setLinkPreviews(configuration.linkPreviews().get()); } - syncHelper.sendConfigurationMessage(); + context.getSyncHelper().sendConfigurationMessage(); } - /** - * @param givenName if null, the previous givenName will be kept - * @param familyName if null, the previous familyName will be kept - * @param about if null, the previous about text will be kept - * @param aboutEmoji if null, the previous about emoji will be kept - * @param avatar if avatar is null the image from the local avatar store is used (if present), - */ @Override - public void setProfile( - String givenName, final String familyName, String about, String aboutEmoji, java.util.Optional avatar - ) throws IOException { - profileHelper.setProfile(givenName, - familyName, - about, - aboutEmoji, - avatar == null ? null : Optional.fromNullable(avatar.orElse(null))); - syncHelper.sendSyncFetchProfileMessage(); + public void updateProfile(UpdateProfile updateProfile) throws IOException { + context.getProfileHelper() + .setProfile(updateProfile.getGivenName(), + updateProfile.getFamilyName(), + updateProfile.getAbout(), + updateProfile.getAboutEmoji(), + updateProfile.isDeleteAvatar() + ? Optional.empty() + : updateProfile.getAvatar() == null ? null : Optional.of(updateProfile.getAvatar()), + updateProfile.getMobileCoinAddress()); + context.getSyncHelper().sendSyncFetchProfileMessage(); } - @Override - public void unregister() throws IOException { - // When setting an empty GCM id, the Signal-Server also sets the fetchesMessages property to false. - // If this is the master device, other users can't send messages to this number anymore. - // If this is a linked device, other users can still send messages, but this device doesn't receive them anymore. - dependencies.getAccountManager().setGcmId(Optional.absent()); - - account.setRegistered(false); - close(); + void refreshCurrentUsername() throws IOException, BaseUsernameException { + context.getAccountHelper().refreshCurrentUsername(); } @Override - public void deleteAccount() throws IOException { + public String setUsername(final String username) throws IOException, InvalidUsernameException { try { - pinHelper.removeRegistrationLockPin(); - } catch (IOException e) { - logger.warn("Failed to remove registration lock pin"); + return context.getAccountHelper().reserveUsername(username); + } catch (BaseUsernameException e) { + throw new InvalidUsernameException(e.getMessage() + " (" + e.getClass().getSimpleName() + ")", e); } - account.setRegistrationLockPin(null, null); + } - dependencies.getAccountManager().deleteAccount(); + @Override + public void deleteUsername() throws IOException { + context.getAccountHelper().deleteUsername(); + } - account.setRegistered(false); - close(); + @Override + public void unregister() throws IOException { + context.getAccountHelper().unregister(); + } + + @Override + public void deleteAccount() throws IOException { + context.getAccountHelper().deleteAccount(); } @Override @@ -416,7 +331,7 @@ public class ManagerImpl implements Manager { public List getLinkedDevices() throws IOException { var devices = dependencies.getAccountManager().getDevices(); account.setMultiDevice(devices.size() > 1); - var identityKey = account.getIdentityKeyPair().getPrivateKey(); + var identityKey = account.getAciIdentityKeyPair().getPrivateKey(); return devices.stream().map(d -> { String deviceName = d.getName(); if (deviceName != null) { @@ -431,79 +346,44 @@ public class ManagerImpl implements Manager { d.getCreated(), d.getLastSeen(), d.getId() == account.getDeviceId()); - }).collect(Collectors.toList()); + }).toList(); } @Override - public void removeLinkedDevices(long deviceId) throws IOException { - dependencies.getAccountManager().removeDevice(deviceId); - var devices = dependencies.getAccountManager().getDevices(); - account.setMultiDevice(devices.size() > 1); + public void removeLinkedDevices(int deviceId) throws IOException { + context.getAccountHelper().removeLinkedDevices(deviceId); } @Override public void addDeviceLink(URI linkUri) throws IOException, InvalidDeviceLinkException { - var info = DeviceLinkInfo.parseDeviceLinkUri(linkUri); - - addDevice(info.deviceIdentifier(), info.deviceKey()); - } - - private void addDevice( - String deviceIdentifier, ECPublicKey deviceKey - ) throws IOException, InvalidDeviceLinkException { - var identityKeyPair = account.getIdentityKeyPair(); - var verificationCode = dependencies.getAccountManager().getNewDeviceVerificationCode(); - - try { - dependencies.getAccountManager() - .addDevice(deviceIdentifier, - deviceKey, - identityKeyPair, - Optional.of(account.getProfileKey().serialize()), - verificationCode); - } catch (InvalidKeyException e) { - throw new InvalidDeviceLinkException("Invalid device link", e); - } - account.setMultiDevice(true); + var deviceLinkInfo = DeviceLinkInfo.parseDeviceLinkUri(linkUri); + context.getAccountHelper().addDevice(deviceLinkInfo); } @Override - public void setRegistrationLockPin(java.util.Optional pin) throws IOException { - if (!account.isMasterDevice()) { - throw new RuntimeException("Only master device can set a PIN"); + public void setRegistrationLockPin(Optional pin) throws IOException, NotPrimaryDeviceException { + if (!account.isPrimaryDevice()) { + throw new NotPrimaryDeviceException(); } if (pin.isPresent()) { - final var masterKey = account.getPinMasterKey() != null - ? account.getPinMasterKey() - : KeyUtils.createMasterKey(); - - pinHelper.setRegistrationLockPin(pin.get(), masterKey); - - account.setRegistrationLockPin(pin.get(), masterKey); + context.getAccountHelper().setRegistrationPin(pin.get()); } else { - // Remove KBS Pin - pinHelper.removeRegistrationLockPin(); - - account.setRegistrationLockPin(null, null); + context.getAccountHelper().removeRegistrationPin(); } } void refreshPreKeys() throws IOException { - preKeyHelper.refreshPreKeys(); + context.getPreKeyHelper().refreshPreKeys(); } @Override - public Profile getRecipientProfile(RecipientIdentifier.Single recipient) throws IOException { - return profileHelper.getRecipientProfile(resolveRecipient(recipient)); - } - - private Profile getRecipientProfile(RecipientId recipientId) { - return profileHelper.getRecipientProfile(recipientId); + public Profile getRecipientProfile(RecipientIdentifier.Single recipient) throws UnregisteredRecipientException { + return context.getProfileHelper().getRecipientProfile(context.getRecipientHelper().resolveRecipient(recipient)); } @Override public List getGroups() { - return account.getGroupStore().getGroups().stream().map(this::toGroup).collect(Collectors.toList()); + return account.getGroupStore().getGroups().stream().map(this::toGroup).toList(); } private Group toGroup(final GroupInfo groupInfo) { @@ -511,186 +391,327 @@ public class ManagerImpl implements Manager { return null; } - return new Group(groupInfo.getGroupId(), - groupInfo.getTitle(), - groupInfo.getDescription(), - groupInfo.getGroupInviteLink(), - groupInfo.getMembers() - .stream() - .map(account.getRecipientStore()::resolveRecipientAddress) - .collect(Collectors.toSet()), - groupInfo.getPendingMembers() - .stream() - .map(account.getRecipientStore()::resolveRecipientAddress) - .collect(Collectors.toSet()), - groupInfo.getRequestingMembers() - .stream() - .map(account.getRecipientStore()::resolveRecipientAddress) - .collect(Collectors.toSet()), - groupInfo.getAdminMembers() - .stream() - .map(account.getRecipientStore()::resolveRecipientAddress) - .collect(Collectors.toSet()), - groupInfo.isBlocked(), - groupInfo.getMessageExpirationTimer(), - groupInfo.getPermissionAddMember(), - groupInfo.getPermissionEditDetails(), - groupInfo.getPermissionSendMessage(), - groupInfo.isMember(account.getSelfRecipientId()), - groupInfo.isAdmin(account.getSelfRecipientId())); + return Group.from(groupInfo, account.getRecipientAddressResolver(), account.getSelfRecipientId()); } @Override public SendGroupMessageResults quitGroup( GroupId groupId, Set groupAdmins - ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException { - final var newAdmins = resolveRecipients(groupAdmins); - return groupHelper.quitGroup(groupId, newAdmins); + ) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException, UnregisteredRecipientException { + final var newAdmins = context.getRecipientHelper().resolveRecipients(groupAdmins); + return context.getGroupHelper().quitGroup(groupId, newAdmins); } @Override public void deleteGroup(GroupId groupId) throws IOException { - groupHelper.deleteGroup(groupId); + final var group = context.getGroupHelper().getGroup(groupId); + if (group.isMember(account.getSelfRecipientId())) { + throw new IOException( + "The local group information cannot be removed, as the user is still a member of the group"); + } + context.getGroupHelper().deleteGroup(groupId); } @Override public Pair createGroup( - String name, Set members, File avatarFile - ) throws IOException, AttachmentInvalidException { - return groupHelper.createGroup(name, members == null ? null : resolveRecipients(members), avatarFile); + String name, Set members, String avatarFile + ) throws IOException, AttachmentInvalidException, UnregisteredRecipientException { + return context.getGroupHelper() + .createGroup(name, + members == null ? null : context.getRecipientHelper().resolveRecipients(members), + avatarFile); } @Override public SendGroupMessageResults updateGroup( final GroupId groupId, final UpdateGroup updateGroup - ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException { - return groupHelper.updateGroup(groupId, - updateGroup.getName(), - updateGroup.getDescription(), - updateGroup.getMembers() == null ? null : resolveRecipients(updateGroup.getMembers()), - updateGroup.getRemoveMembers() == null ? null : resolveRecipients(updateGroup.getRemoveMembers()), - updateGroup.getAdmins() == null ? null : resolveRecipients(updateGroup.getAdmins()), - updateGroup.getRemoveAdmins() == null ? null : resolveRecipients(updateGroup.getRemoveAdmins()), - updateGroup.isResetGroupLink(), - updateGroup.getGroupLinkState(), - updateGroup.getAddMemberPermission(), - updateGroup.getEditDetailsPermission(), - updateGroup.getAvatarFile(), - updateGroup.getExpirationTimer(), - updateGroup.getIsAnnouncementGroup()); + ) throws IOException, GroupNotFoundException, AttachmentInvalidException, NotAGroupMemberException, GroupSendingNotAllowedException, UnregisteredRecipientException { + return context.getGroupHelper() + .updateGroup(groupId, + updateGroup.getName(), + updateGroup.getDescription(), + updateGroup.getMembers() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getMembers()), + updateGroup.getRemoveMembers() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveMembers()), + updateGroup.getAdmins() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getAdmins()), + updateGroup.getRemoveAdmins() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getRemoveAdmins()), + updateGroup.getBanMembers() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getBanMembers()), + updateGroup.getUnbanMembers() == null + ? null + : context.getRecipientHelper().resolveRecipients(updateGroup.getUnbanMembers()), + updateGroup.isResetGroupLink(), + updateGroup.getGroupLinkState(), + updateGroup.getAddMemberPermission(), + updateGroup.getEditDetailsPermission(), + updateGroup.getAvatarFile(), + updateGroup.getExpirationTimer(), + updateGroup.getIsAnnouncementGroup()); } @Override public Pair joinGroup( GroupInviteLinkUrl inviteLinkUrl - ) throws IOException, InactiveGroupLinkException { - return groupHelper.joinGroup(inviteLinkUrl); + ) throws IOException, InactiveGroupLinkException, PendingAdminApprovalException { + return context.getGroupHelper().joinGroup(inviteLinkUrl); } private SendMessageResults sendMessage( SignalServiceDataMessage.Builder messageBuilder, Set recipients + ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { + return sendMessage(messageBuilder, recipients, Optional.empty()); + } + + private SendMessageResults sendMessage( + SignalServiceDataMessage.Builder messageBuilder, + Set recipients, + Optional editTargetTimestamp ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { var results = new HashMap>(); long timestamp = System.currentTimeMillis(); messageBuilder.withTimestamp(timestamp); for (final var recipient : recipients) { if (recipient instanceof RecipientIdentifier.Single single) { - final var recipientId = resolveRecipient(single); - final var result = sendHelper.sendMessage(messageBuilder, recipientId); - results.put(recipient, - List.of(SendMessageResult.from(result, - account.getRecipientStore(), - account.getRecipientStore()::resolveRecipientAddress))); + try { + final var recipientId = context.getRecipientHelper().resolveRecipient(single); + final var result = context.getSendHelper() + .sendMessage(messageBuilder, recipientId, editTargetTimestamp); + results.put(recipient, List.of(toSendMessageResult(result))); + } catch (UnregisteredRecipientException e) { + results.put(recipient, + List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress()))); + } } else if (recipient instanceof RecipientIdentifier.NoteToSelf) { - final var result = sendHelper.sendSelfMessage(messageBuilder); - results.put(recipient, - List.of(SendMessageResult.from(result, - account.getRecipientStore(), - account.getRecipientStore()::resolveRecipientAddress))); + final var result = context.getSendHelper().sendSelfMessage(messageBuilder, editTargetTimestamp); + results.put(recipient, List.of(toSendMessageResult(result))); } else if (recipient instanceof RecipientIdentifier.Group group) { - final var result = sendHelper.sendAsGroupMessage(messageBuilder, group.groupId()); - results.put(recipient, - result.stream() - .map(sendMessageResult -> SendMessageResult.from(sendMessageResult, - account.getRecipientStore(), - account.getRecipientStore()::resolveRecipientAddress)) - .collect(Collectors.toList())); + final var result = context.getSendHelper() + .sendAsGroupMessage(messageBuilder, group.groupId(), editTargetTimestamp); + results.put(recipient, result.stream().map(this::toSendMessageResult).toList()); } } return new SendMessageResults(timestamp, results); } - private void sendTypingMessage( + private SendMessageResult toSendMessageResult(final org.whispersystems.signalservice.api.messages.SendMessageResult result) { + return SendMessageResult.from(result, account.getRecipientResolver(), account.getRecipientAddressResolver()); + } + + private SendMessageResults sendTypingMessage( SignalServiceTypingMessage.Action action, Set recipients - ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { + ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { + var results = new HashMap>(); final var timestamp = System.currentTimeMillis(); for (var recipient : recipients) { - if (recipient instanceof RecipientIdentifier.Single) { - final var message = new SignalServiceTypingMessage(action, timestamp, Optional.absent()); - final var recipientId = resolveRecipient((RecipientIdentifier.Single) recipient); - sendHelper.sendTypingMessage(message, recipientId); + if (recipient instanceof RecipientIdentifier.Single single) { + final var message = new SignalServiceTypingMessage(action, timestamp, Optional.empty()); + try { + final var recipientId = context.getRecipientHelper().resolveRecipient(single); + final var result = context.getSendHelper().sendTypingMessage(message, recipientId); + results.put(recipient, List.of(toSendMessageResult(result))); + } catch (UnregisteredRecipientException e) { + results.put(recipient, + List.of(SendMessageResult.unregisteredFailure(single.toPartialRecipientAddress()))); + } } else if (recipient instanceof RecipientIdentifier.Group) { final var groupId = ((RecipientIdentifier.Group) recipient).groupId(); final var message = new SignalServiceTypingMessage(action, timestamp, Optional.of(groupId.serialize())); - sendHelper.sendGroupTypingMessage(message, groupId); + final var result = context.getSendHelper().sendGroupTypingMessage(message, groupId); + results.put(recipient, result.stream().map(this::toSendMessageResult).toList()); } } + return new SendMessageResults(timestamp, results); } @Override - public void sendTypingMessage( + public SendMessageResults sendTypingMessage( TypingAction action, Set recipients - ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { - sendTypingMessage(action.toSignalService(), recipients); + ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { + return sendTypingMessage(action.toSignalService(), recipients); } @Override - public void sendReadReceipt( + public SendMessageResults sendReadReceipt( RecipientIdentifier.Single sender, List messageIds - ) throws IOException, UntrustedIdentityException { + ) { + final var timestamp = System.currentTimeMillis(); var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.READ, messageIds, - System.currentTimeMillis()); + timestamp); - sendHelper.sendReceiptMessage(receiptMessage, resolveRecipient(sender)); + return sendReceiptMessage(sender, timestamp, receiptMessage); } @Override - public void sendViewedReceipt( + public SendMessageResults sendViewedReceipt( RecipientIdentifier.Single sender, List messageIds - ) throws IOException, UntrustedIdentityException { + ) { + final var timestamp = System.currentTimeMillis(); var receiptMessage = new SignalServiceReceiptMessage(SignalServiceReceiptMessage.Type.VIEWED, messageIds, - System.currentTimeMillis()); + timestamp); + + return sendReceiptMessage(sender, timestamp, receiptMessage); + } - sendHelper.sendReceiptMessage(receiptMessage, resolveRecipient(sender)); + private SendMessageResults sendReceiptMessage( + final RecipientIdentifier.Single sender, + final long timestamp, + final SignalServiceReceiptMessage receiptMessage + ) { + try { + final var result = context.getSendHelper() + .sendReceiptMessage(receiptMessage, context.getRecipientHelper().resolveRecipient(sender)); + return new SendMessageResults(timestamp, Map.of(sender, List.of(toSendMessageResult(result)))); + } catch (UnregisteredRecipientException e) { + return new SendMessageResults(timestamp, + Map.of(sender, List.of(SendMessageResult.unregisteredFailure(sender.toPartialRecipientAddress())))); + } } @Override public SendMessageResults sendMessage( Message message, Set recipients - ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { + ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException { + final var selfProfile = context.getProfileHelper().getSelfProfile(); + if (selfProfile == null || selfProfile.getDisplayName().isEmpty()) { + logger.warn( + "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."); + } final var messageBuilder = SignalServiceDataMessage.newBuilder(); applyMessage(messageBuilder, message); return sendMessage(messageBuilder, recipients); } + @Override + public SendMessageResults sendEditMessage( + Message message, Set recipients, long editTargetTimestamp + ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException { + final var messageBuilder = SignalServiceDataMessage.newBuilder(); + applyMessage(messageBuilder, message); + return sendMessage(messageBuilder, recipients, Optional.of(editTargetTimestamp)); + } + private void applyMessage( final SignalServiceDataMessage.Builder messageBuilder, final Message message - ) throws AttachmentInvalidException, IOException { - messageBuilder.withBody(message.messageText()); - final var attachments = message.attachments(); - if (attachments != null) { - messageBuilder.withAttachments(attachmentHelper.uploadAttachments(attachments)); + ) throws AttachmentInvalidException, IOException, UnregisteredRecipientException, InvalidStickerException { + if (message.messageText().length() > 2000) { + final var messageBytes = message.messageText().getBytes(StandardCharsets.UTF_8); + final var textAttachment = AttachmentUtils.createAttachmentStream(new StreamDetails(new ByteArrayInputStream( + messageBytes), MimeUtils.LONG_TEXT, messageBytes.length), Optional.empty()); + messageBuilder.withBody(message.messageText().substring(0, 2000)); + messageBuilder.withAttachment(context.getAttachmentHelper().uploadAttachment(textAttachment)); + } else { + messageBuilder.withBody(message.messageText()); + } + if (message.attachments().size() > 0) { + messageBuilder.withAttachments(context.getAttachmentHelper().uploadAttachments(message.attachments())); + } + if (message.mentions().size() > 0) { + messageBuilder.withMentions(resolveMentions(message.mentions())); + } + if (message.quote().isPresent()) { + final var quote = message.quote().get(); + messageBuilder.withQuote(new SignalServiceDataMessage.Quote(quote.timestamp(), + context.getRecipientHelper() + .resolveSignalServiceAddress(context.getRecipientHelper().resolveRecipient(quote.author())) + .getServiceId(), + quote.message(), + List.of(), + resolveMentions(quote.mentions()), + SignalServiceDataMessage.Quote.Type.NORMAL, + List.of())); + } + if (message.sticker().isPresent()) { + final var sticker = message.sticker().get(); + final var packId = StickerPackId.deserialize(sticker.packId()); + final var stickerId = sticker.stickerId(); + + final var stickerPack = context.getAccount().getStickerStore().getStickerPack(packId); + if (stickerPack == null) { + throw new InvalidStickerException("Sticker pack not found"); + } + final var manifest = context.getStickerHelper().getOrRetrieveStickerPack(packId, stickerPack.packKey()); + if (manifest.stickers().size() <= stickerId) { + throw new InvalidStickerException("Sticker id not part of this pack"); + } + final var manifestSticker = manifest.stickers().get(stickerId); + final var streamDetails = context.getStickerPackStore().retrieveSticker(packId, stickerId); + if (streamDetails == null) { + throw new InvalidStickerException("Missing local sticker file"); + } + messageBuilder.withSticker(new SignalServiceDataMessage.Sticker(packId.serialize(), + stickerPack.packKey(), + stickerId, + manifestSticker.emoji(), + AttachmentUtils.createAttachmentStream(streamDetails, Optional.empty()))); + } + if (message.previews().size() > 0) { + final var previews = new ArrayList(message.previews().size()); + for (final var p : message.previews()) { + final var image = p.image().isPresent() ? context.getAttachmentHelper() + .uploadAttachment(p.image().get()) : null; + previews.add(new SignalServicePreview(p.url(), + p.title(), + p.description(), + 0, + Optional.ofNullable(image))); + } + messageBuilder.withPreviews(previews); + } + if (message.storyReply().isPresent()) { + final var storyReply = message.storyReply().get(); + final var authorServiceId = context.getRecipientHelper() + .resolveSignalServiceAddress(context.getRecipientHelper().resolveRecipient(storyReply.author())) + .getServiceId(); + messageBuilder.withStoryContext(new SignalServiceDataMessage.StoryContext(authorServiceId, + storyReply.timestamp())); } } + private ArrayList resolveMentions(final List mentionList) throws UnregisteredRecipientException { + final var mentions = new ArrayList(); + for (final var m : mentionList) { + final var recipientId = context.getRecipientHelper().resolveRecipient(m.recipient()); + mentions.add(new SignalServiceDataMessage.Mention(context.getRecipientHelper() + .resolveSignalServiceAddress(recipientId) + .getServiceId(), m.start(), m.length())); + } + return mentions; + } + @Override public SendMessageResults sendRemoteDeleteMessage( long targetSentTimestamp, Set recipients ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { var delete = new SignalServiceDataMessage.RemoteDelete(targetSentTimestamp); final var messageBuilder = SignalServiceDataMessage.newBuilder().withRemoteDelete(delete); + for (final var recipient : recipients) { + if (recipient instanceof RecipientIdentifier.Uuid u) { + account.getMessageSendLogStore() + .deleteEntryForRecipientNonGroup(targetSentTimestamp, ServiceId.from(u.uuid())); + } else if (recipient instanceof RecipientIdentifier.Single r) { + try { + final var recipientId = context.getRecipientHelper().resolveRecipient(r); + final var address = account.getRecipientAddressResolver().resolveRecipientAddress(recipientId); + if (address.serviceId().isPresent()) { + account.getMessageSendLogStore() + .deleteEntryForRecipientNonGroup(targetSentTimestamp, address.serviceId().get()); + } + } catch (UnregisteredRecipientException ignored) { + } + } else if (recipient instanceof RecipientIdentifier.Group r) { + account.getMessageSendLogStore().deleteEntryForGroup(targetSentTimestamp, r.groupId()); + } + } return sendMessage(messageBuilder, recipients); } @@ -700,17 +721,36 @@ public class ManagerImpl implements Manager { boolean remove, RecipientIdentifier.Single targetAuthor, long targetSentTimestamp, - Set recipients - ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException { - var targetAuthorRecipientId = resolveRecipient(targetAuthor); - var reaction = new SignalServiceDataMessage.Reaction(emoji, - remove, - resolveSignalServiceAddress(targetAuthorRecipientId), - targetSentTimestamp); + Set recipients, + final boolean isStory + ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException { + var targetAuthorRecipientId = context.getRecipientHelper().resolveRecipient(targetAuthor); + final var authorServiceId = context.getRecipientHelper() + .resolveSignalServiceAddress(targetAuthorRecipientId) + .getServiceId(); + var reaction = new SignalServiceDataMessage.Reaction(emoji, remove, authorServiceId, targetSentTimestamp); final var messageBuilder = SignalServiceDataMessage.newBuilder().withReaction(reaction); + if (isStory) { + messageBuilder.withStoryContext(new SignalServiceDataMessage.StoryContext(authorServiceId, + targetSentTimestamp)); + } return sendMessage(messageBuilder, recipients); } + @Override + public SendMessageResults sendPaymentNotificationMessage( + byte[] receipt, String note, RecipientIdentifier.Single recipient + ) throws IOException { + final var paymentNotification = new SignalServiceDataMessage.PaymentNotification(receipt, note); + final var payment = new SignalServiceDataMessage.Payment(paymentNotification, null); + final var messageBuilder = SignalServiceDataMessage.newBuilder().withPayment(payment); + try { + return sendMessage(messageBuilder, Set.of(recipient)); + } catch (NotAGroupMemberException | GroupNotFoundException | GroupSendingNotAllowedException e) { + throw new AssertionError(e); + } + } + @Override public SendMessageResults sendEndSessionMessage(Set recipients) throws IOException { var messageBuilder = SignalServiceDataMessage.newBuilder().asEndSessionMessage(); @@ -722,55 +762,112 @@ public class ManagerImpl implements Manager { throw new AssertionError(e); } finally { for (var recipient : recipients) { - final var recipientId = resolveRecipient(recipient); - account.getSessionStore().deleteAllSessions(recipientId); + final RecipientId recipientId; + try { + recipientId = context.getRecipientHelper().resolveRecipient(recipient); + } catch (UnregisteredRecipientException e) { + continue; + } + final var serviceId = context.getAccount() + .getRecipientAddressResolver() + .resolveRecipientAddress(recipientId) + .serviceId(); + if (serviceId.isPresent()) { + account.getAciSessionStore().deleteAllSessions(serviceId.get()); + } } } } + @Override + public void deleteRecipient(final RecipientIdentifier.Single recipient) { + final var recipientIdOptional = context.getRecipientHelper().resolveRecipientOptional(recipient); + if (recipientIdOptional.isPresent()) { + account.removeRecipient(recipientIdOptional.get()); + } + } + + @Override + public void deleteContact(final RecipientIdentifier.Single recipient) { + final var recipientIdOptional = context.getRecipientHelper().resolveRecipientOptional(recipient); + if (recipientIdOptional.isPresent()) { + account.getContactStore().deleteContact(recipientIdOptional.get()); + } + } + @Override public void setContactName( - RecipientIdentifier.Single recipient, String name - ) throws NotMasterDeviceException, IOException { - if (!account.isMasterDevice()) { - throw new NotMasterDeviceException(); + RecipientIdentifier.Single recipient, String givenName, final String familyName + ) throws NotPrimaryDeviceException, UnregisteredRecipientException { + if (!account.isPrimaryDevice()) { + throw new NotPrimaryDeviceException(); } - contactHelper.setContactName(resolveRecipient(recipient), name); + context.getContactHelper() + .setContactName(context.getRecipientHelper().resolveRecipient(recipient), givenName, familyName); } @Override - public void setContactBlocked( - RecipientIdentifier.Single recipient, boolean blocked - ) throws NotMasterDeviceException, IOException { - if (!account.isMasterDevice()) { - throw new NotMasterDeviceException(); + public void setContactsBlocked( + Collection recipients, boolean blocked + ) throws NotPrimaryDeviceException, IOException, UnregisteredRecipientException { + if (!account.isPrimaryDevice()) { + throw new NotPrimaryDeviceException(); + } + if (recipients.size() == 0) { + return; + } + final var recipientIds = context.getRecipientHelper().resolveRecipients(recipients); + final var selfRecipientId = account.getSelfRecipientId(); + boolean shouldRotateProfileKey = false; + for (final var recipientId : recipientIds) { + if (context.getContactHelper().isContactBlocked(recipientId) == blocked) { + continue; + } + context.getContactHelper().setContactBlocked(recipientId, blocked); + // if we don't have a common group with the blocked contact we need to rotate the profile key + shouldRotateProfileKey = blocked && ( + shouldRotateProfileKey || account.getGroupStore() + .getGroups() + .stream() + .noneMatch(g -> g.isMember(selfRecipientId) && g.isMember(recipientId)) + ); + } + if (shouldRotateProfileKey) { + context.getProfileHelper().rotateProfileKey(); } - contactHelper.setContactBlocked(resolveRecipient(recipient), blocked); - // TODO cycle our profile key - syncHelper.sendBlockedList(); + context.getSyncHelper().sendBlockedList(); } @Override - public void setGroupBlocked( - final GroupId groupId, final boolean blocked - ) throws GroupNotFoundException, IOException, NotMasterDeviceException { - if (!account.isMasterDevice()) { - throw new NotMasterDeviceException(); + public void setGroupsBlocked( + final Collection groupIds, final boolean blocked + ) throws GroupNotFoundException, NotPrimaryDeviceException, IOException { + if (!account.isPrimaryDevice()) { + throw new NotPrimaryDeviceException(); } - groupHelper.setGroupBlocked(groupId, blocked); - // TODO cycle our profile key - syncHelper.sendBlockedList(); + if (groupIds.size() == 0) { + return; + } + boolean shouldRotateProfileKey = false; + for (final var groupId : groupIds) { + if (context.getGroupHelper().isGroupBlocked(groupId) == blocked) { + continue; + } + context.getGroupHelper().setGroupBlocked(groupId, blocked); + shouldRotateProfileKey = blocked; + } + if (shouldRotateProfileKey) { + context.getProfileHelper().rotateProfileKey(); + } + context.getSyncHelper().sendBlockedList(); } - /** - * Change the expiration timer for a contact - */ @Override public void setExpirationTimer( RecipientIdentifier.Single recipient, int messageExpirationTimer - ) throws IOException { - var recipientId = resolveRecipient(recipient); - contactHelper.setExpirationTimer(recipientId, messageExpirationTimer); + ) throws IOException, UnregisteredRecipientException { + var recipientId = context.getRecipientHelper().resolveRecipient(recipient); + context.getContactHelper().setExpirationTimer(recipientId, messageExpirationTimer); final var messageBuilder = SignalServiceDataMessage.newBuilder().asExpirationUpdate(); try { sendMessage(messageBuilder, Set.of(recipient)); @@ -779,14 +876,8 @@ public class ManagerImpl implements Manager { } } - /** - * Upload the sticker pack from path. - * - * @param path Path can be a path to a manifest.json file or to a zip file that contains a manifest.json file - * @return if successful, returns the URL to install the sticker pack in the signal app - */ @Override - public URI uploadStickerPack(File path) throws IOException, StickerPackInvalidException { + public StickerPackUrl uploadStickerPack(File path) throws IOException, StickerPackInvalidException { var manifest = StickerUtils.getSignalServiceStickerManifestUpload(path); var messageSender = dependencies.getMessageSender(); @@ -795,127 +886,47 @@ public class ManagerImpl implements Manager { var packIdString = messageSender.uploadStickerManifest(manifest, packKey); var packId = StickerPackId.deserialize(Hex.fromStringCondensed(packIdString)); - var sticker = new Sticker(packId, packKey); - account.getStickerStore().updateSticker(sticker); + var sticker = new StickerPack(packId, packKey); + account.getStickerStore().addStickerPack(sticker); - try { - return new URI("https", - "signal.art", - "/addstickers/", - "pack_id=" - + URLEncoder.encode(Hex.toStringCondensed(packId.serialize()), StandardCharsets.UTF_8) - + "&pack_key=" - + URLEncoder.encode(Hex.toStringCondensed(packKey), StandardCharsets.UTF_8)); - } catch (URISyntaxException e) { - throw new AssertionError(e); - } + return new StickerPackUrl(packId, packKey); } @Override - public void requestAllSyncData() throws IOException { - syncHelper.requestAllSyncData(); - retrieveRemoteStorage(); - } - - void retrieveRemoteStorage() throws IOException { - if (account.getStorageKey() != null) { - storageHelper.readDataFromStorage(); - } - } - - private RecipientId refreshRegisteredUser(RecipientId recipientId) throws IOException { - final var address = resolveSignalServiceAddress(recipientId); - if (!address.getNumber().isPresent()) { - return recipientId; - } - final var number = address.getNumber().get(); - final var uuid = getRegisteredUser(number); - return resolveRecipientTrusted(new SignalServiceAddress(uuid, number)); - } - - private ACI getRegisteredUser(final String number) throws IOException { - final Map aciMap; - try { - aciMap = getRegisteredUsers(Set.of(number)); - } catch (NumberFormatException e) { - throw new IOException(number, e); - } - final var uuid = aciMap.get(number); - if (uuid == null) { - throw new IOException(number, null); - } - return uuid; - } - - private Map getRegisteredUsers(final Set numbers) throws IOException { - final Map registeredUsers; - try { - registeredUsers = dependencies.getAccountManager() - .getRegisteredUsers(ServiceConfig.getIasKeyStore(), - numbers, - serviceEnvironmentConfig.getCdsMrenclave()); - } catch (Quote.InvalidQuoteFormatException | UnauthenticatedQuoteException | SignatureException | UnauthenticatedResponseException | InvalidKeyException e) { - throw new IOException(e); - } - - // Store numbers as recipients, so we have the number/uuid association - registeredUsers.forEach((number, aci) -> resolveRecipientTrusted(new SignalServiceAddress(aci, number))); + public List getStickerPacks() { + final var stickerPackStore = context.getStickerPackStore(); + return account.getStickerStore().getStickerPacks().stream().map(pack -> { + if (stickerPackStore.existsStickerPack(pack.packId())) { + try { + final var manifest = stickerPackStore.retrieveManifest(pack.packId()); + return new org.asamk.signal.manager.api.StickerPack(pack.packId(), + new StickerPackUrl(pack.packId(), pack.packKey()), + pack.isInstalled(), + manifest.title(), + manifest.author(), + Optional.ofNullable(manifest.cover() == null ? null : manifest.cover().toApi()), + manifest.stickers().stream().map(JsonStickerPack.JsonSticker::toApi).toList()); + } catch (Exception e) { + logger.warn("Failed to read local sticker pack manifest: {}", e.getMessage(), e); + } + } - return registeredUsers; + return new org.asamk.signal.manager.api.StickerPack(pack.packId(), pack.packKey(), pack.isInstalled()); + }).toList(); } - private void retryFailedReceivedMessages(ReceiveMessageHandler handler) { - Set queuedActions = new HashSet<>(); - for (var cachedMessage : account.getMessageCache().getCachedMessages()) { - var actions = retryFailedReceivedMessage(handler, cachedMessage); - if (actions != null) { - queuedActions.addAll(actions); - } - } - handleQueuedActions(queuedActions); + @Override + public void requestAllSyncData() throws IOException { + context.getSyncHelper().requestAllSyncData(); + retrieveRemoteStorage(); } - private List retryFailedReceivedMessage( - final ReceiveMessageHandler handler, final CachedMessage cachedMessage - ) { - var envelope = cachedMessage.loadEnvelope(); - if (envelope == null) { - cachedMessage.delete(); - return null; - } - - final var result = incomingMessageHandler.handleRetryEnvelope(envelope, ignoreAttachments, handler); - final var actions = result.first(); - final var exception = result.second(); - - if (exception instanceof UntrustedIdentityException) { - if (System.currentTimeMillis() - envelope.getServerDeliveredTimestamp() > 1000L * 60 * 60 * 24 * 30) { - // Envelope is more than a month old, cleaning up. - cachedMessage.delete(); - return null; - } - if (!envelope.hasSourceUuid()) { - final var identifier = ((UntrustedIdentityException) exception).getSender(); - final var recipientId = account.getRecipientStore().resolveRecipient(identifier); - try { - account.getMessageCache().replaceSender(cachedMessage, recipientId); - } catch (IOException ioException) { - logger.warn("Failed to move cached message to recipient folder: {}", ioException.getMessage()); - } - } - return null; - } - - // If successful and for all other errors that are not recoverable, delete the cached message - cachedMessage.delete(); - return actions; + void retrieveRemoteStorage() throws IOException { + context.getStorageHelper().readDataFromStorage(); } @Override public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) { - if (isReceivingSynchronous) { - throw new IllegalStateException("Already receiving message synchronously."); - } synchronized (messageHandlers) { if (isWeakListener) { weakHandlers.add(handler); @@ -926,32 +937,16 @@ public class ManagerImpl implements Manager { } } + private static final AtomicInteger threadNumber = new AtomicInteger(0); + private void startReceiveThreadIfRequired() { - if (receiveThread != null) { + if (receiveThread != null || isReceivingSynchronous) { return; } receiveThread = new Thread(() -> { logger.debug("Starting receiving messages"); - while (!Thread.interrupted()) { - try { - receiveMessagesInternal(1L, TimeUnit.HOURS, false, (envelope, e) -> { - synchronized (messageHandlers) { - Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> { - try { - h.handleMessage(envelope, e); - } catch (Exception ex) { - logger.warn("Message handler failed, ignoring", ex); - } - }); - } - }); - break; - } catch (IOException e) { - logger.warn("Receiving messages failed, retrying", e); - } - } + context.getReceiveHelper().receiveMessagesContinuously(this::passReceivedMessageToHandlers); logger.debug("Finished receiving messages"); - hasCaughtUpWithOldMessages = false; synchronized (messageHandlers) { receiveThread = null; @@ -962,10 +957,23 @@ public class ManagerImpl implements Manager { } } }); + receiveThread.setName("receive-" + threadNumber.getAndIncrement()); receiveThread.start(); } + private void passReceivedMessageToHandlers(MessageEnvelope envelope, Throwable e) { + synchronized (messageHandlers) { + Stream.concat(messageHandlers.stream(), weakHandlers.stream()).forEach(h -> { + try { + h.handleMessage(envelope, e); + } catch (Throwable ex) { + logger.warn("Message handler failed, ignoring", ex); + } + }); + } + } + @Override public void removeReceiveHandler(final ReceiveMessageHandler handler) { final Thread thread; @@ -983,7 +991,10 @@ public class ManagerImpl implements Manager { } private void stopReceiveThread(final Thread thread) { - thread.interrupt(); + if (context.getReceiveHelper().requestStopReceiveMessages()) { + logger.debug("Receive stop requested, interrupting read from server."); + thread.interrupt(); + } try { thread.join(); } catch (InterruptedException ignored) { @@ -1001,206 +1012,101 @@ public class ManagerImpl implements Manager { } @Override - public void receiveMessages(long timeout, TimeUnit unit, ReceiveMessageHandler handler) throws IOException { - receiveMessages(timeout, unit, true, handler); - } - - @Override - public void receiveMessages(ReceiveMessageHandler handler) throws IOException { - receiveMessages(1L, TimeUnit.HOURS, false, handler); + public void receiveMessages( + Optional timeout, Optional maxMessages, ReceiveMessageHandler handler + ) throws IOException, AlreadyReceivingException { + receiveMessages(timeout.orElse(Duration.ofMinutes(1)), timeout.isPresent(), maxMessages.orElse(null), handler); } private void receiveMessages( - long timeout, TimeUnit unit, boolean returnOnTimeout, ReceiveMessageHandler handler - ) throws IOException { - if (isReceiving()) { - throw new IllegalStateException("Already receiving message."); + Duration timeout, boolean returnOnTimeout, Integer maxMessages, ReceiveMessageHandler handler + ) throws IOException, AlreadyReceivingException { + synchronized (messageHandlers) { + if (isReceiving()) { + throw new AlreadyReceivingException("Already receiving message."); + } + isReceivingSynchronous = true; + receiveThread = Thread.currentThread(); } - isReceivingSynchronous = true; - receiveThread = Thread.currentThread(); try { - receiveMessagesInternal(timeout, unit, returnOnTimeout, handler); + context.getReceiveHelper().receiveMessages(timeout, returnOnTimeout, maxMessages, (envelope, e) -> { + passReceivedMessageToHandlers(envelope, e); + handler.handleMessage(envelope, e); + }); } finally { - receiveThread = null; - hasCaughtUpWithOldMessages = false; - isReceivingSynchronous = false; - } - } - - private void receiveMessagesInternal( - long timeout, TimeUnit unit, boolean returnOnTimeout, ReceiveMessageHandler handler - ) throws IOException { - retryFailedReceivedMessages(handler); - - // Use a Map here because java Set doesn't have a get method ... - Map queuedActions = new HashMap<>(); - - final var signalWebSocket = dependencies.getSignalWebSocket(); - signalWebSocket.connect(); - - hasCaughtUpWithOldMessages = false; - var backOffCounter = 0; - final var MAX_BACKOFF_COUNTER = 9; - - while (!Thread.interrupted()) { - SignalServiceEnvelope envelope; - final CachedMessage[] cachedMessage = {null}; - account.setLastReceiveTimestamp(System.currentTimeMillis()); - logger.debug("Checking for new message from server"); - try { - var result = signalWebSocket.readOrEmpty(unit.toMillis(timeout), envelope1 -> { - final var recipientId = envelope1.hasSourceUuid() - ? resolveRecipient(envelope1.getSourceAddress()) - : null; - // store message on disk, before acknowledging receipt to the server - cachedMessage[0] = account.getMessageCache().cacheMessage(envelope1, recipientId); - }); - backOffCounter = 0; - - if (result.isPresent()) { - envelope = result.get(); - logger.debug("New message received from server"); - } else { - logger.debug("Received indicator that server queue is empty"); - handleQueuedActions(queuedActions.keySet()); - queuedActions.clear(); - - hasCaughtUpWithOldMessages = true; - synchronized (this) { - this.notifyAll(); - } - - // Continue to wait another timeout for new messages - continue; - } - } catch (AssertionError e) { - if (e.getCause() instanceof InterruptedException) { - Thread.currentThread().interrupt(); - break; - } else { - throw e; - } - } catch (IOException e) { - logger.debug("Pipe unexpectedly unavailable: {}", e.getMessage()); - if (e instanceof WebSocketUnavailableException || "Connection closed!".equals(e.getMessage())) { - final var sleepMilliseconds = 100 * (long) Math.pow(2, backOffCounter); - backOffCounter = Math.min(backOffCounter + 1, MAX_BACKOFF_COUNTER); - logger.warn("Connection closed unexpectedly, reconnecting in {} ms", sleepMilliseconds); - try { - Thread.sleep(sleepMilliseconds); - } catch (InterruptedException interruptedException) { - return; - } - hasCaughtUpWithOldMessages = false; - signalWebSocket.connect(); - continue; - } - throw e; - } catch (TimeoutException e) { - backOffCounter = 0; - if (returnOnTimeout) return; - continue; - } - - final var result = incomingMessageHandler.handleEnvelope(envelope, ignoreAttachments, handler); - for (final var h : result.first()) { - final var existingAction = queuedActions.get(h); - if (existingAction == null) { - queuedActions.put(h, h); - } else { - existingAction.mergeOther(h); - } - } - final var exception = result.second(); - - if (hasCaughtUpWithOldMessages) { - handleQueuedActions(queuedActions.keySet()); - queuedActions.clear(); - } - if (cachedMessage[0] != null) { - if (exception instanceof UntrustedIdentityException) { - logger.debug("Keeping message with untrusted identity in message cache"); - final var address = ((UntrustedIdentityException) exception).getSender(); - final var recipientId = resolveRecipient(address); - if (!envelope.hasSourceUuid()) { - try { - cachedMessage[0] = account.getMessageCache().replaceSender(cachedMessage[0], recipientId); - } catch (IOException ioException) { - logger.warn("Failed to move cached message to recipient folder: {}", - ioException.getMessage()); - } - } - } else { - cachedMessage[0].delete(); + synchronized (messageHandlers) { + receiveThread = null; + isReceivingSynchronous = false; + if (messageHandlers.size() > 0) { + startReceiveThreadIfRequired(); } } } - handleQueuedActions(queuedActions.keySet()); - queuedActions.clear(); - dependencies.getSignalWebSocket().disconnect(); } @Override - public void setIgnoreAttachments(final boolean ignoreAttachments) { - this.ignoreAttachments = ignoreAttachments; + public void setReceiveConfig(final ReceiveConfig receiveConfig) { + context.getReceiveHelper().setReceiveConfig(receiveConfig); } @Override public boolean hasCaughtUpWithOldMessages() { - return hasCaughtUpWithOldMessages; - } - - private void handleQueuedActions(final Collection queuedActions) { - logger.debug("Handling message actions"); - var interrupted = false; - for (var action : queuedActions) { - try { - action.execute(context); - } catch (Throwable e) { - if ((e instanceof AssertionError || e instanceof RuntimeException) - && e.getCause() instanceof InterruptedException) { - interrupted = true; - continue; - } - logger.warn("Message action failed.", e); - } - } - if (interrupted) { - Thread.currentThread().interrupt(); - } + return context.getReceiveHelper().hasCaughtUpWithOldMessages(); } @Override public boolean isContactBlocked(final RecipientIdentifier.Single recipient) { final RecipientId recipientId; try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { + recipientId = context.getRecipientHelper().resolveRecipient(recipient); + } catch (UnregisteredRecipientException e) { return false; } - return contactHelper.isContactBlocked(recipientId); + return context.getContactHelper().isContactBlocked(recipientId); } @Override public void sendContacts() throws IOException { - syncHelper.sendContacts(); + context.getSyncHelper().sendContacts(); } @Override - public List> getContacts() { - return account.getContactStore() - .getContacts() + public List getRecipients( + boolean onlyContacts, + Optional blocked, + Collection recipients, + Optional name + ) { + final var recipientIds = recipients.stream().map(a -> { + try { + return context.getRecipientHelper().resolveRecipient(a); + } catch (UnregisteredRecipientException e) { + return null; + } + }).filter(Objects::nonNull).collect(Collectors.toSet()); + if (!recipients.isEmpty() && recipientIds.isEmpty()) { + return List.of(); + } + // refresh profiles of explicitly given recipients + context.getProfileHelper().refreshRecipientProfiles(recipientIds); + return account.getRecipientStore() + .getRecipients(onlyContacts, blocked, recipientIds, name) .stream() - .map(p -> new Pair<>(account.getRecipientStore().resolveRecipientAddress(p.first()), p.second())) - .collect(Collectors.toList()); + .map(s -> new Recipient(s.getRecipientId(), + s.getAddress().toApiRecipientAddress(), + s.getContact(), + s.getProfileKey(), + s.getExpiringProfileKeyCredential(), + s.getProfile())) + .toList(); } @Override public String getContactOrProfileName(RecipientIdentifier.Single recipient) { final RecipientId recipientId; try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { + recipientId = context.getRecipientHelper().resolveRecipient(recipient); + } catch (UnregisteredRecipientException e) { return null; } @@ -1209,7 +1115,7 @@ public class ManagerImpl implements Manager { return contact.getName(); } - final var profile = getRecipientProfile(recipientId); + final var profile = context.getProfileHelper().getRecipientProfile(recipientId); if (profile != null) { return profile.getDisplayName(); } @@ -1219,20 +1125,12 @@ public class ManagerImpl implements Manager { @Override public Group getGroup(GroupId groupId) { - return toGroup(groupHelper.getGroup(groupId)); - } - - private GroupInfo getGroupInfo(GroupId groupId) { - return groupHelper.getGroup(groupId); + return toGroup(context.getGroupHelper().getGroup(groupId)); } @Override public List getIdentities() { - return account.getIdentityKeyStore() - .getIdentities() - .stream() - .map(this::toIdentity) - .collect(Collectors.toList()); + return account.getIdentityKeyStore().getIdentities().stream().map(this::toIdentity).toList(); } private Identity toIdentity(final IdentityInfo identityInfo) { @@ -1240,167 +1138,96 @@ public class ManagerImpl implements Manager { return null; } - final var address = account.getRecipientStore().resolveRecipientAddress(identityInfo.getRecipientId()); - final var scannableFingerprint = identityHelper.computeSafetyNumberForScanning(identityInfo.getRecipientId(), - identityInfo.getIdentityKey()); - return new Identity(address, + final var address = account.getRecipientAddressResolver() + .resolveRecipientAddress(account.getRecipientResolver().resolveRecipient(identityInfo.getServiceId())); + final var scannableFingerprint = context.getIdentityHelper() + .computeSafetyNumberForScanning(identityInfo.getServiceId(), identityInfo.getIdentityKey()); + return new Identity(address.toApiRecipientAddress(), identityInfo.getIdentityKey(), - identityHelper.computeSafetyNumber(identityInfo.getRecipientId(), identityInfo.getIdentityKey()), + context.getIdentityHelper() + .computeSafetyNumber(identityInfo.getServiceId(), identityInfo.getIdentityKey()), scannableFingerprint == null ? null : scannableFingerprint.getSerialized(), identityInfo.getTrustLevel(), - identityInfo.getDateAdded()); + identityInfo.getDateAddedTimestamp()); } @Override public List getIdentities(RecipientIdentifier.Single recipient) { - IdentityInfo identity; + ServiceId serviceId; try { - identity = account.getIdentityKeyStore().getIdentity(resolveRecipient(recipient)); - } catch (IOException e) { - identity = null; + final var address = account.getRecipientAddressResolver() + .resolveRecipientAddress(context.getRecipientHelper().resolveRecipient(recipient)); + if (address.serviceId().isEmpty()) { + return List.of(); + } + serviceId = address.serviceId().get(); + } catch (UnregisteredRecipientException e) { + return List.of(); } + final var identity = account.getIdentityKeyStore().getIdentityInfo(serviceId); return identity == null ? List.of() : List.of(toIdentity(identity)); } - /** - * Trust this the identity with this fingerprint - * - * @param recipient account of the identity - * @param fingerprint Fingerprint - */ - @Override - public boolean trustIdentityVerified(RecipientIdentifier.Single recipient, byte[] fingerprint) { - RecipientId recipientId; - try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { - return false; - } - return identityHelper.trustIdentityVerified(recipientId, fingerprint); - } - - /** - * Trust this the identity with this safety number - * - * @param recipient account of the identity - * @param safetyNumber Safety number - */ @Override - public boolean trustIdentityVerifiedSafetyNumber(RecipientIdentifier.Single recipient, String safetyNumber) { - RecipientId recipientId; - try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { - return false; - } - return identityHelper.trustIdentityVerifiedSafetyNumber(recipientId, safetyNumber); + public boolean trustIdentityVerified( + RecipientIdentifier.Single recipient, byte[] fingerprint + ) throws UnregisteredRecipientException { + return trustIdentity(recipient, r -> context.getIdentityHelper().trustIdentityVerified(r, fingerprint)); } - /** - * Trust this the identity with this scannable safety number - * - * @param recipient account of the identity - * @param safetyNumber Scannable safety number - */ @Override - public boolean trustIdentityVerifiedSafetyNumber(RecipientIdentifier.Single recipient, byte[] safetyNumber) { - RecipientId recipientId; - try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { - return false; - } - return identityHelper.trustIdentityVerifiedSafetyNumber(recipientId, safetyNumber); + public boolean trustIdentityVerifiedSafetyNumber( + RecipientIdentifier.Single recipient, String safetyNumber + ) throws UnregisteredRecipientException { + return trustIdentity(recipient, + r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber)); } - /** - * Trust all keys of this identity without verification - * - * @param recipient account of the identity - */ @Override - public boolean trustIdentityAllKeys(RecipientIdentifier.Single recipient) { - RecipientId recipientId; - try { - recipientId = resolveRecipient(recipient); - } catch (IOException e) { - return false; - } - return identityHelper.trustIdentityAllKeys(recipientId); + public boolean trustIdentityVerifiedSafetyNumber( + RecipientIdentifier.Single recipient, byte[] safetyNumber + ) throws UnregisteredRecipientException { + return trustIdentity(recipient, + r -> context.getIdentityHelper().trustIdentityVerifiedSafetyNumber(r, safetyNumber)); } @Override - public void addClosedListener(final Runnable listener) { - synchronized (closedListeners) { - closedListeners.add(listener); - } + public boolean trustIdentityAllKeys(RecipientIdentifier.Single recipient) throws UnregisteredRecipientException { + return trustIdentity(recipient, r -> context.getIdentityHelper().trustIdentityAllKeys(r)); } - private void handleIdentityFailure( - final RecipientId recipientId, - final org.whispersystems.signalservice.api.messages.SendMessageResult.IdentityFailure identityFailure - ) { - this.identityHelper.handleIdentityFailure(recipientId, identityFailure); - } - - private SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) { - final var address = account.getRecipientStore().resolveRecipientAddress(recipientId); - if (address.getUuid().isPresent()) { - return address.toSignalServiceAddress(); - } - - // Address in recipient store doesn't have a uuid, this shouldn't happen - // Try to retrieve the uuid from the server - final var number = address.getNumber().get(); - final ACI aci; - try { - aci = getRegisteredUser(number); - } catch (IOException e) { - logger.warn("Failed to get uuid for e164 number: {}", number, e); - // Return SignalServiceAddress with unknown UUID - return address.toSignalServiceAddress(); + private boolean trustIdentity( + RecipientIdentifier.Single recipient, Function trustMethod + ) throws UnregisteredRecipientException { + final var recipientId = context.getRecipientHelper().resolveRecipient(recipient); + final var updated = trustMethod.apply(recipientId); + if (updated && this.isReceiving()) { + context.getReceiveHelper().setNeedsToRetryFailedMessages(true); } - return resolveSignalServiceAddress(account.getRecipientStore().resolveRecipient(aci)); + return updated; } - private Set resolveRecipients(Collection recipients) throws IOException { - final var recipientIds = new HashSet(recipients.size()); - for (var number : recipients) { - final var recipientId = resolveRecipient(number); - recipientIds.add(recipientId); + @Override + public void addAddressChangedListener(final Runnable listener) { + synchronized (addressChangedListeners) { + addressChangedListeners.add(listener); } - return recipientIds; } - private RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws IOException { - if (recipient instanceof RecipientIdentifier.Uuid uuidRecipient) { - return account.getRecipientStore().resolveRecipient(ACI.from(uuidRecipient.uuid())); - } else { - final var number = ((RecipientIdentifier.Number) recipient).number(); - return account.getRecipientStore().resolveRecipient(number, () -> { - try { - return getRegisteredUser(number); - } catch (IOException e) { - return null; - } - }); + @Override + public void addClosedListener(final Runnable listener) { + synchronized (closedListeners) { + closedListeners.add(listener); } } - private RecipientId resolveRecipient(RecipientAddress address) { - return account.getRecipientStore().resolveRecipient(address); - } - - private RecipientId resolveRecipient(SignalServiceAddress address) { - return account.getRecipientStore().resolveRecipient(address); - } - - private RecipientId resolveRecipientTrusted(SignalServiceAddress address) { - return account.getRecipientStore().resolveRecipientTrusted(address); + @Override + public InputStream retrieveAttachment(final String id) throws IOException { + return context.getAttachmentHelper().retrieveAttachment(id).getStream(); } @Override - public void close() throws IOException { + public void close() { Thread thread; synchronized (messageHandlers) { weakHandlers.clear(); @@ -1414,15 +1241,17 @@ public class ManagerImpl implements Manager { executor.shutdown(); dependencies.getSignalWebSocket().disconnect(); + disposable.dispose(); + + if (account != null) { + account.close(); + } synchronized (closedListeners) { closedListeners.forEach(Runnable::run); closedListeners.clear(); } - if (account != null) { - account.close(); - } account = null; } }