import org.asamk.signal.DbusConfig;
import org.asamk.signal.manager.Manager;
import org.asamk.signal.manager.api.AttachmentInvalidException;
+import org.asamk.signal.manager.api.CaptchaRequiredException;
import org.asamk.signal.manager.api.Configuration;
+import org.asamk.signal.manager.api.Contact;
import org.asamk.signal.manager.api.Device;
+import org.asamk.signal.manager.api.DeviceLinkUrl;
import org.asamk.signal.manager.api.Group;
+import org.asamk.signal.manager.api.GroupId;
+import org.asamk.signal.manager.api.GroupInviteLinkUrl;
+import org.asamk.signal.manager.api.GroupNotFoundException;
+import org.asamk.signal.manager.api.GroupPermission;
+import org.asamk.signal.manager.api.GroupSendingNotAllowedException;
import org.asamk.signal.manager.api.Identity;
+import org.asamk.signal.manager.api.IdentityVerificationCode;
import org.asamk.signal.manager.api.InactiveGroupLinkException;
+import org.asamk.signal.manager.api.IncorrectPinException;
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.LastGroupAdminException;
import org.asamk.signal.manager.api.Message;
import org.asamk.signal.manager.api.MessageEnvelope;
-import org.asamk.signal.manager.api.NotMasterDeviceException;
+import org.asamk.signal.manager.api.NonNormalizedPhoneNumberException;
+import org.asamk.signal.manager.api.NotAGroupMemberException;
+import org.asamk.signal.manager.api.NotPrimaryDeviceException;
import org.asamk.signal.manager.api.Pair;
+import org.asamk.signal.manager.api.PinLockedException;
+import org.asamk.signal.manager.api.RateLimitException;
+import org.asamk.signal.manager.api.ReceiveConfig;
+import org.asamk.signal.manager.api.Recipient;
+import org.asamk.signal.manager.api.RecipientAddress;
import org.asamk.signal.manager.api.RecipientIdentifier;
import org.asamk.signal.manager.api.SendGroupMessageResults;
import org.asamk.signal.manager.api.SendMessageResults;
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.api.UpdateProfile;
import org.asamk.signal.manager.api.UserStatus;
-import org.asamk.signal.manager.groups.GroupId;
-import org.asamk.signal.manager.groups.GroupInviteLinkUrl;
-import org.asamk.signal.manager.groups.GroupNotFoundException;
-import org.asamk.signal.manager.groups.GroupPermission;
-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.storage.recipients.Contact;
-import org.asamk.signal.manager.storage.recipients.Profile;
-import org.asamk.signal.manager.storage.recipients.Recipient;
-import org.asamk.signal.manager.storage.recipients.RecipientAddress;
import org.freedesktop.dbus.DBusMap;
import org.freedesktop.dbus.DBusPath;
import org.freedesktop.dbus.connections.impl.DBusConnection;
import java.io.File;
import java.io.IOException;
+import java.io.InputStream;
import java.net.URI;
import java.net.URISyntaxException;
import java.time.Duration;
import java.util.Objects;
import java.util.Optional;
import java.util.Set;
+import java.util.concurrent.atomic.AtomicInteger;
import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import java.util.function.Supplier;
private final Set<ReceiveMessageHandler> messageHandlers = new HashSet<>();
private final List<Runnable> closedListeners = new ArrayList<>();
private DBusSigHandler<Signal.MessageReceivedV2> dbusMsgHandler;
+ private DBusSigHandler<Signal.EditMessageReceived> dbusEditMsgHandler;
private DBusSigHandler<Signal.ReceiptReceivedV2> dbusRcptHandler;
private DBusSigHandler<Signal.SyncMessageReceivedV2> dbusSyncHandler;
}
@Override
- public void updateConfiguration(Configuration newConfiguration) throws IOException {
+ public void updateConfiguration(Configuration newConfiguration) {
final var configuration = getRemoteObject(new DBusPath(signal.getObjectPath() + "/Configuration"),
Signal.Configuration.class);
newConfiguration.readReceipts()
}
@Override
- public void setProfile(
- final String givenName,
- final String familyName,
- final String about,
- final String aboutEmoji,
- final Optional<File> avatar
- ) throws IOException {
- signal.updateProfile(emptyIfNull(givenName),
- emptyIfNull(familyName),
- emptyIfNull(about),
- emptyIfNull(aboutEmoji),
- avatar == null ? "" : avatar.map(File::getPath).orElse(""),
- avatar != null && avatar.isEmpty());
+ public void updateProfile(UpdateProfile updateProfile) throws IOException {
+ signal.updateProfile(emptyIfNull(updateProfile.getGivenName()),
+ emptyIfNull(updateProfile.getFamilyName()),
+ emptyIfNull(updateProfile.getAbout()),
+ emptyIfNull(updateProfile.getAboutEmoji()),
+ updateProfile.getAvatar() == null ? "" : updateProfile.getAvatar(),
+ updateProfile.isDeleteAvatar());
+ }
+
+ @Override
+ public String setUsername(final String username) throws IOException, InvalidUsernameException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void deleteUsername() throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void startChangeNumber(
+ final String newNumber, final boolean voiceVerification, final String captcha
+ ) throws RateLimitException, IOException, CaptchaRequiredException, NonNormalizedPhoneNumberException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void finishChangeNumber(
+ final String newNumber, final String verificationCode, final String pin
+ ) throws IncorrectPinException, PinLockedException, IOException {
+ throw new UnsupportedOperationException();
}
@Override
}
@Override
- public void addDeviceLink(final URI linkUri) throws IOException, InvalidDeviceLinkException {
- signal.addDevice(linkUri.toString());
+ public void addDeviceLink(final DeviceLinkUrl linkUri) throws IOException, InvalidDeviceLinkException {
+ signal.addDevice(linkUri.createDeviceLinkUri().toString());
}
@Override
}
}
- @Override
- public Profile getRecipientProfile(final RecipientIdentifier.Single recipient) {
- throw new UnsupportedOperationException();
- }
-
@Override
public List<Group> getGroups() {
final var groups = signal.listGroups();
public SendGroupMessageResults quitGroup(
final GroupId groupId, final Set<RecipientIdentifier.Single> groupAdmins
) throws GroupNotFoundException, IOException, NotAGroupMemberException, LastGroupAdminException {
- if (groupAdmins.size() > 0) {
+ if (!groupAdmins.isEmpty()) {
throw new UnsupportedOperationException();
}
final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
- group.quitGroup();
+ try {
+ group.quitGroup();
+ } catch (Signal.Error.GroupNotFound e) {
+ throw new GroupNotFoundException(groupId);
+ } catch (Signal.Error.NotAGroupMember e) {
+ throw new NotAGroupMemberException(groupId, group.Get("org.asamk.Signal.Group", "Name"));
+ } catch (Signal.Error.LastGroupAdmin e) {
+ throw new LastGroupAdminException(groupId, group.Get("org.asamk.Signal.Group", "Name"));
+ }
return new SendGroupMessageResults(0, List.of());
}
@Override
public Pair<GroupId, SendGroupMessageResults> createGroup(
- final String name, final Set<RecipientIdentifier.Single> members, final File avatarFile
+ final String name, final Set<RecipientIdentifier.Single> members, final String avatarFile
) throws IOException, AttachmentInvalidException {
final var newGroupId = signal.createGroup(emptyIfNull(name),
members.stream().map(RecipientIdentifier.Single::getIdentifier).toList(),
- avatarFile == null ? "" : avatarFile.getPath());
+ avatarFile == null ? "" : avatarFile);
return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
}
if (updateGroup.getAvatarFile() != null) {
group.Set("org.asamk.Signal.Group",
"Avatar",
- updateGroup.getAvatarFile() == null ? "" : updateGroup.getAvatarFile().getPath());
+ updateGroup.getAvatarFile() == null ? "" : updateGroup.getAvatarFile());
}
if (updateGroup.getExpirationTimer() != null) {
group.Set("org.asamk.Signal.Group", "MessageExpirationTimer", updateGroup.getExpirationTimer());
groupId -> signal.sendGroupMessage(message.messageText(), message.attachments(), groupId));
}
+ @Override
+ public SendMessageResults sendEditMessage(
+ final Message message, final Set<RecipientIdentifier> recipients, final long editTargetTimestamp
+ ) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException, UnregisteredRecipientException, InvalidStickerException {
+ throw new UnsupportedOperationException();
+ }
+
@Override
public SendMessageResults sendRemoteDeleteMessage(
final long targetSentTimestamp, final Set<RecipientIdentifier> recipients
final boolean remove,
final RecipientIdentifier.Single targetAuthor,
final long targetSentTimestamp,
- final Set<RecipientIdentifier> recipients
+ final Set<RecipientIdentifier> recipients,
+ final boolean isStory
) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
return handleMessage(recipients,
numbers -> signal.sendMessageReaction(emoji,
public SendMessageResults sendPaymentNotificationMessage(
final byte[] receipt, final String note, final RecipientIdentifier.Single recipient
) throws IOException {
- throw new UnsupportedOperationException();
+ final var timestamp = signal.sendPaymentNotification(receipt, note, recipient.getIdentifier());
+ return new SendMessageResults(timestamp, Map.of());
}
@Override
@Override
public void setContactName(
- final RecipientIdentifier.Single recipient, final String name
- ) throws NotMasterDeviceException {
- signal.setContactName(recipient.getIdentifier(), name);
+ final RecipientIdentifier.Single recipient, final String givenName, final String familyName
+ ) throws NotPrimaryDeviceException {
+ signal.setContactName(recipient.getIdentifier(), givenName);
}
@Override
public void setContactsBlocked(
final Collection<RecipientIdentifier.Single> recipients, final boolean blocked
- ) throws NotMasterDeviceException, IOException {
+ ) throws NotPrimaryDeviceException, IOException {
for (final var recipient : recipients) {
signal.setContactBlocked(recipient.getIdentifier(), blocked);
}
}
}
+ @Override
+ public void installStickerPack(final StickerPackUrl url) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
@Override
public List<StickerPack> getStickerPacks() {
throw new UnsupportedOperationException();
if (isWeakListener) {
weakHandlers.add(handler);
} else {
- if (messageHandlers.size() == 0) {
+ if (messageHandlers.isEmpty()) {
installMessageHandlers();
}
messageHandlers.add(handler);
synchronized (messageHandlers) {
weakHandlers.remove(handler);
messageHandlers.remove(handler);
- if (messageHandlers.size() == 0) {
+ if (messageHandlers.isEmpty()) {
uninstallMessageHandlers();
}
}
@Override
public boolean isReceiving() {
synchronized (messageHandlers) {
- return messageHandlers.size() > 0;
- }
- }
-
- @Override
- public void receiveMessages(final ReceiveMessageHandler handler) throws IOException {
- addReceiveHandler(handler);
- try {
- synchronized (this) {
- this.wait();
- }
- } catch (InterruptedException ignored) {
+ return !messageHandlers.isEmpty();
}
- removeReceiveHandler(handler);
}
@Override
public void receiveMessages(
- final Duration timeout, final ReceiveMessageHandler handler
+ Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
) throws IOException {
+ final var remainingMessages = new AtomicInteger(maxMessages.orElse(-1));
final var lastMessage = new AtomicLong(System.currentTimeMillis());
+ final var thread = Thread.currentThread();
final ReceiveMessageHandler receiveHandler = (envelope, e) -> {
lastMessage.set(System.currentTimeMillis());
handler.handleMessage(envelope, e);
+ if (remainingMessages.get() > 0) {
+ if (remainingMessages.decrementAndGet() <= 0) {
+ remainingMessages.set(0);
+ thread.interrupt();
+ }
+ }
};
addReceiveHandler(receiveHandler);
- while (true) {
+ if (timeout.isPresent()) {
+ while (remainingMessages.get() != 0) {
+ try {
+ final var passedTime = System.currentTimeMillis() - lastMessage.get();
+ final var sleepTimeRemaining = timeout.get().toMillis() - passedTime;
+ if (sleepTimeRemaining < 0) {
+ break;
+ }
+ Thread.sleep(sleepTimeRemaining);
+ } catch (InterruptedException ignored) {
+ }
+ }
+ } else {
try {
- final var sleepTimeRemaining = timeout.toMillis() - (System.currentTimeMillis() - lastMessage.get());
- if (sleepTimeRemaining < 0) {
- break;
+ synchronized (this) {
+ this.wait();
}
- Thread.sleep(sleepTimeRemaining);
} catch (InterruptedException ignored) {
}
}
- removeReceiveHandler(receiveHandler);
- }
- @Override
- public void setIgnoreAttachments(final boolean ignoreAttachments) {
+ removeReceiveHandler(receiveHandler);
}
@Override
- public boolean hasCaughtUpWithOldMessages() {
- return true;
+ public void setReceiveConfig(final ReceiveConfig receiveConfig) {
}
@Override
return null;
}
final var contactName = signal.getContactName(n);
- if (onlyContacts && contactName.length() == 0) {
+ if (onlyContacts && contactName.isEmpty()) {
return null;
}
if (name.isPresent() && !name.get().equals(contactName)) {
}
return Recipient.newBuilder()
.withAddress(new RecipientAddress(null, n))
- .withContact(new Contact(contactName, null, 0, contactBlocked, false, false))
+ .withContact(new Contact(contactName, null, null, 0, contactBlocked, false, false))
.build();
}).filter(Objects::nonNull).toList();
}
}
@Override
- public boolean trustIdentityVerified(final RecipientIdentifier.Single recipient, final byte[] fingerprint) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public boolean trustIdentityVerifiedSafetyNumber(
- final RecipientIdentifier.Single recipient, final String safetyNumber
- ) {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public boolean trustIdentityVerifiedSafetyNumber(
- final RecipientIdentifier.Single recipient, final byte[] safetyNumber
+ public boolean trustIdentityVerified(
+ final RecipientIdentifier.Single recipient, final IdentityVerificationCode verificationCode
) {
throw new UnsupportedOperationException();
}
this.notify();
}
synchronized (messageHandlers) {
- if (messageHandlers.size() > 0) {
+ if (!messageHandlers.isEmpty()) {
uninstallMessageHandlers();
}
weakHandlers.clear();
.map(RecipientIdentifier.Single.class::cast)
.map(RecipientIdentifier.Single::getIdentifier)
.toList();
- if (singleRecipients.size() > 0) {
+ if (!singleRecipients.isEmpty()) {
timestamp = recipientsHandler.apply(singleRecipients);
}
messageReceived.getGroupId()), false, 0))
: Optional.empty(),
Optional.empty(),
+ Optional.empty(),
Optional.of(messageReceived.getMessage()),
0,
false,
false,
false,
false,
+ false,
Optional.empty(),
Optional.empty(),
Optional.empty(),
Optional.empty(),
List.of(),
List.of(),
+ List.of(),
List.of())),
Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
Optional.empty());
notifyMessageHandlers(envelope);
};
connection.addSigHandler(Signal.MessageReceivedV2.class, signal, this.dbusMsgHandler);
+ this.dbusEditMsgHandler = messageReceived -> {
+ final var extras = messageReceived.getExtras();
+ final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(null,
+ messageReceived.getSender())),
+ 0,
+ messageReceived.getTimestamp(),
+ 0,
+ 0,
+ false,
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.of(new MessageEnvelope.Edit(messageReceived.getTargetSentTimestamp(),
+ new MessageEnvelope.Data(messageReceived.getTimestamp(),
+ messageReceived.getGroupId().length > 0
+ ? Optional.of(new MessageEnvelope.Data.GroupContext(GroupId.unknownVersion(
+ messageReceived.getGroupId()), false, 0))
+ : Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.of(messageReceived.getMessage()),
+ 0,
+ false,
+ false,
+ false,
+ false,
+ false,
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
+ getAttachments(extras),
+ Optional.empty(),
+ Optional.empty(),
+ List.of(),
+ List.of(),
+ List.of(),
+ List.of()))),
+ Optional.empty(),
+ Optional.empty(),
+ Optional.empty());
+ notifyMessageHandlers(envelope);
+ };
+ connection.addSigHandler(Signal.EditMessageReceived.class, signal, this.dbusEditMsgHandler);
this.dbusRcptHandler = receiptReceived -> {
final var type = switch (receiptReceived.getReceiptType()) {
Optional.empty(),
Optional.empty(),
Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
Optional.empty());
notifyMessageHandlers(envelope);
};
Optional.empty(),
Optional.empty(),
Optional.empty(),
+ Optional.empty(),
Optional.of(new MessageEnvelope.Sync(Optional.of(new MessageEnvelope.Sync.Sent(syncReceived.getTimestamp(),
syncReceived.getTimestamp(),
syncReceived.getDestination().isEmpty()
syncReceived.getGroupId()), false, 0))
: Optional.empty(),
Optional.empty(),
+ Optional.empty(),
Optional.of(syncReceived.getMessage()),
0,
false,
false,
false,
false,
+ false,
Optional.empty(),
Optional.empty(),
Optional.empty(),
Optional.empty(),
List.of(),
List.of(),
- List.of())))),
+ List.of(),
+ List.of())),
+ Optional.empty(),
+ Optional.empty())),
Optional.empty(),
List.of(),
List.of(),
Optional.empty(),
Optional.empty(),
Optional.empty())),
+ Optional.empty(),
Optional.empty());
notifyMessageHandlers(envelope);
};
connection.addSigHandler(Signal.SyncMessageReceivedV2.class, signal, this.dbusSyncHandler);
} catch (DBusException e) {
- e.printStackTrace();
+ throw new RuntimeException(e);
}
signal.subscribeReceive();
}
try {
signal.unsubscribeReceive();
connection.removeSigHandler(Signal.MessageReceivedV2.class, signal, this.dbusMsgHandler);
+ connection.removeSigHandler(Signal.EditMessageReceived.class, signal, this.dbusEditMsgHandler);
connection.removeSigHandler(Signal.ReceiptReceivedV2.class, signal, this.dbusRcptHandler);
connection.removeSigHandler(Signal.SyncMessageReceivedV2.class, signal, this.dbusSyncHandler);
} catch (DBusException e) {
- e.printStackTrace();
+ throw new RuntimeException(e);
}
}
}).toList();
}
+ @Override
+ public InputStream retrieveAttachment(final String id) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
@SuppressWarnings("unchecked")
private <T> T getValue(
final Map<String, Variant<?>> stringVariantMap, final String field
git.nmode.ca / signal-cli / blobdiff
