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

package org.mercury_im.messenger.xmpp;

import org.jivesoftware.smack.AbstractXMPPConnection;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.mercury_im.messenger.data.repository.AccountRepository;
import org.mercury_im.messenger.entity.Account;
import org.mercury_im.messenger.util.Optional;
import org.mercury_im.messenger.xmpp.state.ConnectionState;
import org.mercury_im.messenger.xmpp.state.ConnectivityState;

import java.io.IOException;
import java.util.UUID;
import java.util.logging.Level;
import java.util.logging.Logger;

import io.reactivex.Observable;
import io.reactivex.disposables.CompositeDisposable;
import io.reactivex.subjects.BehaviorSubject;
import lombok.Getter;

public class MercuryConnection {

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

    @Getter
    private XMPPConnection connection;

    @Getter
    private final UUID accountId;

    private final BehaviorSubject<ConnectionState> state;

    public MercuryConnection(XMPPConnection connection, Account account) {
        this.connection = connection;
        this.accountId = account.getId();

        this.state = BehaviorSubject.createDefault(new ConnectionState(accountId,
                ConnectivityState.disconnected, false, false));
    }


    public Observable<ConnectionState> observeConnection() {
        return state;
    }

    public void connect() throws InterruptedException, XMPPException, SmackException, IOException {
        if (getConnection().isConnected()) {
            return;
        }
        ((AbstractXMPPConnection) getConnection()).connect();
    }

    public void login() throws InterruptedException, IOException, SmackException, XMPPException {
        if (getConnection().isAuthenticated()) {
            return;
        }
        connect();
        ((AbstractXMPPConnection) getConnection()).login();
    }

    private final ConnectionListener connectionListener = new ConnectionListener() {
        @Override
        public void connected(XMPPConnection connection) {
            state.onNext(state.getValue()
                    .withConnectivity(ConnectivityState.connected)
                    .withAuthenticated(false));
        }

        @Override
        public void authenticated(XMPPConnection connection, boolean resumed) {
            state.onNext(state.getValue()
                    .withConnectivity(ConnectivityState.connected)
                    .withAuthenticated(true)
                    .withResumed(resumed));
        }

        @Override
        public void connectionClosed() {
            state.onNext(state.getValue()
                    .withConnectivity(ConnectivityState.disconnected)
                    .withAuthenticated(false));
        }

        @Override
        public void connectionClosedOnError(Exception e) {
            state.onNext(state.getValue()
                    .withConnectivity(ConnectivityState.disconnected)
                    .withAuthenticated(false));
        }
    };

    public void shutdown() {
        if (connection.isConnected()) {
            ((AbstractXMPPConnection) getConnection()).disconnect();
        } else {
            ((AbstractXMPPConnection) getConnection()).instantShutdown();
        }
    }
}