261 lines
10 KiB
Java
261 lines
10 KiB
Java
package org.mercury_im.messenger.core.viewmodel.contact;
|
|
|
|
import org.jivesoftware.smack.SmackException;
|
|
import org.jivesoftware.smack.XMPPException;
|
|
import org.jivesoftware.smack.packet.Presence;
|
|
import org.jivesoftware.smack.roster.Roster;
|
|
import org.jivesoftware.smack.roster.RosterEntry;
|
|
import org.jivesoftware.smack.roster.RosterGroup;
|
|
import org.jivesoftware.smackx.ikey.util.IkeyTrust;
|
|
import org.jivesoftware.smackx.ox.store.definition.OpenPgpTrustStore;
|
|
import org.jxmpp.jid.EntityBareJid;
|
|
import org.jxmpp.jid.Jid;
|
|
import org.jxmpp.jid.impl.JidCreate;
|
|
import org.mercury_im.messenger.core.SchedulersFacade;
|
|
import org.mercury_im.messenger.core.connection.MercuryConnection;
|
|
import org.mercury_im.messenger.core.connection.MercuryConnectionManager;
|
|
import org.mercury_im.messenger.core.crypto.ikey.IkeyRepository;
|
|
import org.mercury_im.messenger.core.data.repository.DirectChatRepository;
|
|
import org.mercury_im.messenger.core.data.repository.OpenPgpRepository;
|
|
import org.mercury_im.messenger.core.data.repository.PeerRepository;
|
|
import org.mercury_im.messenger.core.util.CombinedPresenceListener;
|
|
import org.mercury_im.messenger.core.util.Optional;
|
|
import org.mercury_im.messenger.core.util.Tuple;
|
|
import org.mercury_im.messenger.core.viewmodel.MercuryViewModel;
|
|
import org.mercury_im.messenger.core.viewmodel.openpgp.FingerprintViewItem;
|
|
import org.mercury_im.messenger.entity.chat.Chat;
|
|
import org.mercury_im.messenger.entity.contact.Peer;
|
|
import org.pgpainless.key.OpenPgpV4Fingerprint;
|
|
|
|
import java.util.ArrayList;
|
|
import java.util.Collections;
|
|
import java.util.List;
|
|
import java.util.UUID;
|
|
|
|
import javax.inject.Inject;
|
|
|
|
import io.reactivex.Completable;
|
|
import io.reactivex.Observable;
|
|
import io.reactivex.Single;
|
|
import io.reactivex.subjects.BehaviorSubject;
|
|
import lombok.Getter;
|
|
|
|
public class ContactDetailViewModel implements MercuryViewModel {
|
|
|
|
private final MercuryConnectionManager connectionManager;
|
|
private final PeerRepository peerRepository;
|
|
private final DirectChatRepository directChatRepository;
|
|
private final OpenPgpRepository openPgpRepository;
|
|
private final IkeyRepository ikeyRepository;
|
|
private final SchedulersFacade schedulers;
|
|
|
|
private Roster roster;
|
|
private FilteredPresenceEventListener presenceEventListener;
|
|
|
|
private BehaviorSubject<EntityBareJid> contactAddress = BehaviorSubject.create();
|
|
private BehaviorSubject<String> contactDisplayName = BehaviorSubject.create();
|
|
private BehaviorSubject<EntityBareJid> contactAccountAddress = BehaviorSubject.create();
|
|
private BehaviorSubject<Presence.Mode> contactPresenceMode = BehaviorSubject.create();
|
|
private BehaviorSubject<String> contactPresenceStatus = BehaviorSubject.create();
|
|
private BehaviorSubject<List<String>> contactGroups = BehaviorSubject.create();
|
|
private BehaviorSubject<Optional<FingerprintViewItem>> contactIdentityFingerprint = BehaviorSubject.createDefault(new Optional<>());
|
|
private BehaviorSubject<List<FingerprintViewItem>> contactDeviceFingerprints = BehaviorSubject.createDefault(Collections.emptyList());
|
|
private BehaviorSubject<Tuple<String, EntityBareJid>> contactAvatarBase = BehaviorSubject.create();
|
|
|
|
@Getter
|
|
private UUID peerId;
|
|
|
|
@Getter
|
|
private UUID accountId;
|
|
|
|
@Inject
|
|
public ContactDetailViewModel(MercuryConnectionManager connectionManager,
|
|
PeerRepository peerRepository,
|
|
DirectChatRepository directChatRepository,
|
|
OpenPgpRepository openPgpRepository,
|
|
IkeyRepository ikeyRepository,
|
|
SchedulersFacade schedulers) {
|
|
this.connectionManager = connectionManager;
|
|
this.peerRepository = peerRepository;
|
|
this.directChatRepository = directChatRepository;
|
|
this.openPgpRepository = openPgpRepository;
|
|
this.ikeyRepository = ikeyRepository;
|
|
this.schedulers = schedulers;
|
|
}
|
|
|
|
public Completable init(UUID peerId) {
|
|
return peerRepository.getPeer(peerId)
|
|
.flatMapCompletable(this::init);
|
|
}
|
|
|
|
public Completable init(Peer peer) {
|
|
return Completable.fromAction(() -> {
|
|
this.peerId = peer.getId();
|
|
this.accountId = peer.getAccount().getId();
|
|
|
|
MercuryConnection connection = connectionManager.getConnection(peer.getAccount());
|
|
roster = Roster.getInstanceFor(connection.getConnection());
|
|
setupPresenceEventListener(roster, peer.getJid());
|
|
|
|
addDisposable(peerRepository
|
|
.observePeer(peerId)
|
|
.filter(Optional::isPresent)
|
|
.map(Optional::getItem)
|
|
.compose(schedulers.executeUiSafeObservable())
|
|
.subscribe(p -> {
|
|
contactAddress.onNext(peer.getJid());
|
|
contactDisplayName.onNext(peer.getDisplayName());
|
|
contactAccountAddress.onNext(peer.getAccount().getJid());
|
|
contactAvatarBase.onNext(new Tuple<>(peer.getDisplayName(), peer.getJid()));
|
|
}));
|
|
|
|
addDisposable(openPgpRepository
|
|
.observeFingerprints(peer.getAccount().getId(), peer.getJid())
|
|
.compose(schedulers.executeUiSafeObservable())
|
|
.subscribe(fingerprints -> contactDeviceFingerprints.onNext(fingerprints)));
|
|
|
|
addDisposable(ikeyRepository
|
|
.loadRecord(peer.getAccount().getId(), peer.getJid())
|
|
.compose(schedulers.executeUiSafeObservable())
|
|
.map(record -> new FingerprintViewItem(
|
|
peer.getAccount().getId(), record.getJid(),
|
|
new OpenPgpV4Fingerprint(record.getSuperordinate()),
|
|
record.getTimestamp(), record.getTimestamp(),
|
|
OpenPgpTrustStore.Trust.trusted) // TODO
|
|
)
|
|
.map(Optional::new)
|
|
.subscribe(contactIdentityFingerprint::onNext));
|
|
});
|
|
}
|
|
|
|
private void setupPresenceEventListener(Roster roster, EntityBareJid jid) {
|
|
if (presenceEventListener != null) {
|
|
if (presenceEventListener.getJid().equals(jid)) {
|
|
// already set up
|
|
return;
|
|
}
|
|
// outdated listener from previous contact
|
|
roster.removePresenceEventListener(presenceEventListener);
|
|
}
|
|
|
|
presenceEventListener = new FilteredPresenceEventListener(jid) {
|
|
@Override
|
|
public void presenceReceived(Presence presence) {
|
|
contactPresenceMode.onNext(presence.getMode());
|
|
if (presence.getStatus() != null) {
|
|
contactPresenceStatus.onNext(presence.getStatus());
|
|
}
|
|
|
|
RosterEntry entry = roster.getEntry(jid);
|
|
if (entry == null) {
|
|
return;
|
|
}
|
|
|
|
List<RosterGroup> groups = entry.getGroups();
|
|
List<String> groupNames = new ArrayList<>(groups.size());
|
|
for (RosterGroup group : groups) {
|
|
groupNames.add(group.getName());
|
|
}
|
|
contactGroups.onNext(groupNames);
|
|
}
|
|
};
|
|
// Trigger once
|
|
Presence presence = roster.getPresence(jid);
|
|
if (presence != null) {
|
|
presenceEventListener.presenceReceived(presence);
|
|
}
|
|
|
|
roster.addPresenceEventListener(presenceEventListener);
|
|
}
|
|
|
|
public Observable<EntityBareJid> getContactAddress() {
|
|
return contactAddress;
|
|
}
|
|
|
|
public Observable<String> getContactDisplayName() {
|
|
return contactDisplayName;
|
|
}
|
|
|
|
public Observable<EntityBareJid> getContactAccountAddress() {
|
|
return contactAccountAddress;
|
|
}
|
|
|
|
public Observable<Presence.Mode> getContactPresenceMode() {
|
|
return contactPresenceMode;
|
|
}
|
|
|
|
public Observable<String> getContactPresenceStatus() {
|
|
return contactPresenceStatus;
|
|
}
|
|
|
|
public Observable<List<String>> getContactGroups() {
|
|
return contactGroups;
|
|
}
|
|
|
|
public Observable<Optional<FingerprintViewItem>> getContactIdentityFingerprint() {
|
|
return contactIdentityFingerprint;
|
|
}
|
|
|
|
public Observable<List<FingerprintViewItem>> getContactDeviceFingerprints() {
|
|
return contactDeviceFingerprints;
|
|
}
|
|
|
|
public Observable<Tuple<String, EntityBareJid>> getContactAvatarBase() {
|
|
return contactAvatarBase;
|
|
}
|
|
|
|
public Single<UUID> getOrCreateChat() {
|
|
return peerRepository.getPeer(peerId)
|
|
.flatMapSingle(directChatRepository::getOrCreateChatWithPeer)
|
|
.map(Chat::getId);
|
|
}
|
|
|
|
public void changeContactName(String newName)
|
|
throws XMPPException.XMPPErrorException, SmackException.NotConnectedException,
|
|
InterruptedException, SmackException.NoResponseException {
|
|
if (!newName.trim().isEmpty()) {
|
|
RosterEntry entry = roster.getEntry(contactAddress.getValue());
|
|
entry.setName(newName);
|
|
}
|
|
}
|
|
|
|
public void markDeviceFingerprintTrusted(OpenPgpV4Fingerprint fingerprint, boolean checked) {
|
|
openPgpRepository.storeTrust(accountId, contactAddress.getValue(), fingerprint,
|
|
checked ? OpenPgpTrustStore.Trust.trusted : OpenPgpTrustStore.Trust.untrusted)
|
|
.subscribe();
|
|
}
|
|
|
|
public void markIkeyFingerprintTrusted(OpenPgpV4Fingerprint fingerprint, EntityBareJid owner, boolean isChecked) {
|
|
IkeyTrust trust = new IkeyTrust();
|
|
trust.setTrust(isChecked ? OpenPgpTrustStore.Trust.trusted : OpenPgpTrustStore.Trust.untrusted);
|
|
ikeyRepository.storeSuperordinateTrust(accountId, owner, fingerprint, trust)
|
|
.subscribe();
|
|
}
|
|
|
|
public static abstract class FilteredPresenceEventListener extends CombinedPresenceListener {
|
|
|
|
@Getter
|
|
private final EntityBareJid jid;
|
|
|
|
public FilteredPresenceEventListener(EntityBareJid jid) {
|
|
this.jid = jid;
|
|
}
|
|
|
|
@Override
|
|
public void presenceReceived(Jid address, Presence presence) {
|
|
EntityBareJid entityBareJid = address.asEntityBareJidIfPossible();
|
|
if (entityBareJid != null && entityBareJid.equals(jid)) {
|
|
presenceReceived(presence);
|
|
}
|
|
}
|
|
|
|
public abstract void presenceReceived(Presence presence);
|
|
}
|
|
|
|
@Override
|
|
public void dispose() {
|
|
compositeDisposable.dispose();
|
|
if (presenceEventListener != null) roster.removePresenceEventListener(presenceEventListener);
|
|
}
|
|
}
|