Moved UI code around, removed unnecessary object allocation/deallocation from connection

app/src/main/java/de/kuschku/libquassel/Client.java

@@ -23,6 +23,8 @@ import de.kuschku.libquassel.syncables.types.BufferSyncer;
 import de.kuschku.libquassel.syncables.types.BufferViewManager;
 import de.kuschku.libquassel.syncables.types.Network;
 import de.kuschku.libquassel.syncables.types.SyncableObject;
+import de.kuschku.util.backports.Optional;
+import de.kuschku.util.backports.Optionals;
 import de.kuschku.util.backports.Stream;
 
 
@@ -101,7 +103,13 @@ public class Client {
     }
 
     public void __objectRenamed__(String className, String newName, String oldName) {
-        getObjectByIdentifier(className, oldName).renameObject(newName);
+        safeGetObjectByIdentifier(className, oldName).renameObject(newName);
+    }
+
+    private SyncableObject safeGetObjectByIdentifier(String className, String oldName) {
+        SyncableObject val = getObjectByIdentifier(className, oldName);
+        if (val == null) throw new IllegalArgumentException(String.format("Object %s::%s does not exist", className, oldName));
+        else return val;
     }
 
     public SyncableObject getObjectByIdentifier(final String className, final String objectName) {

app/src/main/java/de/kuschku/libquassel/CoreConnection.java

 package de.kuschku.libquassel;
 
 
+import android.util.Log;
+
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.Socket;
@@ -15,6 +17,7 @@ import java.util.logging.Level;
 import java.util.logging.Logger;
 
 import de.kuschku.libquassel.events.ConnectionChangeEvent;
+import de.kuschku.libquassel.events.GeneralErrorEvent;
 import de.kuschku.libquassel.events.HandshakeFailedEvent;
 import de.kuschku.libquassel.functions.types.HandshakeFunction;
 import de.kuschku.libquassel.objects.types.ClientInit;
@@ -175,7 +178,7 @@ public class CoreConnection {
                         final ByteBuffer buffer = ByteBuffer.allocate(4);
                         getChannel().read(buffer);
 
-                        final Protocol protocol = new ProtocolSerializer().deserialize(buffer);
+                        final Protocol protocol = ProtocolSerializer.get().deserialize(buffer);
 
                         // Wrap socket in deflater if compression is enabled
                         setCompression(protocol.protocolFlags.supportsCompression);
@@ -210,9 +213,9 @@ public class CoreConnection {
                     }
                 }
             } catch (SocketException e) {
-                Logger.getLogger("libquassel").log(Level.FINEST, "Socket closed while reading");
-            } catch (IOException e) {
-                e.printStackTrace();
+                Log.e("libquassel", "Socket closed while reading");
+            } catch (Exception e) {
+                busProvider.sendEvent(new GeneralErrorEvent(e));
             }
         }
     }

app/src/main/java/de/kuschku/libquassel/backlogmanagers/BacklogManager.java

@@ -7,7 +7,8 @@ import java.util.List;
 
 import de.kuschku.libquassel.message.Message;
 import de.kuschku.libquassel.syncables.types.SyncableObject;
-import de.kuschku.util.ObservableList;
+import de.kuschku.util.observablelists.AutoScroller;
+import de.kuschku.util.observablelists.ObservableSortedList;
 
 public abstract class BacklogManager extends SyncableObject {
     public abstract void requestBacklog(int bufferId, int from, int to, int count, int extra);
@@ -16,9 +17,9 @@ public abstract class BacklogManager extends SyncableObject {
 
     public abstract void displayMessage(int bufferId, Message message);
 
-    public abstract ObservableList<Message> get(int bufferId);
+    public abstract ObservableSortedList<Message> get(int bufferId);
 
-    public abstract void bind(int bufferId, @Nullable RecyclerView.Adapter adapter);
+    public abstract void bind(int bufferId, @Nullable RecyclerView.Adapter adapter, AutoScroller scroller);
 
     public abstract void requestMoreBacklog(int bufferId, int count);
 }

app/src/main/java/de/kuschku/libquassel/backlogmanagers/SimpleBacklogManager.java

@@ -15,10 +15,12 @@ import de.kuschku.libquassel.functions.types.InitDataFunction;
 import de.kuschku.libquassel.functions.types.SyncFunction;
 import de.kuschku.libquassel.message.Message;
 import de.kuschku.libquassel.primitives.types.QVariant;
-import de.kuschku.util.ObservableList;
+import de.kuschku.util.observablelists.AutoScroller;
+import de.kuschku.util.observablelists.ObservableSortedList;
+import de.kuschku.util.observablelists.RecyclerViewAdapterCallback;
 
 public class SimpleBacklogManager extends BacklogManager {
-    SparseArray<ObservableList<Message>> backlogs = new SparseArray<>();
+    SparseArray<ObservableSortedList<Message>> backlogs = new SparseArray<>();
     private BusProvider busProvider;
 
     public SimpleBacklogManager(BusProvider busProvider) {
@@ -46,27 +48,27 @@ public class SimpleBacklogManager extends BacklogManager {
         get(bufferId).list.add(message);
     }
 
-    public void bind(int bufferId, @Nullable RecyclerView.Adapter adapter) {
+    public void bind(int bufferId, @Nullable RecyclerView.Adapter adapter, AutoScroller scroller) {
         if (adapter == null)
             get(bufferId).setCallback(null);
         else
-            get(bufferId).setCallback(new ObservableList.RecyclerViewAdapterCallback(adapter));
+            get(bufferId).setCallback(new RecyclerViewAdapterCallback(adapter, scroller));
     }
 
     @Override
     public void requestMoreBacklog(int bufferId, int count) {
-        ObservableList<Message> backlog = backlogs.get(bufferId);
+        ObservableSortedList<Message> backlog = backlogs.get(bufferId);
         int messageId =
                 (backlog == null) ? -1 :
-                (backlog.first() == null) ? -1 :
-                backlog.first().messageId;
+                (backlog.last() == null) ? -1 :
+                backlog.last().messageId;
 
         requestBacklog(bufferId, -1, messageId, count, 0);
     }
 
-    public ObservableList<Message> get(int bufferId) {
+    public ObservableSortedList<Message> get(int bufferId) {
         if (backlogs.get(bufferId) == null)
-            backlogs.put(bufferId, new ObservableList<>(Message.class));
+            backlogs.put(bufferId, new ObservableSortedList<>(Message.class, true));
 
         return backlogs.get(bufferId);
     }

app/src/main/java/de/kuschku/libquassel/functions/serializers/InitDataFunctionSerializer.java

@@ -7,12 +7,21 @@ import de.kuschku.libquassel.functions.types.PackedInitDataFunction;
 import de.kuschku.libquassel.functions.types.UnpackedInitDataFunction;
 
 public class InitDataFunctionSerializer implements FunctionSerializer<InitDataFunction> {
+    private static final InitDataFunctionSerializer serializer = new InitDataFunctionSerializer();
+
+    private InitDataFunctionSerializer() {
+    }
+
+    public static InitDataFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final InitDataFunction data) {
         if (data instanceof UnpackedInitDataFunction) {
-            return new PackedInitDataFunctionSerializer().serialize((UnpackedInitDataFunction) data);
+            return PackedInitDataFunctionSerializer.get().serialize((UnpackedInitDataFunction) data);
         } else if (data instanceof PackedInitDataFunction) {
-            return new UnpackedInitDataFunctionSerializer().serialize((PackedInitDataFunction) data);
+            return UnpackedInitDataFunctionSerializer.get().serialize((PackedInitDataFunction) data);
         } else {
             throw new IllegalArgumentException("Can not be applied to these arguments");
         }

app/src/main/java/de/kuschku/libquassel/functions/serializers/InitRequestFunctionSerializer.java

@@ -11,6 +11,15 @@ import de.kuschku.libquassel.primitives.types.QVariant;
 import static de.kuschku.libquassel.primitives.QMetaType.Type.QByteArray;
 
 public class InitRequestFunctionSerializer implements FunctionSerializer<InitRequestFunction> {
+    private static final InitRequestFunctionSerializer serializer = new InitRequestFunctionSerializer();
+
+    private InitRequestFunctionSerializer() {
+    }
+
+    public static InitRequestFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final InitRequestFunction data) {
         return Lists.newArrayList(

app/src/main/java/de/kuschku/libquassel/functions/serializers/PackedInitDataFunctionSerializer.java

@@ -9,6 +9,15 @@ import de.kuschku.libquassel.primitives.types.QVariant;
 import de.kuschku.libquassel.protocols.DatastreamPeer;
 
 public class PackedInitDataFunctionSerializer implements FunctionSerializer<UnpackedInitDataFunction> {
+    private static final PackedInitDataFunctionSerializer serializer = new PackedInitDataFunctionSerializer();
+
+    private PackedInitDataFunctionSerializer() {
+    }
+
+    public static PackedInitDataFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final UnpackedInitDataFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/functions/serializers/PackedRpcCallFunctionSerializer.java

@@ -10,6 +10,15 @@ import de.kuschku.libquassel.primitives.types.QVariant;
 import de.kuschku.libquassel.protocols.DatastreamPeer;
 
 public class PackedRpcCallFunctionSerializer implements FunctionSerializer<RpcCallFunction> {
+    private static final PackedRpcCallFunctionSerializer serializer = new PackedRpcCallFunctionSerializer();
+
+    private PackedRpcCallFunctionSerializer() {
+    }
+
+    public static PackedRpcCallFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final RpcCallFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/functions/serializers/PackedSyncFunctionSerializer.java

@@ -10,6 +10,15 @@ import de.kuschku.libquassel.primitives.types.QVariant;
 import de.kuschku.libquassel.protocols.DatastreamPeer;
 
 public class PackedSyncFunctionSerializer implements FunctionSerializer<SyncFunction> {
+    private static final PackedSyncFunctionSerializer serializer = new PackedSyncFunctionSerializer();
+
+    private PackedSyncFunctionSerializer() {
+    }
+
+    public static PackedSyncFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final SyncFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/functions/serializers/UnpackedInitDataFunctionSerializer.java

@@ -9,6 +9,15 @@ import de.kuschku.libquassel.functions.types.PackedInitDataFunction;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class UnpackedInitDataFunctionSerializer implements FunctionSerializer<PackedInitDataFunction> {
+    private static final UnpackedInitDataFunctionSerializer serializer = new UnpackedInitDataFunctionSerializer();
+
+    private UnpackedInitDataFunctionSerializer() {
+    }
+
+    public static UnpackedInitDataFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final PackedInitDataFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/functions/serializers/UnpackedRpcCallFunctionSerializer.java

@@ -9,6 +9,15 @@ import de.kuschku.libquassel.primitives.QMetaType;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class UnpackedRpcCallFunctionSerializer implements FunctionSerializer<RpcCallFunction> {
+    private static final UnpackedRpcCallFunctionSerializer serializer = new UnpackedRpcCallFunctionSerializer();
+
+    private UnpackedRpcCallFunctionSerializer() {
+    }
+
+    public static UnpackedRpcCallFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final RpcCallFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/functions/serializers/UnpackedSyncFunctionSerializer.java

@@ -9,6 +9,15 @@ import de.kuschku.libquassel.primitives.QMetaType;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class UnpackedSyncFunctionSerializer implements FunctionSerializer<SyncFunction> {
+    private static final UnpackedSyncFunctionSerializer serializer = new UnpackedSyncFunctionSerializer();
+
+    private UnpackedSyncFunctionSerializer() {
+    }
+
+    public static UnpackedSyncFunctionSerializer get() {
+        return serializer;
+    }
+
     @Override
     public List serialize(final SyncFunction data) {
         final List func = new ArrayList<>();

app/src/main/java/de/kuschku/libquassel/message/Message.java

@@ -8,7 +8,7 @@ import java.io.Serializable;
 import java.util.Comparator;
 
 import de.kuschku.libquassel.primitives.types.BufferInfo;
-import de.kuschku.util.ContentComparable;
+import de.kuschku.util.observablelists.ContentComparable;
 
 public class Message implements ContentComparable<Message> {
     public final int messageId;

app/src/main/java/de/kuschku/libquassel/objects/MessageTypeRegistry.java

@@ -20,16 +20,16 @@ public class MessageTypeRegistry {
     private static Map<String, ObjectSerializer> serializerMap = new HashMap<String, ObjectSerializer>();
 
     static {
-        serializerMap.put("ClientInit", new ClientInitSerializer());
-        serializerMap.put("ClientInitAck", new ClientInitAckSerializer());
-        serializerMap.put("ClientInitReject", new ClientInitRejectSerializer());
-        serializerMap.put("ClientLogin", new ClientLoginSerializer());
-        serializerMap.put("ClientLoginAck", new ClientLoginAckSerializer());
-        serializerMap.put("ClientLoginReject", new ClientLoginRejectSerializer());
-        serializerMap.put("CoreSetupData", new CoreSetupDataSerializer());
-        serializerMap.put("CoreSetupAck", new CoreSetupAckSerializer());
-        serializerMap.put("CoreSetupReject", new CoreSetupRejectSerializer());
-        serializerMap.put("SessionInit", new SessionInitSerializer());
+        serializerMap.put("ClientInit", ClientInitSerializer.get());
+        serializerMap.put("ClientInitAck", ClientInitAckSerializer.get());
+        serializerMap.put("ClientInitReject", ClientInitRejectSerializer.get());
+        serializerMap.put("ClientLogin", ClientLoginSerializer.get());
+        serializerMap.put("ClientLoginAck", ClientLoginAckSerializer.get());
+        serializerMap.put("ClientLoginReject", ClientLoginRejectSerializer.get());
+        serializerMap.put("CoreSetupData", CoreSetupDataSerializer.get());
+        serializerMap.put("CoreSetupAck", CoreSetupAckSerializer.get());
+        serializerMap.put("CoreSetupReject", CoreSetupRejectSerializer.get());
+        serializerMap.put("SessionInit", SessionInitSerializer.get());
     }
 
     // Disable Constructor

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientInitAckSerializer.java

@@ -15,15 +15,24 @@ import de.kuschku.libquassel.objects.types.StorageBackend;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientInitAckSerializer implements ObjectSerializer<ClientInitAck> {
+    private static ClientInitAckSerializer serializer = new ClientInitAckSerializer();
+
+    private ClientInitAckSerializer() {
+    }
+
+    public static ClientInitAckSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientInitAck data) {
         final List<Map<String, QVariant>> storageBackends = new ArrayList<>();
-        final StorageBackendSerializer storageBackendSerializer = new StorageBackendSerializer();
+        final StorageBackendSerializer storageBackendSerializer = StorageBackendSerializer.get();
         for (StorageBackend backend : data.StorageBackends) {
             storageBackends.add((Map<String, QVariant>) storageBackendSerializer.toVariantMap(backend));
         }
 
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
+        final QVariant<Map<String, QVariant>> map = new QVariant<>(new HashMap<>());
         map.data.put("Configured", new QVariant<>(data.Configured));
         map.data.put("LoginEnabled", new QVariant<>(data.LoginEnabled));
         map.data.put("StorageBackends", new QVariant<>(storageBackends));
@@ -40,7 +49,7 @@ public class ClientInitAckSerializer implements ObjectSerializer<ClientInitAck>
     public ClientInitAck fromLegacy(Map<String, QVariant> map) {
         final List<StorageBackend> storageBackends = new ArrayList<StorageBackend>();
         if (map.containsKey("StorageBackends")) {
-            final StorageBackendSerializer storageBackendSerializer = new StorageBackendSerializer();
+            final StorageBackendSerializer storageBackendSerializer = StorageBackendSerializer.get();
             for (Map<String, QVariant> backend : (List<Map<String, QVariant>>) map.get("StorageBackends").data) {
                 storageBackends.add(storageBackendSerializer.fromLegacy(backend));
             }

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientInitRejectSerializer.java

@@ -10,9 +10,18 @@ import de.kuschku.libquassel.objects.types.ClientInitReject;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientInitRejectSerializer implements ObjectSerializer<ClientInitReject> {
+    private static final ClientInitRejectSerializer serializer = new ClientInitRejectSerializer();
+
+    private ClientInitRejectSerializer() {
+    }
+
+    public static ClientInitRejectSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientInitReject data) {
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
+        final QVariant<Map<String, QVariant>> map = new QVariant<>(new HashMap<>());
         map.data.put("Error", new QVariant<>(data.Error));
         return map;
     }

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientInitSerializer.java

@@ -10,9 +10,18 @@ import de.kuschku.libquassel.objects.types.ClientInit;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientInitSerializer implements ObjectSerializer<ClientInit> {
+    private static final ClientInitSerializer serializer = new ClientInitSerializer();
+
+    private ClientInitSerializer() {
+    }
+
+    public static ClientInitSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientInit data) {
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
+        final QVariant<Map<String, QVariant>> map = new QVariant<>(new HashMap<>());
         map.data.put("ClientDate", new QVariant<>(data.ClientDate));
         map.data.put("UseSsl", new QVariant<>(data.UseSsl));
         map.data.put("ClientVersion", new QVariant<>(data.ClientVersion));

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientLoginAckSerializer.java

@@ -10,10 +10,18 @@ import de.kuschku.libquassel.objects.types.ClientLoginAck;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientLoginAckSerializer implements ObjectSerializer<ClientLoginAck> {
+    private static final ClientLoginAckSerializer serializer = new ClientLoginAckSerializer();
+
+    private ClientLoginAckSerializer() {
+    }
+
+    public static ClientLoginAckSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientLoginAck data) {
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
-        return map;
+        return new QVariant<>(new HashMap<>());
     }
 
     @Override

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientLoginRejectSerializer.java

@@ -10,9 +10,18 @@ import de.kuschku.libquassel.objects.types.ClientLoginReject;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientLoginRejectSerializer implements ObjectSerializer<ClientLoginReject> {
+    private static final ClientLoginRejectSerializer serializer = new ClientLoginRejectSerializer();
+
+    private ClientLoginRejectSerializer() {
+    }
+
+    public static ClientLoginRejectSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientLoginReject data) {
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
+        final QVariant<Map<String, QVariant>> map = new QVariant<>(new HashMap<>());
         map.data.put("Error", new QVariant<>(data.Error));
         return map;
     }

app/src/main/java/de/kuschku/libquassel/objects/serializers/ClientLoginSerializer.java

@@ -10,9 +10,18 @@ import de.kuschku.libquassel.objects.types.ClientLogin;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 public class ClientLoginSerializer implements ObjectSerializer<ClientLogin> {
+    private static final ClientLoginSerializer serializer = new ClientLoginSerializer();
+
+    private ClientLoginSerializer() {
+    }
+
+    public static ClientLoginSerializer get() {
+        return serializer;
+    }
+
     @Override
     public QVariant<Map<String, QVariant>> toVariantMap(final ClientLogin data) {
-        final QVariant<Map<String, QVariant>> map = new QVariant<Map<String, QVariant>>(new HashMap<String, QVariant>());
+        final QVariant<Map<String, QVariant>> map = new QVariant<>(new HashMap<>());
         map.data.put("User", new QVariant<>(data.User));
         map.data.put("Password", new QVariant<>(data.Password));
         return map;