SMACK-412 Split the ping implementation to a server ping to replace keepalive and a simplified ping manager for manual pings of other entities.

git-svn-id: http://svn.igniterealtime.org/svn/repos/smack/branches/smack_3_3_0@13569 b35dd754-fafc-0310-a699-88a17e54d16e

source/org/jivesoftware/smack/Connection.java

@@ -178,12 +178,12 @@ public abstract class Connection {
     protected SmackDebugger debugger = null;
 
     /**
-     * The Reader which is used for the {@see debugger}.
+     * The Reader which is used for the debugger.
      */
     protected Reader reader;
 
     /**
-     * The Writer which is used for the {@see debugger}.
+     * The Writer which is used for the debugger.
      */
     protected Writer writer;
 

source/org/jivesoftware/smack/PacketWriter.java

@@ -40,18 +40,11 @@ import java.util.concurrent.BlockingQueue;
 class PacketWriter {
 
     private Thread writerThread;
-    private Thread keepAliveThread;
     private Writer writer;
     private XMPPConnection connection;
     private final BlockingQueue<Packet> queue;
     volatile boolean done;
 
-    /**
-     * Timestamp when the last stanza was sent to the server. This information is used
-     * by the keep alive process to only send heartbeats when the connection has been idle.
-     */
-    private long lastActive = System.currentTimeMillis();
-
     /**
      * Creates a new packet writer with the specified connection.
      *
@@ -117,25 +110,6 @@ class PacketWriter {
         writerThread.start();
     }
 
-    /**
-     * Starts the keep alive process. A white space (aka heartbeat) is going to be
-     * sent to the server every 30 seconds (by default) since the last stanza was sent
-     * to the server.
-     */
-    void startKeepAliveProcess() {
-        // Schedule a keep-alive task to run if the feature is enabled. will write
-        // out a space character each time it runs to keep the TCP/IP connection open.
-        int keepAliveInterval = SmackConfiguration.getKeepAliveInterval();
-        if (keepAliveInterval > 0) {
-            KeepAliveTask task = new KeepAliveTask(keepAliveInterval);
-            keepAliveThread = new Thread(task);
-            task.setThread(keepAliveThread);
-            keepAliveThread.setDaemon(true);
-            keepAliveThread.setName("Smack Keep Alive (" + connection.connectionCounterValue + ")");
-            keepAliveThread.start();
-        }
-    }
-
     void setWriter(Writer writer) {
         this.writer = writer;
     }
@@ -149,9 +123,6 @@ class PacketWriter {
         synchronized (queue) {
             queue.notifyAll();
         }
-        // Interrupt the keep alive thread if one was created
-        if (keepAliveThread != null)
-                keepAliveThread.interrupt();
     }
 
     /**
@@ -193,10 +164,9 @@ class PacketWriter {
                 if (packet != null) {
                     synchronized (writer) {
                         writer.write(packet.toXML());
+                        writer.flush();
                         if (queue.isEmpty()) {
                             writer.flush();
-                            // Keep track of the last time a stanza was sent to the server
-                            lastActive = System.currentTimeMillis();
                         }
                     }
                 }
@@ -268,54 +238,4 @@ class PacketWriter {
         writer.write(stream.toString());
         writer.flush();
     }
-
-    /**
-     * A TimerTask that keeps connections to the server alive by sending a space
-     * character on an interval.
-     */
-    private class KeepAliveTask implements Runnable {
-
-        private int delay;
-        private Thread thread;
-
-        public KeepAliveTask(int delay) {
-            this.delay = delay;
-        }
-
-        protected void setThread(Thread thread) {
-            this.thread = thread;
-        }
-        
-        public void run() {
-            try {
-                // Sleep a minimum of 15 seconds plus delay before sending first heartbeat. This will give time to
-                // properly finish TLS negotiation and then start sending heartbeats.
-                Thread.sleep(15000 + delay);
-            }
-            catch (InterruptedException ie) {
-                // Do nothing
-            }
-            while (!done && keepAliveThread == thread) {
-                synchronized (writer) {
-                    // Send heartbeat if no packet has been sent to the server for a given time
-                    if (System.currentTimeMillis() - lastActive >= delay) {
-                        try {
-                            writer.write(" ");
-                            writer.flush();
-                        }
-                        catch (Exception e) {
-                            // Do nothing
-                        }
-                    }
-                }
-                try {
-                    // Sleep until we should write the next keep-alive.
-                    Thread.sleep(delay);
-                }
-                catch (InterruptedException ie) {
-                    // Do nothing
-                }
-            }
-        }
-    }
 }

source/org/jivesoftware/smack/SmackConfiguration.java

@@ -58,11 +58,6 @@ public final class SmackConfiguration {
     private static int localSocks5ProxyPort = 7777;
     private static int packetCollectorSize = 5000;
 
-    /**
-     * defaultPingInterval (in seconds)
-     */
-    private static int defaultPingInterval = 1800; // 30 min (30*60)
-
     /**
      * This automatically enables EntityCaps for new connections if it is set to true
      */
@@ -117,9 +112,6 @@ public final class SmackConfiguration {
                                 else if (parser.getName().equals("packetCollectorSize")) {
                                     packetCollectorSize = parseIntProperty(parser, packetCollectorSize);
                                 }
-                                else if (parser.getName().equals("defaultPingInterval")) {
-                                    defaultPingInterval = parseIntProperty(parser, defaultPingInterval);
-                                }
                                 else if (parser.getName().equals("autoEnableEntityCaps")) {
                                     autoEnableEntityCaps = Boolean.parseBoolean(parser.nextText());
                                 }
@@ -319,24 +311,6 @@ public final class SmackConfiguration {
         SmackConfiguration.localSocks5ProxyPort = localSocks5ProxyPort;
     }
 
-    /**
-     * Returns the default ping interval (seconds)
-     * 
-     * @return
-     */
-    public static int getDefaultPingInterval() {
-        return defaultPingInterval;
-    }
-
-    /**
-     * Sets the default ping interval (seconds). Set it to '-1' to disable the periodic ping
-     *
-     * @param defaultPingInterval
-     */
-    public static void setDefaultPingInterval(int defaultPingInterval) {
-        SmackConfiguration.defaultPingInterval = defaultPingInterval;
-    }
-
     /**
      * Check if Entity Caps are enabled as default for every new connection
      * @return

source/org/jivesoftware/smack/XMPPConnection.java

@@ -650,10 +650,6 @@ public class XMPPConnection extends Connection {
             // Make note of the fact that we're now connected.
             connected = true;
 
-            // Start keep alive process (after TLS was negotiated - if available)
-            packetWriter.startKeepAliveProcess();
-
-
             if (isFirstInitialization) {
                 // Notify listeners that a new connection has been established
                 for (ConnectionCreationListener listener : getConnectionCreationListeners()) {

source/org/jivesoftware/smack/ping/PingFailedListener.java

@@ -14,8 +14,14 @@
  * limitations under the License.
  */
 
-package org.jivesoftware.smackx.ping;
+package org.jivesoftware.smack.ping;
 
+/**
+ * Defines the callback used whenever the server ping fails.
+ */
 public interface PingFailedListener {
+    /**
+     * Called when the server ping fails.
+     */
     void pingFailed();
 }

source/org/jivesoftware/smack/ping/ServerPingManager.java

@@ -0,0 +1,285 @@
+/**
+ * Copyright 2012-2013 Florian Schmaus
+ *
+ * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+package org.jivesoftware.smack.ping;
+
+import java.util.Collections;
+import java.util.HashSet;
+import java.util.Map;
+import java.util.Set;
+import java.util.WeakHashMap;
+import java.util.concurrent.ScheduledExecutorService;
+import java.util.concurrent.ScheduledFuture;
+import java.util.concurrent.ScheduledThreadPoolExecutor;
+import java.util.concurrent.ThreadFactory;
+import java.util.concurrent.TimeUnit;
+
+import org.jivesoftware.smack.Connection;
+import org.jivesoftware.smack.ConnectionCreationListener;
+import org.jivesoftware.smack.ConnectionListener;
+import org.jivesoftware.smack.PacketCollector;
+import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.SmackConfiguration;
+import org.jivesoftware.smack.XMPPException;
+import org.jivesoftware.smack.filter.AndFilter;
+import org.jivesoftware.smack.filter.IQTypeFilter;
+import org.jivesoftware.smack.filter.PacketFilter;
+import org.jivesoftware.smack.filter.PacketIDFilter;
+import org.jivesoftware.smack.filter.PacketTypeFilter;
+import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.packet.IQ.Type;
+import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.ping.packet.Ping;
+import org.jivesoftware.smackx.ServiceDiscoveryManager;
+
+/**
+ * Using an implementation of <a href="http://www.xmpp.org/extensions/xep-0199.html">XMPP Ping (XEP-0199)</a>. This
+ * class provides keepalive functionality with the server that will periodically "ping" the server to maintain and/or
+ * verify that the connection still exists.
+ * <p>
+ * The ping is done at the application level and is therefore protocol agnostic. It will thus work for both standard TCP
+ * connections as well as BOSH or any other transport protocol. It will also work regardless of whether the server
+ * supports the Ping extension, since an error response to the ping serves the same purpose as a pong.
+ * 
+ * @author Florian Schmaus
+ */
+public class ServerPingManager {
+    public static final long PING_MINIMUM = 10000;
+
+    private static Map<Connection, ServerPingManager> instances = Collections
+            .synchronizedMap(new WeakHashMap<Connection, ServerPingManager>());
+    private static long defaultPingInterval = SmackConfiguration.getKeepAliveInterval(); 
+    
+    private static ScheduledExecutorService periodicPingExecutorService = new ScheduledThreadPoolExecutor(1, new ThreadFactory() {
+        @Override
+        public Thread newThread(Runnable runnable) {
+            Thread pingThread = new Thread(runnable, "Smack Server Ping");
+            pingThread.setDaemon(true);
+            return pingThread;
+        }
+    });
+
+    static {
+        if (defaultPingInterval > 0) {
+            Connection.addConnectionCreationListener(new ConnectionCreationListener() {
+                public void connectionCreated(Connection connection) {
+                    new ServerPingManager(connection);
+                }
+            });
+        }
+    }
+
+    private Connection connection;
+    private long pingInterval = SmackConfiguration.getKeepAliveInterval();
+    private Set<PingFailedListener> pingFailedListeners = Collections.synchronizedSet(new HashSet<PingFailedListener>());
+    private volatile ScheduledFuture<?> periodicPingTask;
+    private volatile long lastSuccessfulContact = -1;
+
+    /**
+     * Retrieves a {@link ServerPingManager} for the specified {@link Connection}, creating one if it doesn't already
+     * exist.
+     * 
+     * @param connection
+     * The connection the manager is attached to.
+     * @return The new or existing manager.
+     */
+    public synchronized static ServerPingManager getInstanceFor(Connection connection) {
+        ServerPingManager pingManager = instances.get(connection);
+
+        if (pingManager == null) {
+            pingManager = new ServerPingManager(connection);
+        }
+        return pingManager;
+    }
+
+    private ServerPingManager(Connection connection) {
+        ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
+        sdm.addFeature(Ping.NAMESPACE);
+        this.connection = connection;
+        init();
+    }
+
+    private void init() {
+        PacketFilter pingPacketFilter = new AndFilter(new PacketTypeFilter(Ping.class), new IQTypeFilter(Type.GET));
+        
+        connection.addPacketListener(new PacketListener() {
+            /**
+             * Sends a Pong for every Ping
+             */
+            public void processPacket(Packet packet) {
+                IQ pong = IQ.createResultIQ((Ping) packet);
+                connection.sendPacket(pong);
+            }
+        }, pingPacketFilter);
+
+        connection.addConnectionListener(new ConnectionListener() {
+
+            @Override
+            public void connectionClosed() {
+                stopPingServerTask();
+            }
+
+            @Override
+            public void connectionClosedOnError(Exception arg0) {
+                stopPingServerTask();
+            }
+
+            @Override
+            public void reconnectionSuccessful() {
+                schedulePingServerTask();
+            }
+
+            @Override
+            public void reconnectingIn(int seconds) {
+            }
+
+            @Override
+            public void reconnectionFailed(Exception e) {
+            }
+        });
+
+        // Listen for all incoming packets and reset the scheduled ping whenever
+        // one arrives.
+        connection.addPacketListener(new PacketListener() {
+
+            @Override
+            public void processPacket(Packet packet) {
+                // reschedule the ping based on this last server contact
+                lastSuccessfulContact = System.currentTimeMillis();
+                schedulePingServerTask();
+            }
+        }, null);
+        instances.put(connection, this);
+        schedulePingServerTask();
+    }
+
+    /**
+     * Sets the ping interval.
+     * 
+     * @param pingInterval
+     * The new ping time interval in milliseconds.
+     */
+    public void setPingInterval(long newPingInterval) {
+        if (newPingInterval < PING_MINIMUM)
+            newPingInterval = PING_MINIMUM;
+
+        if (pingInterval != newPingInterval) {
+            pingInterval = newPingInterval;
+            schedulePingServerTask();
+        }
+    }
+
+    /**
+     * Stops pinging the server.  This cannot stop a ping that has already started, but will prevent another from being triggered.
+     * <p>
+     * To restart, call {@link #setPingInterval(long)}.
+     */
+    public void stopPinging() {
+        pingInterval = -1;
+        stopPingServerTask();
+    }
+    
+    /**
+     * Gets the ping interval.
+     * 
+     * @return The ping interval in milliseconds.
+     */
+    public long getPingInterval() {
+        return pingInterval;
+    }
+
+    /**
+     * Add listener for notification when a server ping fails.
+     * 
+     * <p>
+     * Please note that this doesn't necessarily mean that the connection is lost, a slow to respond server could also
+     * cause a failure due to taking too long to respond and thus causing a reply timeout.
+     * 
+     * @param listener
+     * The listener to be called
+     */
+    public void addPingFailedListener(PingFailedListener listener) {
+        pingFailedListeners.add(listener);
+    }
+
+    /**
+     * Remove the listener.
+     * 
+     * @param listener
+     * The listener to be removed.
+     */
+    public void removePingFailedListener(PingFailedListener listener) {
+        pingFailedListeners.remove(listener);
+    }
+
+    /**
+     * Returns the time of the last successful contact with the server. (i.e. the last time any message was received).
+     * 
+     * @return Time of last message or -1 if none has been received since manager was created.
+     */
+    public long getLastSuccessfulContact() {
+        return lastSuccessfulContact;
+    }
+
+    /**
+     * Cancels any existing periodic ping task if there is one and schedules a new ping task if pingInterval is greater
+     * then zero.
+     * 
+     * This is designed so only one executor is used for scheduling all pings on all connections.  This results in only 1 thread used for pinging.
+     */
+    private synchronized void schedulePingServerTask() {
+        stopPingServerTask();
+        
+        if (pingInterval > 0) {
+            periodicPingTask = periodicPingExecutorService.schedule(new Runnable() {
+                @Override
+                public void run() {
+                    Ping ping = new Ping();
+                    PacketFilter responseFilter = new PacketIDFilter(ping.getPacketID());
+                    final PacketCollector response = connection.createPacketCollector(responseFilter);
+                    connection.sendPacket(ping);
+        
+                    if (!pingFailedListeners.isEmpty()) {
+                        // Schedule a collector for the ping reply, notify listeners if none is received.
+                        periodicPingExecutorService.schedule(new Runnable() {
+                            @Override
+                            public void run() {
+                                Packet result = response.nextResult(1);
+                
+                                // Stop queuing results
+                                response.cancel();
+                
+                                // The actual result of the reply can be ignored since we only care if we actually got one.
+                                if (result == null) {
+                                    for (PingFailedListener listener : pingFailedListeners) {
+                                        listener.pingFailed();
+                                    }
+                                }
+                            }
+                        }, SmackConfiguration.getPacketReplyTimeout(), TimeUnit.MILLISECONDS);
+                    }
+                }
+            }, getPingInterval(), TimeUnit.MILLISECONDS);
+        }
+    }
+
+    private void stopPingServerTask() {
+        if (periodicPingTask != null) {
+            periodicPingTask.cancel(true);
+            periodicPingTask = null;
+        }
+    }
+}

source/org/jivesoftware/smack/ping/packet/Ping.java

@@ -14,25 +14,26 @@
  * limitations under the License.
  */
 
-package org.jivesoftware.smackx.ping.packet;
+package org.jivesoftware.smack.ping.packet;
 
 import org.jivesoftware.smack.packet.IQ;
 import org.jivesoftware.smackx.ping.PingManager;
 
 public class Ping extends IQ {
+
+    public static final String NAMESPACE = "urn:xmpp:ping";
+    public static final String ELEMENT = "ping";
     
     public Ping() {
     }
     
-    public Ping(String from, String to) {
+    public Ping(String to) {
         setTo(to);
-        setFrom(from);
         setType(IQ.Type.GET);
-        setPacketID(getPacketID());
     }
     
+    @Override
     public String getChildElementXML() {
-        return "<" + PingManager.ELEMENT + " xmlns=\'" + PingManager.NAMESPACE + "\' />";
+        return "<" + ELEMENT + " xmlns=\'" + NAMESPACE + "\' />";
     }
-
 }

source/org/jivesoftware/smack/ping/provider/PingProvider.java

@@ -14,11 +14,11 @@
  * limitations under the License.
  */
 
-package org.jivesoftware.smackx.ping.provider;
+package org.jivesoftware.smack.ping.provider;
 
 import org.jivesoftware.smack.packet.IQ;
+import org.jivesoftware.smack.ping.packet.Ping;
 import org.jivesoftware.smack.provider.IQProvider;
-import org.jivesoftware.smackx.ping.packet.Ping;
 import org.xmlpull.v1.XmlPullParser;
 
 public class PingProvider implements IQProvider {

source/org/jivesoftware/smack/util/SyncPacketSend.java

@@ -47,7 +47,7 @@ final public class SyncPacketSend
         response.cancel();
 
         if (result == null) {
-            throw new XMPPException("No response from server.");
+            throw new XMPPException("No response from " + packet.getTo());
         }
         else if (result.getError() != null) {
             throw new XMPPException(result.getError());

source/org/jivesoftware/smackx/ping/PingManager.java

@@ -16,328 +16,80 @@
 
 package org.jivesoftware.smackx.ping;
 
-import java.util.Collections;
-import java.util.HashSet;
-import java.util.Map;
-import java.util.Set;
-import java.util.WeakHashMap;
-import java.util.concurrent.ScheduledExecutorService;
-import java.util.concurrent.ScheduledFuture;
-import java.util.concurrent.ScheduledThreadPoolExecutor;
-import java.util.concurrent.TimeUnit;
-
 import org.jivesoftware.smack.Connection;
-import org.jivesoftware.smack.ConnectionCreationListener;
-import org.jivesoftware.smack.ConnectionListener;
-import org.jivesoftware.smack.PacketCollector;
-import org.jivesoftware.smack.PacketListener;
 import org.jivesoftware.smack.SmackConfiguration;
 import org.jivesoftware.smack.XMPPException;
-import org.jivesoftware.smack.filter.PacketFilter;
-import org.jivesoftware.smack.filter.PacketIDFilter;
-import org.jivesoftware.smack.filter.PacketTypeFilter;
-import org.jivesoftware.smack.packet.IQ;
-import org.jivesoftware.smack.packet.Packet;
+import org.jivesoftware.smack.ping.ServerPingManager;
+import org.jivesoftware.smack.ping.packet.Ping;
+import org.jivesoftware.smack.util.SyncPacketSend;
 import org.jivesoftware.smackx.ServiceDiscoveryManager;
 import org.jivesoftware.smackx.packet.DiscoverInfo;
-import org.jivesoftware.smackx.ping.packet.Ping;
-import org.jivesoftware.smackx.ping.packet.Pong;
 
 /**
- * Implements the XMPP Ping as defined by XEP-0199. This protocol offers an
- * alternative to the traditional 'white space ping' approach of determining the
- * availability of an entity. The XMPP Ping protocol allows ping messages to be
- * send in a more XML-friendly approach, which can be used over more than one
- * hop in the communication path.
+ * Implements the XMPP Ping as defined by XEP-0199.  The XMPP Ping protocol 
+ * allows one entity to 'ping' any other entity by simply sending a ping to 
+ * the appropriate JID.
+ * <p>
+ * NOTE: The {@link ServerPingManager} already provides a keepalive functionality 
+ * for regularly pinging the server to keep the underlying transport connection
+ * alive.  This class is specifically intended to do manual pings of other 
+ * entities.  
  * 
  * @author Florian Schmaus
  * @see <a href="http://www.xmpp.org/extensions/xep-0199.html">XEP-0199:XMPP
  *      Ping</a>
  */
 public class PingManager {
-
-    public static final String NAMESPACE = "urn:xmpp:ping";
-    public static final String ELEMENT = "ping";
-
-
-    private static Map<Connection, PingManager> instances =
-            Collections.synchronizedMap(new WeakHashMap<Connection, PingManager>());
-
-    static {
-        Connection.addConnectionCreationListener(new ConnectionCreationListener() {
-            public void connectionCreated(Connection connection) {
-                new PingManager(connection);
-            }
-        });
-    }
-
-    private ScheduledExecutorService periodicPingExecutorService;
     private Connection connection;
-    private int pingInterval = SmackConfiguration.getDefaultPingInterval();
-    private Set<PingFailedListener> pingFailedListeners = Collections
-            .synchronizedSet(new HashSet<PingFailedListener>());
-    private ScheduledFuture<?> periodicPingTask;
-    protected volatile long lastSuccessfulPingByTask = -1;
 
-
-    // Ping Flood protection
-    private long pingMinDelta = 100;
-    private long lastPingStamp = 0; // timestamp of the last received ping
-
-    // Timestamp of the last pong received, either from the server or another entity
-    // Note, no need to synchronize this value, it will only increase over time
-    private long lastSuccessfulManualPing = -1;
-
-    private PingManager(Connection connection) {
+    public PingManager(Connection connection) {
         ServiceDiscoveryManager sdm = ServiceDiscoveryManager.getInstanceFor(connection);
-        sdm.addFeature(NAMESPACE);
+        sdm.addFeature(Ping.NAMESPACE);
         this.connection = connection;
-        init();
     }
 
-    private void init() {
-        periodicPingExecutorService = new ScheduledThreadPoolExecutor(1);
-        PacketFilter pingPacketFilter = new PacketTypeFilter(Ping.class);
-        connection.addPacketListener(new PacketListener() {
-            /**
-             * Sends a Pong for every Ping
-             */
-            public void processPacket(Packet packet) {
-                if (pingMinDelta > 0) {
-                    // Ping flood protection enabled
-                    long currentMillies = System.currentTimeMillis();
-                    long delta = currentMillies - lastPingStamp;
-                    lastPingStamp = currentMillies;
-                    if (delta < pingMinDelta) {
-                        return;
-                    }
-                }
-                Pong pong = new Pong((Ping)packet);
-                connection.sendPacket(pong);
-            }
+    /**
+     * Pings the given jid. This method will return false if an error occurs.
+     * <p>
+     * Use {@link #isPingSupported(String)} to determine if XMPP Ping is supported 
+     * by the entity.
+     * 
+     * @param jid The id of the entity the ping is being sent to
+     * @param pingTimeout The time to wait for a reply
+     * @return true if a reply was received from the entity, false otherwise.
+     */
+    public boolean ping(String jid, long pingTimeout) {
+        Ping ping = new Ping(jid);
+        
+        try {
+            SyncPacketSend.getReply(connection, ping);
         }
-        , pingPacketFilter);
-        connection.addConnectionListener(new ConnectionListener() {
-
-            @Override
-            public void connectionClosed() {
-                maybeStopPingServerTask();
-            }
-
-            @Override
-            public void connectionClosedOnError(Exception arg0) {
-                maybeStopPingServerTask();
-            }
-
-            @Override
-            public void reconnectionSuccessful() {
-                maybeSchedulePingServerTask();
-            }
-
-            @Override
-            public void reconnectingIn(int seconds) {
-            }
-
-            @Override
-            public void reconnectionFailed(Exception e) {
-            }
-        });
-        instances.put(connection, this);
-        maybeSchedulePingServerTask();
-    }
-
-    public static PingManager getInstanceFor(Connection connection) {
-        PingManager pingManager = instances.get(connection);
-
-        if (pingManager == null) {
-            pingManager = new PingManager(connection);
+        catch (XMPPException exc) {
+            return false;
         }
-
-        return pingManager;
-    }
-
-    public void setPingIntervall(int pingIntervall) {
-        this.pingInterval = pingIntervall;
-    }
-
-    public int getPingIntervall() {
-        return pingInterval;
-    }
-    
-    public void registerPingFailedListener(PingFailedListener listener) {
-        pingFailedListeners.add(listener);
-    }
-    
-    public void unregisterPingFailedListener(PingFailedListener listener) {
-        pingFailedListeners.remove(listener);
-    }
-    
-    public void disablePingFloodProtection() {
-        setPingMinimumInterval(-1);
-    }
-    
-    public void setPingMinimumInterval(long ms) {
-        this.pingMinDelta = ms;
-    }
-    
-    public long getPingMinimumInterval() {
-        return this.pingMinDelta;
+        return true;
     }
     
     /**
-     * Pings the given jid and returns the IQ response which is either of 
-     * IQ.Type.ERROR or IQ.Type.RESULT. If we are not connected or if there was
-     * no reply, null is returned.
+     * Same as calling {@link #ping(String, long)} with the defaultpacket reply 
+     * timeout.
      * 
-     * You should use isPingSupported(jid) to determine if XMPP Ping is 
-     * supported by the user.
-     * 
-     * @param jid
-     * @param pingTimeout
-     * @return
+     * @param jid The id of the entity the ping is being sent to
+     * @return true if a reply was received from the entity, false otherwise.
      */
-    public IQ ping(String jid, long pingTimeout) {
-        // Make sure we actually connected to the server
-        if (!connection.isAuthenticated())
-            return null;
-        
-        Ping ping = new Ping(connection.getUser(), jid);
-        
-        PacketCollector collector =
-                connection.createPacketCollector(new PacketIDFilter(ping.getPacketID()));
-        
-        connection.sendPacket(ping);
-        
-        IQ result = (IQ) collector.nextResult(pingTimeout);
-        
-        collector.cancel();
-        return result;
-    }
-    
-    /**
-     * Pings the given jid and returns the IQ response with the default
-     * packet reply timeout
-     * 
-     * @param jid
-     * @return
-     */
-    public IQ ping(String jid) {
+    public boolean ping(String jid) {
         return ping(jid, SmackConfiguration.getPacketReplyTimeout());
     }
     
     /**
-     * Pings the given Entity.
+     * Query the specified entity to see if it supports the Ping protocol (XEP-0199)
      * 
-     * Note that XEP-199 shows that if we receive a error response
-     * service-unavailable there is no way to determine if the response was send
-     * by the entity (e.g. a user JID) or from a server in between. This is
-     * intended behavior to avoid presence leaks.
-     * 
-     * Always use isPingSupported(jid) to determine if XMPP Ping is supported
-     * by the entity.
-     * 
-     * @param jid
-     * @return True if a pong was received, otherwise false
+     * @param jid The id of the entity the query is being sent to
+     * @return true if it supports ping, false otherwise.
+     * @throws XMPPException An XMPP related error occurred during the request 
      */
-    public boolean pingEntity(String jid, long pingTimeout) {
-        IQ result = ping(jid, pingTimeout);
-
-        if (result == null || result.getType() == IQ.Type.ERROR) {
-            return false;
-        }
-        pongReceived();
-        return true;
-    }
-    
-    public boolean pingEntity(String jid) {
-        return pingEntity(jid, SmackConfiguration.getPacketReplyTimeout());
-    }
-    
-    /**
-     * Pings the user's server. Will notify the registered 
-     * pingFailedListeners in case of error.
-     * 
-     * If we receive as response, we can be sure that it came from the server.
-     * 
-     * @return true if successful, otherwise false
-     */
-    public boolean pingMyServer(long pingTimeout) {
-        IQ result = ping(connection.getServiceName(), pingTimeout);
-
-        if (result == null) {
-            for (PingFailedListener l : pingFailedListeners) {
-                l.pingFailed();
-            }
-            return false;
-        }
-        // Maybe not really a pong, but an answer is an answer
-        pongReceived();
-        return true;
-    }
-    
-    /**
-     * Pings the user's server with the PacketReplyTimeout as defined
-     * in SmackConfiguration.
-     * 
-     * @return true if successful, otherwise false
-     */
-    public boolean pingMyServer() {
-        return pingMyServer(SmackConfiguration.getPacketReplyTimeout());
-    }
-    
-    /**
-     * Returns true if XMPP Ping is supported by a given JID
-     * 
-     * @param jid
-     * @return
-     */
-    public boolean isPingSupported(String jid) {
-        try {
-            DiscoverInfo result =
-                ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(jid);
-            return result.containsFeature(NAMESPACE);
-        }
-        catch (XMPPException e) {
-            return false;
-        }
-    }
-    
-    /**
-     * Returns the time of the last successful Ping Pong with the 
-     * users server. If there was no successful Ping (e.g. because this
-     * feature is disabled) -1 will be returned.
-     *  
-     * @return
-     */
-    public long getLastSuccessfulPing() {
-        return Math.max(lastSuccessfulPingByTask, lastSuccessfulManualPing);
-    }
-    
-    protected Set<PingFailedListener> getPingFailedListeners() {
-        return pingFailedListeners;
-    }
-
-    /**
-     * Cancels any existing periodic ping task if there is one and schedules a new ping task if pingInterval is greater
-     * then zero.
-     * 
-     */
-    protected synchronized void maybeSchedulePingServerTask() {
-        maybeStopPingServerTask();
-        if (pingInterval > 0) {
-            periodicPingTask = periodicPingExecutorService.schedule(new ServerPingTask(connection), pingInterval,
-                    TimeUnit.SECONDS);
-        }
-    }
-
-    private void maybeStopPingServerTask() {
-        if (periodicPingTask != null) {
-            periodicPingTask.cancel(true);
-            periodicPingTask = null;
-        }
-    }
-
-    private void pongReceived() {
-        lastSuccessfulManualPing = System.currentTimeMillis();
+    public boolean isPingSupported(String jid) throws XMPPException {
+        DiscoverInfo result = ServiceDiscoveryManager.getInstanceFor(connection).discoverInfo(jid);
+        return result.containsFeature(Ping.NAMESPACE);
     }
 }

source/org/jivesoftware/smackx/ping/ServerPingTask.java

@@ -1,77 +0,0 @@
-/**
- * Copyright 2012-2013 Florian Schmaus
- *
- * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jivesoftware.smackx.ping;
-
-import java.lang.ref.WeakReference;
-import java.util.Set;
-
-import org.jivesoftware.smack.Connection;
-
-class ServerPingTask implements Runnable {
-
-    // This has to be a weak reference because IIRC all threads are roots
-    // for objects and we have a new thread here that should hold a strong
-    // reference to connection so that it can be GCed.
-    private WeakReference<Connection> weakConnection;
-
-    private int delta = 1000; // 1 seconds
-    private int tries = 3; // 3 tries
-
-    protected ServerPingTask(Connection connection) {
-        this.weakConnection = new WeakReference<Connection>(connection);
-    }
-
-    public void run() {
-        Connection connection = weakConnection.get();
-        if (connection == null) {
-            // connection has been collected by GC
-            // which means we can stop the thread by breaking the loop
-            return;
-        }
-        if (connection.isAuthenticated()) {
-            PingManager pingManager = PingManager.getInstanceFor(connection);
-            boolean res = false;
-
-            for (int i = 0; i < tries; i++) {
-                if (i != 0) {
-                    try {
-                        Thread.sleep(delta);
-                    } catch (InterruptedException e) {
-                        // We received an interrupt
-                        // This only happens if we should stop pinging
-                        return;
-                    }
-                }
-                res = pingManager.pingMyServer();
-                // stop when we receive a pong back
-                if (res) {
-                    pingManager.lastSuccessfulPingByTask = System.currentTimeMillis();
-                    break;
-                }
-            }
-            if (!res) {
-                Set<PingFailedListener> pingFailedListeners = pingManager.getPingFailedListeners();
-                for (PingFailedListener l : pingFailedListeners) {
-                    l.pingFailed();
-                }
-            } else {
-                // Ping was successful, wind-up the periodic task again
-                pingManager.maybeSchedulePingServerTask();
-            }
-        }
-    }
-}

source/org/jivesoftware/smackx/ping/packet/Pong.java

@@ -1,45 +0,0 @@
-/**
- * Copyright 2012 Florian Schmaus
- *
- * All rights reserved. Licensed under the Apache License, Version 2.0 (the "License");
- * you may not use this file except in compliance with the License.
- * You may obtain a copy of the License at
- *
- *     http://www.apache.org/licenses/LICENSE-2.0
- *
- * Unless required by applicable law or agreed to in writing, software
- * distributed under the License is distributed on an "AS IS" BASIS,
- * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
- * See the License for the specific language governing permissions and
- * limitations under the License.
- */
-
-package org.jivesoftware.smackx.ping.packet;
-
-import org.jivesoftware.smack.packet.IQ;
-
-public class Pong extends IQ {
-    
-    /**
-     * Composes a Pong packet from a received ping packet. This basically swaps
-     * the 'from' and 'to' attributes. And sets the IQ type to result.
-     * 
-     * @param ping
-     */
-    public Pong(Ping ping) {
-        setType(IQ.Type.RESULT);
-        setFrom(ping.getTo());
-        setTo(ping.getFrom());
-        setPacketID(ping.getPacketID());
-    }
-    
-    /*
-     * Returns the child element of the Pong reply, which is non-existent. This
-     * is why we return 'null' here. See e.g. Example 11 from
-     * http://xmpp.org/extensions/xep-0199.html#e2e
-     */
-    public String getChildElementXML() {
-        return null;
-    }
-
-}