package org.asamk.signal.dbus;
import org.asamk.Signal;
-import org.asamk.signal.DbusConfig;
-import org.asamk.signal.manager.AttachmentInvalidException;
import org.asamk.signal.manager.Manager;
-import org.asamk.signal.manager.NotMasterDeviceException;
-import org.asamk.signal.manager.StickerPackInvalidException;
-import org.asamk.signal.manager.UntrustedIdentityException;
+import org.asamk.signal.manager.api.AlreadyReceivingException;
+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.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.StickerPack;
+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.TrustLevel;
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.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.RecipientAddress;
+import org.asamk.signal.manager.api.UpdateProfile;
+import org.asamk.signal.manager.api.UserStatus;
+import org.asamk.signal.manager.api.UsernameLinkUrl;
+import org.asamk.signal.manager.api.UsernameStatus;
import org.freedesktop.dbus.DBusMap;
import org.freedesktop.dbus.DBusPath;
import org.freedesktop.dbus.connections.impl.DBusConnection;
import org.freedesktop.dbus.exceptions.DBusException;
+import org.freedesktop.dbus.exceptions.DBusExecutionException;
import org.freedesktop.dbus.interfaces.DBusInterface;
import org.freedesktop.dbus.interfaces.DBusSigHandler;
import org.freedesktop.dbus.types.Variant;
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.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.TimeUnit;
+import java.util.concurrent.atomic.AtomicInteger;
+import java.util.concurrent.atomic.AtomicLong;
import java.util.function.Function;
import java.util.function.Supplier;
import java.util.stream.Collectors;
+import java.util.stream.Stream;
/**
* This class implements the Manager interface using the DBus Signal interface, where possible.
private final Signal signal;
private final DBusConnection connection;
+ private final Set<ReceiveMessageHandler> weakHandlers = new HashSet<>();
private final Set<ReceiveMessageHandler> messageHandlers = new HashSet<>();
+ private final List<Runnable> closedListeners = new ArrayList<>();
+ private final String busname;
private DBusSigHandler<Signal.MessageReceivedV2> dbusMsgHandler;
+ private DBusSigHandler<Signal.EditMessageReceived> dbusEditMsgHandler;
private DBusSigHandler<Signal.ReceiptReceivedV2> dbusRcptHandler;
private DBusSigHandler<Signal.SyncMessageReceivedV2> dbusSyncHandler;
- public DbusManagerImpl(final Signal signal, DBusConnection connection) {
+ public DbusManagerImpl(final Signal signal, DBusConnection connection, final String busname) {
this.signal = signal;
this.connection = connection;
+ this.busname = busname;
}
@Override
}
@Override
- public void checkAccountState() throws IOException {
- throw new UnsupportedOperationException();
- }
-
- @Override
- public Map<String, Pair<String, UUID>> areUsersRegistered(final Set<String> numbers) throws IOException {
+ public Map<String, UserStatus> getUserStatus(final Set<String> numbers) throws IOException {
final var numbersList = new ArrayList<>(numbers);
final var registered = signal.isRegistered(numbersList);
- final var result = new HashMap<String, Pair<String, UUID>>();
+ final var result = new HashMap<String, UserStatus>();
for (var i = 0; i < numbersList.size(); i++) {
result.put(numbersList.get(i),
- new Pair<>(numbersList.get(i), registered.get(i) ? RecipientAddress.UNKNOWN_UUID : null));
+ new UserStatus(numbersList.get(i),
+ registered.get(i) ? RecipientAddress.UNKNOWN_UUID : null,
+ false));
}
return result;
}
@Override
- public void updateAccountAttributes(final String deviceName) throws IOException {
+ public Map<String, UsernameStatus> getUsernameStatus(final Set<String> usernames) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void updateAccountAttributes(
+ final String deviceName,
+ final Boolean unrestrictedUnidentifiedSender,
+ final Boolean discoverableByNumber,
+ final Boolean numberSharing
+ ) throws IOException {
if (deviceName != null) {
final var devicePath = signal.getThisDevice();
getRemoteObject(devicePath, Signal.Device.class).Set("org.asamk.Signal.Device", "Name", deviceName);
+ } else {
+ throw new UnsupportedOperationException();
}
}
@Override
public Configuration getConfiguration() {
+ final var configuration = getRemoteObject(new DBusPath(signal.getObjectPath() + "/Configuration"),
+ Signal.Configuration.class).GetAll("org.asamk.Signal.Configuration");
+ return new Configuration(Optional.of((Boolean) configuration.get("ReadReceipts").getValue()),
+ Optional.of((Boolean) configuration.get("UnidentifiedDeliveryIndicators").getValue()),
+ Optional.of((Boolean) configuration.get("TypingIndicators").getValue()),
+ Optional.of((Boolean) configuration.get("LinkPreviews").getValue()));
+ }
+
+ @Override
+ public void updateConfiguration(Configuration newConfiguration) {
+ final var configuration = getRemoteObject(new DBusPath(signal.getObjectPath() + "/Configuration"),
+ Signal.Configuration.class);
+ newConfiguration.readReceipts()
+ .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "ReadReceipts", v));
+ newConfiguration.unidentifiedDeliveryIndicators()
+ .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration",
+ "UnidentifiedDeliveryIndicators",
+ v));
+ newConfiguration.typingIndicators()
+ .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "TypingIndicators", v));
+ newConfiguration.linkPreviews()
+ .ifPresent(v -> configuration.Set("org.asamk.Signal.Configuration", "LinkPreviews", v));
+ }
+
+ @Override
+ 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 getUsername() {
throw new UnsupportedOperationException();
}
@Override
- public void updateConfiguration(Configuration configuration) throws IOException {
+ public UsernameLinkUrl getUsernameLink() {
throw new UnsupportedOperationException();
}
@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.isPresent());
+ public void setUsername(final String username) throws IOException, InvalidUsernameException {
+ throw new UnsupportedOperationException();
}
@Override
- public void unregister() throws IOException {
+ public void deleteUsername() throws IOException {
throw new UnsupportedOperationException();
}
@Override
- public void deleteAccount() throws IOException {
+ 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
+ public void unregister() throws IOException {
+ signal.unregister();
+ }
+
+ @Override
+ public void deleteAccount() throws IOException {
+ signal.deleteAccount();
+ }
+
@Override
public void submitRateLimitRecaptchaChallenge(final String challenge, final String captcha) throws IOException {
signal.submitRateLimitChallenge(challenge, captcha);
return signal.listDevices().stream().map(d -> {
final var device = getRemoteObject(d.getObjectPath(),
Signal.Device.class).GetAll("org.asamk.Signal.Device");
- return new Device((long) device.get("Id").getValue(),
+ return new Device((Integer) device.get("Id").getValue(),
(String) device.get("Name").getValue(),
(long) device.get("Created").getValue(),
(long) device.get("LastSeen").getValue(),
thisDevice.equals(d.getObjectPath()));
- }).collect(Collectors.toList());
+ }).toList();
}
@Override
- public void removeLinkedDevices(final long deviceId) throws IOException {
+ public void removeLinkedDevices(final int deviceId) throws IOException {
final var devicePath = signal.getDevice(deviceId);
getRemoteObject(devicePath, Signal.Device.class).removeDevice();
}
@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();
- return groups.stream().map(Signal.StructGroup::getObjectPath).map(this::getGroup).collect(Collectors.toList());
+ return groups.stream().map(Signal.StructGroup::getObjectPath).map(this::getGroup).toList();
}
@Override
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 void deleteGroup(final GroupId groupId) throws IOException {
- throw new UnsupportedOperationException();
+ final var group = getRemoteObject(signal.getGroup(groupId.serialize()), Signal.Group.class);
+ group.deleteGroup();
}
@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).collect(Collectors.toList()),
- avatarFile == null ? "" : avatarFile.getPath());
+ members.stream().map(RecipientIdentifier.Single::getIdentifier).toList(),
+ 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());
: GroupPermission.EVERY_MEMBER.name());
}
if (updateGroup.getMembers() != null) {
- group.addMembers(updateGroup.getMembers()
- .stream()
- .map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList()));
+ group.addMembers(updateGroup.getMembers().stream().map(RecipientIdentifier.Single::getIdentifier).toList());
}
if (updateGroup.getRemoveMembers() != null) {
group.removeMembers(updateGroup.getRemoveMembers()
.stream()
.map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList()));
+ .toList());
}
if (updateGroup.getAdmins() != null) {
- group.addAdmins(updateGroup.getAdmins()
- .stream()
- .map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList()));
+ group.addAdmins(updateGroup.getAdmins().stream().map(RecipientIdentifier.Single::getIdentifier).toList());
}
if (updateGroup.getRemoveAdmins() != null) {
group.removeAdmins(updateGroup.getRemoveAdmins()
.stream()
.map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList()));
+ .toList());
}
if (updateGroup.isResetGroupLink()) {
group.resetLink();
@Override
public Pair<GroupId, SendGroupMessageResults> joinGroup(final GroupInviteLinkUrl inviteLinkUrl) throws IOException, InactiveGroupLinkException {
- final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
- return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
+ try {
+ final var newGroupId = signal.joinGroup(inviteLinkUrl.getUrl());
+ return new Pair<>(GroupId.unknownVersion(newGroupId), new SendGroupMessageResults(0, List.of()));
+ } catch (DBusExecutionException e) {
+ throw new IOException("Failed to join group: " + e.getMessage() + " (" + e.getClass().getSimpleName() + ")",
+ e);
+ }
}
@Override
- public void sendTypingMessage(
+ public SendMessageResults sendTypingMessage(
final TypingAction action, final Set<RecipientIdentifier> recipients
- ) throws IOException, UntrustedIdentityException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
- for (final var recipient : recipients) {
- if (recipient instanceof RecipientIdentifier.Single) {
- signal.sendTyping(((RecipientIdentifier.Single) recipient).getIdentifier(),
- action == TypingAction.STOP);
- } else if (recipient instanceof RecipientIdentifier.Group) {
- throw new UnsupportedOperationException();
- }
- }
+ ) throws IOException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
+ return handleMessage(recipients, numbers -> {
+ numbers.forEach(n -> signal.sendTyping(n, action == TypingAction.STOP));
+ return 0L;
+ }, () -> {
+ signal.sendTyping(signal.getSelfNumber(), action == TypingAction.STOP);
+ return 0L;
+ }, groupId -> {
+ signal.sendGroupTyping(groupId, action == TypingAction.STOP);
+ return 0L;
+ });
}
@Override
- public void sendReadReceipt(
+ public SendMessageResults sendReadReceipt(
final RecipientIdentifier.Single sender, final List<Long> messageIds
- ) throws IOException, UntrustedIdentityException {
+ ) {
signal.sendReadReceipt(sender.getIdentifier(), messageIds);
+ return new SendMessageResults(0, Map.of());
}
@Override
- public void sendViewedReceipt(
+ public SendMessageResults sendViewedReceipt(
final RecipientIdentifier.Single sender, final List<Long> messageIds
- ) throws IOException, UntrustedIdentityException {
+ ) {
signal.sendViewedReceipt(sender.getIdentifier(), messageIds);
+ return new SendMessageResults(0, Map.of());
}
@Override
public SendMessageResults sendMessage(
- final Message message, final Set<RecipientIdentifier> recipients
+ final Message message, final Set<RecipientIdentifier> recipients, final boolean notifySelf
) throws IOException, AttachmentInvalidException, NotAGroupMemberException, GroupNotFoundException, GroupSendingNotAllowedException {
return handleMessage(recipients,
numbers -> signal.sendMessage(message.messageText(), message.attachments(), numbers),
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,
groupId));
}
+ @Override
+ public SendMessageResults sendPaymentNotificationMessage(
+ final byte[] receipt, final String note, final RecipientIdentifier.Single recipient
+ ) throws IOException {
+ final var timestamp = signal.sendPaymentNotification(receipt, note, recipient.getIdentifier());
+ return new SendMessageResults(timestamp, Map.of());
+ }
+
@Override
public SendMessageResults sendEndSessionMessage(final Set<RecipientIdentifier.Single> recipients) throws IOException {
- signal.sendEndSessionMessage(recipients.stream()
- .map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList()));
+ signal.sendEndSessionMessage(recipients.stream().map(RecipientIdentifier.Single::getIdentifier).toList());
return new SendMessageResults(0, Map.of());
}
+ @Override
+ public SendMessageResults sendMessageRequestResponse(
+ final MessageEnvelope.Sync.MessageRequestResponse.Type type,
+ final Set<RecipientIdentifier> recipientIdentifiers
+ ) {
+ throw new UnsupportedOperationException();
+ }
+
+ public void hideRecipient(final RecipientIdentifier.Single recipient) {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public void deleteRecipient(final RecipientIdentifier.Single recipient) {
+ signal.deleteRecipient(recipient.getIdentifier());
+ }
+
+ @Override
+ public void deleteContact(final RecipientIdentifier.Single recipient) {
+ signal.deleteContact(recipient.getIdentifier());
+ }
+
@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 setContactBlocked(
- final RecipientIdentifier.Single recipient, final boolean blocked
- ) throws NotMasterDeviceException, IOException {
- signal.setContactBlocked(recipient.getIdentifier(), blocked);
+ public void setContactsBlocked(
+ final Collection<RecipientIdentifier.Single> recipients, final boolean blocked
+ ) throws NotPrimaryDeviceException, IOException {
+ for (final var recipient : recipients) {
+ signal.setContactBlocked(recipient.getIdentifier(), blocked);
+ }
}
@Override
- public void setGroupBlocked(
- final GroupId groupId, final boolean blocked
+ public void setGroupsBlocked(
+ final Collection<GroupId> groupIds, final boolean blocked
) throws GroupNotFoundException, IOException {
- setGroupProperty(groupId, "IsBlocked", blocked);
+ for (final var groupId : groupIds) {
+ setGroupProperty(groupId, "IsBlocked", blocked);
+ }
}
private void setGroupProperty(final GroupId groupId, final String propertyName, final boolean blocked) {
}
@Override
- public URI uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {
+ public StickerPackUrl uploadStickerPack(final File path) throws IOException, StickerPackInvalidException {
try {
- return new URI(signal.uploadStickerPack(path.getPath()));
- } catch (URISyntaxException e) {
+ return StickerPackUrl.fromUri(new URI(signal.uploadStickerPack(path.getPath())));
+ } catch (URISyntaxException | StickerPackUrl.InvalidStickerPackLinkException e) {
throw new AssertionError(e);
}
}
+ @Override
+ public void installStickerPack(final StickerPackUrl url) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public List<StickerPack> getStickerPacks() {
+ throw new UnsupportedOperationException();
+ }
+
@Override
public void requestAllSyncData() throws IOException {
signal.sendSyncRequest();
}
@Override
- public void addReceiveHandler(final ReceiveMessageHandler handler) {
+ public void addReceiveHandler(final ReceiveMessageHandler handler, final boolean isWeakListener) {
synchronized (messageHandlers) {
- if (messageHandlers.size() == 0) {
- installMessageHandlers();
+ if (isWeakListener) {
+ weakHandlers.add(handler);
+ } else {
+ if (messageHandlers.isEmpty()) {
+ installMessageHandlers();
+ }
+ messageHandlers.add(handler);
}
- messageHandlers.add(handler);
}
}
@Override
public void removeReceiveHandler(final ReceiveMessageHandler 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;
+ return !messageHandlers.isEmpty();
}
}
- @Override
- public void receiveMessages(final ReceiveMessageHandler handler) throws IOException {
- addReceiveHandler(handler);
- try {
- synchronized (this) {
- this.wait();
- }
- } catch (InterruptedException ignored) {
- }
- removeReceiveHandler(handler);
- }
+ private Thread receiveThread;
@Override
public void receiveMessages(
- final long timeout, final TimeUnit unit, final ReceiveMessageHandler handler
- ) throws IOException {
- addReceiveHandler(handler);
- try {
- Thread.sleep(unit.toMillis(timeout));
- } catch (InterruptedException ignored) {
+ Optional<Duration> timeout, Optional<Integer> maxMessages, ReceiveMessageHandler handler
+ ) throws IOException, AlreadyReceivingException {
+ if (receiveThread != null) {
+ throw new AlreadyReceivingException("Already receiving message.");
+ }
+ receiveThread = Thread.currentThread();
+
+ 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);
+ 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) {
+ break;
+ }
+ }
+ } else {
+ try {
+ synchronized (this) {
+ this.wait();
+ }
+ } catch (InterruptedException ignored) {
+ }
}
- removeReceiveHandler(handler);
+
+ removeReceiveHandler(receiveHandler);
+ receiveThread = null;
}
@Override
- public void setIgnoreAttachments(final boolean ignoreAttachments) {
+ public void stopReceiveMessages() {
+ if (receiveThread != null) {
+ receiveThread.interrupt();
+ }
}
@Override
- public boolean hasCaughtUpWithOldMessages() {
- return true;
+ public void setReceiveConfig(final ReceiveConfig receiveConfig) {
}
@Override
}
@Override
- public List<Pair<RecipientAddress, Contact>> getContacts() {
- throw new UnsupportedOperationException();
+ public List<Recipient> getRecipients(
+ final boolean onlyContacts,
+ final Optional<Boolean> blocked,
+ final Collection<RecipientIdentifier.Single> addresses,
+ final Optional<String> name
+ ) {
+ final var numbers = addresses.stream()
+ .filter(s -> s instanceof RecipientIdentifier.Number)
+ .map(s -> ((RecipientIdentifier.Number) s).number())
+ .collect(Collectors.toSet());
+ return signal.listNumbers().stream().filter(n -> addresses.isEmpty() || numbers.contains(n)).map(n -> {
+ final var contactBlocked = signal.isContactBlocked(n);
+ if (blocked.isPresent() && blocked.get() != contactBlocked) {
+ return null;
+ }
+ final var contactName = signal.getContactName(n);
+ if (onlyContacts && contactName.isEmpty()) {
+ return null;
+ }
+ if (name.isPresent() && !name.get().equals(contactName)) {
+ return null;
+ }
+ return Recipient.newBuilder()
+ .withAddress(new RecipientAddress(n))
+ .withContact(new Contact(contactName,
+ null,
+ null,
+ null,
+ null,
+ null,
+ null,
+ 0,
+ 0,
+ false,
+ contactBlocked,
+ false,
+ false,
+ false,
+ null))
+ .build();
+ }).filter(Objects::nonNull).toList();
}
@Override
(String) group.get("Description").getValue(),
GroupInviteLinkUrl.fromUri((String) group.get("GroupInviteLink").getValue()),
((List<String>) group.get("Members").getValue()).stream()
- .map(m -> new RecipientAddress(null, m))
+ .map(m -> new RecipientAddress(m))
.collect(Collectors.toSet()),
((List<String>) group.get("PendingMembers").getValue()).stream()
- .map(m -> new RecipientAddress(null, m))
+ .map(m -> new RecipientAddress(m))
.collect(Collectors.toSet()),
((List<String>) group.get("RequestingMembers").getValue()).stream()
- .map(m -> new RecipientAddress(null, m))
+ .map(m -> new RecipientAddress(m))
.collect(Collectors.toSet()),
((List<String>) group.get("Admins").getValue()).stream()
- .map(m -> new RecipientAddress(null, m))
+ .map(m -> new RecipientAddress(m))
+ .collect(Collectors.toSet()),
+ ((List<String>) group.get("Banned").getValue()).stream()
+ .map(m -> new RecipientAddress(m))
.collect(Collectors.toSet()),
(boolean) group.get("IsBlocked").getValue(),
(int) group.get("MessageExpirationTimer").getValue(),
@Override
public List<Identity> getIdentities() {
- throw new UnsupportedOperationException();
+ final var identities = signal.listIdentities();
+ return identities.stream().map(Signal.StructIdentity::getObjectPath).map(this::getIdentity).toList();
}
@Override
public List<Identity> getIdentities(final RecipientIdentifier.Single recipient) {
- throw new UnsupportedOperationException();
+ final var path = signal.getIdentity(recipient.getIdentifier());
+ return List.of(getIdentity(path));
}
- @Override
- public boolean trustIdentityVerified(final RecipientIdentifier.Single recipient, final byte[] fingerprint) {
- throw new UnsupportedOperationException();
+ private Identity getIdentity(final DBusPath identityPath) {
+ final var group = getRemoteObject(identityPath, Signal.Identity.class).GetAll("org.asamk.Signal.Identity");
+ final var aci = (String) group.get("Uuid").getValue();
+ final var number = (String) group.get("Number").getValue();
+ return new Identity(new RecipientAddress(aci, null, number, null),
+ (byte[]) group.get("Fingerprint").getValue(),
+ (String) group.get("SafetyNumber").getValue(),
+ (byte[]) group.get("ScannableSafetyNumber").getValue(),
+ TrustLevel.valueOf((String) group.get("TrustLevel").getValue()),
+ (Long) group.get("AddedDate").getValue());
}
@Override
- public boolean trustIdentityVerifiedSafetyNumber(
- final RecipientIdentifier.Single recipient, final String safetyNumber
+ public boolean trustIdentityVerified(
+ final RecipientIdentifier.Single recipient, final IdentityVerificationCode verificationCode
) {
throw new UnsupportedOperationException();
}
@Override
- public boolean trustIdentityVerifiedSafetyNumber(
- final RecipientIdentifier.Single recipient, final byte[] safetyNumber
- ) {
+ public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {
throw new UnsupportedOperationException();
}
@Override
- public boolean trustIdentityAllKeys(final RecipientIdentifier.Single recipient) {
- throw new UnsupportedOperationException();
+ public void addAddressChangedListener(final Runnable listener) {
}
@Override
- public void close() throws IOException {
+ public void addClosedListener(final Runnable listener) {
+ synchronized (closedListeners) {
+ closedListeners.add(listener);
+ }
+ }
+
+ @Override
+ public void close() {
synchronized (this) {
this.notify();
}
synchronized (messageHandlers) {
+ if (!messageHandlers.isEmpty()) {
+ uninstallMessageHandlers();
+ }
+ weakHandlers.clear();
messageHandlers.clear();
- uninstallMessageHandlers();
+ }
+ synchronized (closedListeners) {
+ closedListeners.forEach(Runnable::run);
+ closedListeners.clear();
}
}
.filter(r -> r instanceof RecipientIdentifier.Single)
.map(RecipientIdentifier.Single.class::cast)
.map(RecipientIdentifier.Single::getIdentifier)
- .collect(Collectors.toList());
- if (singleRecipients.size() > 0) {
+ .toList();
+ if (!singleRecipients.isEmpty()) {
timestamp = recipientsHandler.apply(singleRecipients);
}
.filter(r -> r instanceof RecipientIdentifier.Group)
.map(RecipientIdentifier.Group.class::cast)
.map(RecipientIdentifier.Group::groupId)
- .collect(Collectors.toList());
+ .toList();
for (final var groupId : groupRecipients) {
timestamp = groupHandler.apply(groupId.serialize());
}
return string == null ? "" : string;
}
- private <T extends DBusInterface> T getRemoteObject(final DBusPath devicePath, final Class<T> type) {
+ private <T extends DBusInterface> T getRemoteObject(final DBusPath path, final Class<T> type) {
try {
- return connection.getRemoteObject(DbusConfig.getBusname(), devicePath.getPath(), type);
+ return connection.getRemoteObject(busname, path.getPath(), type);
} catch (DBusException e) {
throw new AssertionError(e);
}
try {
this.dbusMsgHandler = messageReceived -> {
final var extras = messageReceived.getExtras();
- final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(null,
- messageReceived.getSender())),
+ final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(messageReceived.getSender())),
0,
messageReceived.getTimestamp(),
0,
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(),
+ getMentions(extras),
List.of(),
List.of())),
Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
Optional.empty());
- synchronized (messageHandlers) {
- for (final var messageHandler : messageHandlers) {
- messageHandler.handleMessage(envelope, null);
- }
- }
+ 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(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(),
+ getMentions(extras),
+ 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()) {
case "delivery" -> MessageEnvelope.Receipt.Type.DELIVERY;
default -> MessageEnvelope.Receipt.Type.UNKNOWN;
};
- final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(null,
- receiptReceived.getSender())),
+ final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(receiptReceived.getSender())),
0,
receiptReceived.getTimestamp(),
0,
Optional.empty(),
Optional.empty(),
Optional.empty(),
+ Optional.empty(),
+ Optional.empty(),
Optional.empty());
- synchronized (messageHandlers) {
- for (final var messageHandler : messageHandlers) {
- messageHandler.handleMessage(envelope, null);
- }
- }
+ notifyMessageHandlers(envelope);
};
connection.addSigHandler(Signal.ReceiptReceivedV2.class, signal, this.dbusRcptHandler);
this.dbusSyncHandler = syncReceived -> {
final var extras = syncReceived.getExtras();
- final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(null,
- syncReceived.getSource())),
+ final var envelope = new MessageEnvelope(Optional.of(new RecipientAddress(syncReceived.getSource())),
0,
syncReceived.getTimestamp(),
0,
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()
? Optional.empty()
- : Optional.of(new RecipientAddress(null, syncReceived.getDestination())),
+ : Optional.of(new RecipientAddress(syncReceived.getDestination())),
Set.of(),
- new MessageEnvelope.Data(syncReceived.getTimestamp(),
+ Optional.of(new MessageEnvelope.Data(syncReceived.getTimestamp(),
syncReceived.getGroupId().length > 0
? Optional.of(new MessageEnvelope.Data.GroupContext(GroupId.unknownVersion(
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(),
getAttachments(extras),
Optional.empty(),
Optional.empty(),
List.of(),
+ getMentions(extras),
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());
- synchronized (messageHandlers) {
- for (final var messageHandler : messageHandlers) {
- messageHandler.handleMessage(envelope, null);
- }
- }
+ notifyMessageHandlers(envelope);
};
connection.addSigHandler(Signal.SyncMessageReceivedV2.class, signal, this.dbusSyncHandler);
} catch (DBusException e) {
- e.printStackTrace();
+ throw new RuntimeException(e);
+ }
+ signal.subscribeReceive();
+ }
+
+ private void notifyMessageHandlers(final MessageEnvelope envelope) {
+ synchronized (messageHandlers) {
+ Stream.concat(messageHandlers.stream(), weakHandlers.stream())
+ .forEach(h -> h.handleMessage(envelope, null));
}
}
private void uninstallMessageHandlers() {
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);
}
}
getValue(a, "isVoiceNote"),
getValue(a, "isGif"),
getValue(a, "isBorderless"));
- }).collect(Collectors.toList());
+ }).toList();
+ }
+
+ private List<MessageEnvelope.Data.Mention> getMentions(final Map<String, Variant<?>> extras) {
+ if (!extras.containsKey("mentions")) {
+ return List.of();
+ }
+
+ final List<DBusMap<String, Variant<?>>> mentions = getValue(extras, "mentions");
+ return mentions.stream()
+ .map(a -> new MessageEnvelope.Data.Mention(new RecipientAddress(this.<String>getValue(a, "recipient")),
+ getValue(a, "start"),
+ getValue(a, "length")))
+ .toList();
+ }
+
+ @Override
+ public InputStream retrieveAttachment(final String id) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public InputStream retrieveContactAvatar(final RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public InputStream retrieveProfileAvatar(final RecipientIdentifier.Single recipient) throws IOException, UnregisteredRecipientException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public InputStream retrieveGroupAvatar(final GroupId groupId) throws IOException {
+ throw new UnsupportedOperationException();
+ }
+
+ @Override
+ public InputStream retrieveSticker(final StickerPackId stickerPackId, final int stickerId) throws IOException {
+ throw new UnsupportedOperationException();
}
@SuppressWarnings("unchecked")
git.nmode.ca / signal-cli / blobdiff
