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.Message;
import org.asamk.signal.manager.api.Pair;
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.TypingAction;
import org.asamk.signal.manager.api.UpdateGroup;
import org.whispersystems.libsignal.ecc.ECPublicKey;
import org.whispersystems.libsignal.util.guava.Optional;
import org.whispersystems.signalservice.api.SignalSessionLock;
-import org.whispersystems.signalservice.api.groupsv2.GroupLinkNotActiveException;
-import org.whispersystems.signalservice.api.messages.SendMessageResult;
-import org.whispersystems.signalservice.api.messages.SignalServiceAttachmentRemoteId;
import org.whispersystems.signalservice.api.messages.SignalServiceDataMessage;
import org.whispersystems.signalservice.api.messages.SignalServiceEnvelope;
import org.whispersystems.signalservice.api.messages.SignalServiceReceiptMessage;
import org.whispersystems.signalservice.api.messages.SignalServiceTypingMessage;
import org.whispersystems.signalservice.api.push.SignalServiceAddress;
-import org.whispersystems.signalservice.api.push.exceptions.UnregisteredUserException;
import org.whispersystems.signalservice.api.util.DeviceNameUtil;
import org.whispersystems.signalservice.api.util.InvalidNumberException;
import org.whispersystems.signalservice.api.util.PhoneNumberFormatter;
public void deleteAccount() throws IOException {
try {
pinHelper.removeRegistrationLockPin();
- } catch (UnauthenticatedResponseException e) {
+ } catch (IOException e) {
logger.warn("Failed to remove registration lock pin");
}
account.setRegistrationLockPin(null, null);
}
@Override
- public void addDeviceLink(URI linkUri) throws IOException, InvalidKeyException {
+ 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, InvalidKeyException {
+ private void addDevice(
+ String deviceIdentifier, ECPublicKey deviceKey
+ ) throws IOException, InvalidDeviceLinkException {
var identityKeyPair = account.getIdentityKeyPair();
var verificationCode = dependencies.getAccountManager().getNewDeviceVerificationCode();
- dependencies.getAccountManager()
- .addDevice(deviceIdentifier,
- deviceKey,
- identityKeyPair,
- Optional.of(account.getProfileKey().serialize()),
- verificationCode);
+ 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);
}
@Override
- public void setRegistrationLockPin(java.util.Optional<String> pin) throws IOException, UnauthenticatedResponseException {
+ public void setRegistrationLockPin(java.util.Optional<String> pin) throws IOException {
if (!account.isMasterDevice()) {
throw new RuntimeException("Only master device can set a PIN");
}
}
@Override
- public Profile getRecipientProfile(RecipientIdentifier.Single recipient) throws UnregisteredUserException {
+ public Profile getRecipientProfile(RecipientIdentifier.Single recipient) throws IOException {
return profileHelper.getRecipientProfile(resolveRecipient(recipient));
}
@Override
public Pair<GroupId, SendGroupMessageResults> joinGroup(
GroupInviteLinkUrl inviteLinkUrl
- ) throws IOException, GroupLinkNotActiveException {
+ ) throws IOException, InactiveGroupLinkException {
return groupHelper.joinGroup(inviteLinkUrl);
}
if (recipient instanceof RecipientIdentifier.Single single) {
final var recipientId = resolveRecipient(single);
final var result = sendHelper.sendMessage(messageBuilder, recipientId);
- results.put(recipient, List.of(result));
+ results.put(recipient,
+ List.of(SendMessageResult.from(result,
+ account.getRecipientStore(),
+ account.getRecipientStore()::resolveRecipientAddress)));
} else if (recipient instanceof RecipientIdentifier.NoteToSelf) {
final var result = sendHelper.sendSelfMessage(messageBuilder);
- results.put(recipient, List.of(result));
+ results.put(recipient,
+ List.of(SendMessageResult.from(result,
+ account.getRecipientStore(),
+ account.getRecipientStore()::resolveRecipientAddress)));
} else if (recipient instanceof RecipientIdentifier.Group group) {
- final var result = sendHelper.sendAsGroupMessage(messageBuilder, group.groupId);
- results.put(recipient, result);
+ 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()));
}
}
return new SendMessageResults(timestamp, results);
final var recipientId = resolveRecipient((RecipientIdentifier.Single) recipient);
sendHelper.sendTypingMessage(message, recipientId);
} else if (recipient instanceof RecipientIdentifier.Group) {
- final var groupId = ((RecipientIdentifier.Group) recipient).groupId;
+ final var groupId = ((RecipientIdentifier.Group) recipient).groupId();
final var message = new SignalServiceTypingMessage(action, timestamp, Optional.of(groupId.serialize()));
sendHelper.sendGroupTypingMessage(message, groupId);
}
@Override
public void setContactName(
RecipientIdentifier.Single recipient, String name
- ) throws NotMasterDeviceException, UnregisteredUserException {
+ ) throws NotMasterDeviceException, IOException {
if (!account.isMasterDevice()) {
throw new NotMasterDeviceException();
}
try {
uuidMap = getRegisteredUsers(Set.of(number));
} catch (NumberFormatException e) {
- throw new UnregisteredUserException(number, e);
+ throw new IOException(number, e);
}
final var uuid = uuidMap.get(number);
if (uuid == null) {
- throw new UnregisteredUserException(number, null);
+ throw new IOException(number, null);
}
return uuid;
}
receiveThread = new Thread(() -> {
while (!Thread.interrupted()) {
try {
- receiveMessagesInternal(1L, TimeUnit.HOURS, false, (envelope, decryptedContent, e) -> {
+ receiveMessagesInternal(1L, TimeUnit.HOURS, false, (envelope, e) -> {
synchronized (messageHandlers) {
for (ReceiveMessageHandler h : messageHandlers) {
try {
- h.handleMessage(envelope, decryptedContent, e);
+ h.handleMessage(envelope, e);
} catch (Exception ex) {
logger.warn("Message handler failed, ignoring", ex);
}
final RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return false;
}
return contactHelper.isContactBlocked(recipientId);
}
@Override
- public File getAttachmentFile(SignalServiceAttachmentRemoteId attachmentId) {
+ public File getAttachmentFile(String attachmentId) {
return attachmentHelper.getAttachmentFile(attachmentId);
}
final RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return null;
}
IdentityInfo identity;
try {
identity = account.getIdentityKeyStore().getIdentity(resolveRecipient(recipient));
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
identity = null;
}
return identity == null ? List.of() : List.of(toIdentity(identity));
RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return false;
}
return identityHelper.trustIdentityVerified(recipientId, fingerprint);
RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return false;
}
return identityHelper.trustIdentityVerifiedSafetyNumber(recipientId, safetyNumber);
RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return false;
}
return identityHelper.trustIdentityVerifiedSafetyNumber(recipientId, safetyNumber);
RecipientId recipientId;
try {
recipientId = resolveRecipient(recipient);
- } catch (UnregisteredUserException e) {
+ } catch (IOException e) {
return false;
}
return identityHelper.trustIdentityAllKeys(recipientId);
}
private void handleIdentityFailure(
- final RecipientId recipientId, final SendMessageResult.IdentityFailure identityFailure
+ final RecipientId recipientId,
+ final org.whispersystems.signalservice.api.messages.SendMessageResult.IdentityFailure identityFailure
) {
this.identityHelper.handleIdentityFailure(recipientId, identityFailure);
}
- @Override
- public SignalServiceAddress resolveSignalServiceAddress(SignalServiceAddress address) {
- return resolveSignalServiceAddress(resolveRecipient(address));
- }
-
private SignalServiceAddress resolveSignalServiceAddress(RecipientId recipientId) {
final var address = account.getRecipientStore().resolveRecipientAddress(recipientId);
if (address.getUuid().isPresent()) {
return resolveSignalServiceAddress(account.getRecipientStore().resolveRecipient(uuid));
}
- private Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws UnregisteredUserException {
+ private Set<RecipientId> resolveRecipients(Collection<RecipientIdentifier.Single> recipients) throws IOException {
final var recipientIds = new HashSet<RecipientId>(recipients.size());
for (var number : recipients) {
final var recipientId = resolveRecipient(number);
return recipientIds;
}
- private RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws UnregisteredUserException {
+ private RecipientId resolveRecipient(final RecipientIdentifier.Single recipient) throws IOException {
if (recipient instanceof RecipientIdentifier.Uuid) {
- return account.getRecipientStore().resolveRecipient(((RecipientIdentifier.Uuid) recipient).uuid);
+ return account.getRecipientStore().resolveRecipient(((RecipientIdentifier.Uuid) recipient).uuid());
} else {
- final var number = ((RecipientIdentifier.Number) recipient).number;
+ final var number = ((RecipientIdentifier.Number) recipient).number();
return account.getRecipientStore().resolveRecipient(number, () -> {
try {
return getRegisteredUser(number);
}
}
+ private RecipientId resolveRecipient(RecipientAddress address) {
+ return account.getRecipientStore().resolveRecipient(address);
+ }
+
private RecipientId resolveRecipient(SignalServiceAddress address) {
return account.getRecipientStore().resolveRecipient(address);
}
git.nmode.ca / signal-cli / blobdiff
