Comment garder un XMPP connexion stable sur Android avec (a)smack?

En fait Il n'y a aucun problème avec la Reconnexion manager. Vous devez d'abord ajouter écoute de connexion à votre gestionnaire de connexion.

connection.addConnectionListener(new ConnectionListener() {

                    @Override
                    public void reconnectionSuccessful() {
                        Log.i("","Successfully reconnected to the XMPP server.");

                    }

                    @Override
                    public void reconnectionFailed(Exception arg0) {
                        Log.i("","Failed to reconnect to the XMPP server.");
                    }

                    @Override
                    public void reconnectingIn(int seconds) {
                        Log.i("","Reconnecting in " + seconds + " seconds.");
                    }

                    @Override
                    public void connectionClosedOnError(Exception arg0) {
                        Log.i("","Connection to XMPP server was lost.");
                    }

                    @Override
                    public void connectionClosed() {
                        Log.i("","XMPP connection was closed.");

                    }
                }); 

si une erreur s'est produite à la connectionClosedOnError(à l'Exception de arg0) sera appelée automatiquement
lorsque la connexion est fermée

 public void connectionClosed() {
                        Log.i("","XMPP connection was closed.");
                        //You can manually call reconnection code if you                  want to reconnect on any connection close
                    }

puis vérifier cela appel reconnectingin() la méthode et essayer de se reconnecter.

Espère que cela va vous aider.

utilisez code ci-dessous pour vérifier la connexion
PingManager pingManager = PingManager.getInstanceFor(connection); pingManager.setPingInterval(5000);

ajouter listner de ping échec de la manipulation de la poignée de connexion est connecté ou pas, parce isConnected méthode n'est pas fiable pour vérifier l'état de la connexion.

pingManager.registerPingFailedListener(PingFailedListener);

Pour une connectivité de réseau est très gros problème si vous avez besoin pour vérifier la connectivité réseau pour mobile à l'aide du récepteur de radiodiffusion et sur les données de la reconnexion, vous pouvez utiliser pingMyServer méthode pour vérifier la connexion est vivant ou pas, si vous devez recevoir de réponse ping à partir du serveur, des moyens de connexion est vivant sinon sur commande ping échoue, vous pouvez rétablir la connexion manuellement.

J'ai le même problème, sauf que Mon programme s'exécute sur le serveur côté de la JVM.

J'ai utilisé smack 4.0 en premier lieu. Puis j'ai mis à jour smack 4.1, mais le problème n'est toujours pas arrivé. Enfin j'ai trouvé un module de configuration: PingManager

Après l'utilisation de ce, de la survenance de cette situation a été déroulant.

    connection = new XMPPTCPConnection(config);     
PingManager pingManager = PingManager.getInstanceFor(connection);
pingManager.setPingInterval(300); //seconds

Pour ces cas, vous devez gérer la déconnexion manuelle je veux dire que vous devez intercepter toute déconnexion, connexion auditeur averti lorsque vous avez obtenu une déconnexion plus.

public void connectionClosedOnError(Sauf exception)

    import android.util.Log;
import com.dagm8.core.protocols.ConnectionState;
import com.dagm8.core.service.XMPPService;
import com.dagm8.events.ConnectionStateEvent;
import org.greenrobot.eventbus.EventBus;
import org.jivesoftware.smack.ConnectionListener;
import org.jivesoftware.smack.SmackException;
import org.jivesoftware.smack.XMPPConnection;
import org.jivesoftware.smack.XMPPException;
import org.jivesoftware.smack.tcp.XMPPTCPConnection;
import java.io.IOException;
import static com.dagm8.core.protocols.ConnectionState.CONNECTED;
import static com.dagm8.core.protocols.ConnectionState.DISCONNECTED;
import static com.dagm8.core.protocols.ConnectionState.RECONNECTING;
/**
* dagm8-android
* Created by Bedoy on 8/28/17.
*/
public class ConnectionController implements ConnectionListener {
private String TAG = getClass().getCanonicalName();
private XMPPTCPConnection mConnection;
public void setConnection(XMPPTCPConnection connection) {
mConnection = connection;
}
public void init(XMPPTCPConnection connection) throws InterruptedException, XMPPException, SmackException, IOException {
setConnection(connection);
mConnection.setPacketReplyTimeout(10000);
mConnection.addConnectionListener(this);
mConnection.connect();
}
@Override
public void connected(XMPPConnection connection) {
XMPPService.connectionState = RECONNECTING;
notifyConnectionState(RECONNECTING);
try {
mConnection.login();
} catch (XMPPException | SmackException | IOException | InterruptedException e) {
e.printStackTrace();
}
Log.i(TAG, "connected()");
}
@Override
public void authenticated(XMPPConnection connection, boolean resumed) {
XMPPService.connectionState = CONNECTED;
notifyConnectionState(CONNECTED);
Log.i(TAG, "authenticated()");
}
@Override
public void connectionClosed() {
XMPPService.connectionState = DISCONNECTED;
notifyConnectionState(DISCONNECTED);
Log.i(TAG, "connectionClosed()");
}
@Override
public void connectionClosedOnError(Exception e) {
XMPPService.connectionState = DISCONNECTED;
notifyConnectionState(DISCONNECTED);
try {
mConnection.connect();
} catch (SmackException | IOException | XMPPException | InterruptedException exception) {
exception.printStackTrace();
}
Log.i(TAG, "connectionClosedOnError()");
}
@Override
public void reconnectingIn(int seconds) {
XMPPService.connectionState = RECONNECTING;
notifyConnectionState(RECONNECTING);
Log.i(TAG, "reconnectingIn()");
}
@Override
public void reconnectionSuccessful() {
XMPPService.connectionState = CONNECTED;
notifyConnectionState(CONNECTED);
Log.i(TAG, "reconnectionSuccessful()");
}
@Override
public void reconnectionFailed(Exception e) {
XMPPService.connectionState = DISCONNECTED;
notifyConnectionState(DISCONNECTED);
Log.i(TAG, "reconnectionFailed()");
}
private void notifyConnectionState(ConnectionState state) {
EventBus.getDefault().post((ConnectionStateEvent) () -> state);
}
public boolean isAuthenticated()
{
return mConnection.isAuthenticated();
}
public void login() {
try {
mConnection.login();
} catch (XMPPException | SmackException | IOException | InterruptedException e) {
e.printStackTrace();
}
}
}