Mercury-IM/xmpp_core/src/main/java/org/mercury_im/messenger/xmpp_core/MercuryConnection.java

package org.mercury_im.messenger.xmpp_core;

import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.chat2.ChatManager;
import org.jivesoftware.smack.roster.Roster;
import org.jivesoftware.smack.sm.packet.StreamManagement;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import org.jivesoftware.smackx.carbons.CarbonManager;
import org.jivesoftware.smackx.csi.ClientStateIndicationManager;
import org.jivesoftware.smackx.sid.StableUniqueStanzaIdManager;

import java.util.logging.Logger;

public abstract class MercuryConnection implements ConnectionListener {

    public static final String TAG = "Mercury";

    private static final Logger LOGGER = Logger.getLogger(MercuryConnection.class.getName());

    protected final XMPPConnection connection;
    protected final long accountId;

    protected final Roster roster;
    protected final ChatManager chatManager;
    protected final CarbonManager carbonManager;
    protected final StableUniqueStanzaIdManager stanzaIdManager;

    protected ConnectionStateHolder stateHolder;

    public MercuryConnection(XMPPConnection connection, long accountId) {
        this.connection = connection;
        connection.addConnectionListener(this);
        this.accountId = accountId;

        this.roster = Roster.getInstanceFor(connection);
        this.chatManager = ChatManager.getInstanceFor(connection);
        this.carbonManager = CarbonManager.getInstanceFor(connection);
        this.stanzaIdManager = StableUniqueStanzaIdManager.getInstanceFor(connection);
        stanzaIdManager.enable();


        roster.setRosterLoadedAtLogin(true);
    }

    public XMPPConnection getConnection() {
        return connection;
    }

    public void setRosterHandler(RosterHandler handler) {
        roster.addRosterListener(handler);
        roster.addRosterLoadedListener(handler);
    }

    public void setPlainMessageHandler(PlainMessageHandler plainMessageHandler) {
        carbonManager.addCarbonCopyReceivedListener(plainMessageHandler);
        chatManager.addIncomingListener(plainMessageHandler);
        chatManager.addOutgoingListener(plainMessageHandler);
    }

    public abstract ConnectionStateHolder getState();

    public long getAccountId() {
        return accountId;
    }

    public Roster getRoster() {
        return roster;
    }

    @Override
    public void connected(XMPPConnection connection) {
        getState().updateConnectionState(ConnectionState.CONNECTED);
    }

    @Override
    public void authenticated(XMPPConnection connection, boolean resumed) {
        if (connection == this.connection && !resumed) {
            LOGGER.info("Enabling carbons!");
            carbonManager.enableCarbonsAsync(exception -> {
                LOGGER.severe("Could not enable carbons for connection " + accountId + ": " + exception.getMessage());
                exception.printStackTrace();
            });
        }
        getState().updateConnectionState(ConnectionState.CONNECTED);
    }

    @Override
    public void connectionClosed() {
        LOGGER.fine("Connection closed.");
        getState().updateConnectionState(ConnectionState.DISCONNECTED);
    }

    @Override
    public void connectionClosedOnError(Exception e) {
        LOGGER.severe("Connection closed on error: " + e.getMessage());
        e.printStackTrace();
        getState().updateConnectionState(ConnectionState.DISCONNECTED);
    }
}