Mercury-IM/domain/src/main/java/org/mercury_im/messenger/Messenger.java

package org.mercury_im.messenger;

import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.roster.Roster;
import org.jivesoftware.smackx.csi.ClientStateIndicationManager;
import org.mercury_im.messenger.data.repository.Repositories;
import org.mercury_im.messenger.entity.Account;
import org.mercury_im.messenger.store.MercuryRosterStore;
import org.mercury_im.messenger.usecase.AddAccount;
import org.mercury_im.messenger.usecase.ConnectAccountsOnStartup;
import org.mercury_im.messenger.xmpp.MercuryConnection;

import java.util.HashMap;
import java.util.Map;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;

import javax.inject.Inject;

import io.reactivex.Scheduler;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.schedulers.Schedulers;

public class Messenger implements ClientStateListener {

    public static final String TAG = "MercuryIM";
    private static final Logger LOGGER = Logger.getLogger(Messenger.class.getName());

    private final Map<UUID, MercuryConnection> connections = new HashMap<>();
    private Repositories repositories;

    private CompositeDisposable disposable = new CompositeDisposable();

    @Inject
    public Messenger(Repositories repositories) {
        this.repositories = repositories;
        initialLogin();
    }

    public void initialLogin() {
        disposable.add(repositories.getAccountRepository().observeAllAccounts().firstOrError()
                .subscribeOn(Schedulers.newThread())
                .subscribe(initialAccounts -> ConnectAccountsOnStartup
                        .with(this, initialAccounts)
                        .execute()));
    }

    public void addConnection(MercuryConnection connection) {
        connections.put(connection.getAccount().getId(), connection);
        initRosterStore(connection);
    }

    private void initRosterStore(MercuryConnection connection) {
        Roster.getInstanceFor(connection.getConnection())
                .setRosterStore(new MercuryRosterStore(connection.getAccount(),
                        repositories.getPeerRepository(), repositories.getAccountRepository()));
    }

    public MercuryConnection getConnection(Account account) {
        return connections.get(account.getId());
    }

    public AddAccount addAccount() {
        return new AddAccount(repositories.getAccountRepository(), this);
    }

    // CSI

    @Override
    public void onClientInForeground() {
        LOGGER.log(Level.INFO, "CSI: active");
        for (MercuryConnection connection : connections.values()) {
            tryCsiActive(connection);
        }
    }

    @Override
    public void onClientInBackground() {
        LOGGER.log(Level.INFO, "CSI: inactive");
        for (MercuryConnection connection : connections.values()) {
            tryCsiInactive(connection);
        }
    }

    private void tryCsiActive(MercuryConnection connection) {
        try {
            ClientStateIndicationManager.active(connection.getConnection());
        } catch (SmackException.NotConnectedException | InterruptedException e) {
            LOGGER.log(Level.WARNING, "Sending CSI state 'active' failed.", e);
        }
    }

    private void tryCsiInactive(MercuryConnection connection) {
        try {
            ClientStateIndicationManager.inactive(connection.getConnection());
        } catch (SmackException.NotConnectedException | InterruptedException e) {
            LOGGER.log(Level.WARNING, "Sending CSI state 'inactive' failed.", e);
        }
    }
}