Add AbstractDebugger and JulDebugger

there was a lot of duplicate code in ConsoleDebugger and
AndroidDebugger, which resides now in AbstractDebugger. Those two and
the new JulDebugger subclass AbstractDebugger.

smack-android/src/main/java/org/jivesoftware/smackx/debugger/android/AndroidDebugger.java

@@ -16,16 +16,8 @@
  */
 package org.jivesoftware.smackx.debugger.android;
 
-import org.jivesoftware.smack.debugger.SmackDebugger;
-import org.jivesoftware.smack.AbstractConnectionListener;
-import org.jivesoftware.smack.ConnectionListener;
-import org.jivesoftware.smack.PacketListener;
+import org.jivesoftware.smack.debugger.AbstractDebugger;
 import org.jivesoftware.smack.XMPPConnection;
-import org.jivesoftware.smack.packet.Packet;
-import org.jivesoftware.smack.util.ObservableReader;
-import org.jivesoftware.smack.util.ObservableWriter;
-import org.jivesoftware.smack.util.ReaderListener;
-import org.jivesoftware.smack.util.WriterListener;
 
 import android.util.Log;
 
@@ -33,145 +25,24 @@ import java.io.Reader;
 import java.io.Writer;
 
 /**
- * Very simple debugger that prints to the android log the sent and received stanzas. Use
- * this debugger with caution since printing to the console is an expensive operation that may
- * even block the thread since only one thread may print at a time.<p>
- * <p/>
+ * Very simple debugger that prints to the android log the sent and received stanzas.
+ * <p>
+ * Only use this debugger if really required, Android has a good java.util.logging
+ * implementation, therefore {@link org.jivesoftware.smack.debugger.JulDebugger} is preferred.
+ * </p>
  * It is possible to not only print the raw sent and received stanzas but also the interpreted
  * packets by Smack. By default interpreted packets won't be printed. To enable this feature
  * just change the <tt>printInterpreted</tt> static variable to <tt>true</tt>.
  *
  */
-public class AndroidDebugger implements SmackDebugger {
-
-    public static boolean printInterpreted = false;
-
-    private XMPPConnection connection = null;
-
-    private PacketListener listener = null;
-    private ConnectionListener connListener = null;
-
-    private Writer writer;
-    private Reader reader;
-    private ReaderListener readerListener;
-    private WriterListener writerListener;
+public class AndroidDebugger extends AbstractDebugger {
 
     public AndroidDebugger(XMPPConnection connection, Writer writer, Reader reader) {
-        this.connection = connection;
-        this.writer = writer;
-        this.reader = reader;
-        createDebug();
+        super(connection, writer, reader);
     }
 
-    /**
-     * Creates the listeners that will print in the console when new activity is detected.
-     */
-    private void createDebug() {
-        // Create a special Reader that wraps the main Reader and logs data to the GUI.
-        ObservableReader debugReader = new ObservableReader(reader);
-        readerListener = new ReaderListener() {
-            public void read(String str) {
-                Log.d("SMACK", "RCV (" + connection.getConnectionCounter() +
-                        "): " + str);
-            }
-        };
-        debugReader.addReaderListener(readerListener);
-
-        // Create a special Writer that wraps the main Writer and logs data to the GUI.
-        ObservableWriter debugWriter = new ObservableWriter(writer);
-        writerListener = new WriterListener() {
-            public void write(String str) {
-                Log.d("SMACK", "SENT (" + connection.getConnectionCounter() +
-                        "): " + str);
-            }
-        };
-        debugWriter.addWriterListener(writerListener);
-
-        // Assign the reader/writer objects to use the debug versions. The packet reader
-        // and writer will use the debug versions when they are created.
-        reader = debugReader;
-        writer = debugWriter;
-
-        // Create a thread that will listen for all incoming packets and write them to
-        // the GUI. This is what we call "interpreted" packet data, since it's the packet
-        // data as Smack sees it and not as it's coming in as raw XML.
-        listener = new PacketListener() {
-            public void processPacket(Packet packet) {
-                if (printInterpreted) {
-                    Log.d("SMACK", "RCV PKT (" + connection.getConnectionCounter() +
-                            "): " + packet.toXML());
-                }
-            }
-        };
-
-        connListener = new AbstractConnectionListener() {
-            public void connectionClosed() {
-                Log.d("SMACK", "Connection closed (" + connection.getConnectionCounter() + ")");
-            }
-
-            public void connectionClosedOnError(Exception e) {
-                Log.d("SMACK", "Connection closed due to an exception (" +
-                        connection.getConnectionCounter() + ")");
-            }
-            public void reconnectionFailed(Exception e) {
-                Log.d("SMACK", "Reconnection failed due to an exception (" +
-                        connection.getConnectionCounter() + ")");
-            }
-            public void reconnectionSuccessful() {
-                Log.d("SMACK", "Connection reconnected (" +
-                        connection.getConnectionCounter() + ")");
-            }
-            public void reconnectingIn(int seconds) {
-                Log.d("SMACK", "Connection (" + connection.getConnectionCounter() +
-                        ") will reconnect in " + seconds);
-            }
-        };
-    }
-
-    public Reader newConnectionReader(Reader newReader) {
-        ((ObservableReader)reader).removeReaderListener(readerListener);
-        ObservableReader debugReader = new ObservableReader(newReader);
-        debugReader.addReaderListener(readerListener);
-        reader = debugReader;
-        return reader;
-    }
-
-    public Writer newConnectionWriter(Writer newWriter) {
-        ((ObservableWriter)writer).removeWriterListener(writerListener);
-        ObservableWriter debugWriter = new ObservableWriter(newWriter);
-        debugWriter.addWriterListener(writerListener);
-        writer = debugWriter;
-        return writer;
-    }
-
-    public void userHasLogged(String user) {
-        String title =
-                "User logged (" + connection.getConnectionCounter() + "): "
-                + user
-                + "@"
-                + connection.getServiceName()
-                + ":"
-                + connection.getPort();
-        Log.d("SMACK", title);
-        // Add the connection listener to the connection so that the debugger can be notified
-        // whenever the connection is closed.
-        connection.addConnectionListener(connListener);
-    }
-
-    public Reader getReader() {
-        return reader;
-    }
-
-    public Writer getWriter() {
-        return writer;
-    }
-
-    public PacketListener getReaderListener() {
-        return listener;
-    }
-
-    public PacketListener getWriterListener() {
-        return null;
+    @Override
+    protected void log(String logMessage) {
+                Log.d("SMACK", logMessage);
     }
 }
-