Added proper backlog filtering, refactored some stuff

app/build.gradle

@@ -46,14 +46,10 @@ android {
 }
 
 
-
 dependencies {
     testCompile 'junit:junit:4.12'
 
-    compile('com.mikepenz:materialdrawer:5.0.0.fastAdapter.b5-SNAPSHOT@aar') {
-        transitive = true
-    }
-    compile('com.mikepenz:fastadapter:0.4.2-SNAPSHOT@aar') {
+    compile('com.mikepenz:materialdrawer:5.0.0.b21-SNAPSHOT@aar') {
         transitive = true
     }
     compile('com.github.afollestad.material-dialogs:core:0.8.5.3@aar') {

app/src/main/AndroidManifest.xml

@@ -17,7 +17,7 @@
             android:name=".ui.chat.ChatActivity"
             android:label="@string/app_name"
             android:launchMode="singleTask"
-            android:theme="@style/AppTheme.Light">
+            android:theme="@style/Quassel">
             <intent-filter>
                 <action android:name="android.intent.action.MAIN" />
                 <category android:name="android.intent.category.LAUNCHER" />

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

@@ -2,6 +2,7 @@ package de.kuschku.libquassel;
 
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
+import android.util.Log;
 
 import java.util.ArrayList;
 import java.util.Collection;
@@ -9,28 +10,33 @@ import java.util.HashMap;
 import java.util.List;
 import java.util.Map;
 
-import de.kuschku.libquassel.backlogmanagers.BacklogManager;
-import de.kuschku.libquassel.backlogmanagers.SimpleBacklogManager;
+import de.kuschku.libquassel.events.LagChangedEvent;
+import de.kuschku.libquassel.localtypes.NotificationManager;
+import de.kuschku.libquassel.localtypes.backlogmanagers.BacklogManager;
+import de.kuschku.libquassel.localtypes.backlogmanagers.SimpleBacklogManager;
 import de.kuschku.libquassel.events.ConnectionChangeEvent;
 import de.kuschku.libquassel.events.StatusMessageEvent;
+import de.kuschku.libquassel.functions.types.HandshakeFunction;
 import de.kuschku.libquassel.functions.types.InitRequestFunction;
 import de.kuschku.libquassel.functions.types.RpcCallFunction;
 import de.kuschku.libquassel.localtypes.Buffer;
 import de.kuschku.libquassel.localtypes.Buffers;
 import de.kuschku.libquassel.message.Message;
 import de.kuschku.libquassel.objects.types.ClientInitAck;
+import de.kuschku.libquassel.objects.types.ClientLogin;
 import de.kuschku.libquassel.objects.types.SessionState;
 import de.kuschku.libquassel.primitives.types.BufferInfo;
 import de.kuschku.libquassel.primitives.types.QVariant;
 import de.kuschku.libquassel.syncables.types.BufferSyncer;
+import de.kuschku.libquassel.syncables.types.BufferViewConfig;
 import de.kuschku.libquassel.syncables.types.BufferViewManager;
+import de.kuschku.libquassel.syncables.types.IgnoreListManager;
+import de.kuschku.libquassel.syncables.types.IrcChannel;
+import de.kuschku.libquassel.syncables.types.IrcUser;
 import de.kuschku.libquassel.syncables.types.Network;
 import de.kuschku.libquassel.syncables.types.SyncableObject;
-import de.kuschku.quasseldroid_ng.ui.chat.drawer.NetworkWrapper;
 import de.kuschku.util.backports.Stream;
-import de.kuschku.util.observables.callbacks.UICallback;
-import de.kuschku.util.observables.lists.IObservableList;
-import de.kuschku.util.observables.lists.ObservableComparableSortedList;
+import de.kuschku.util.observables.lists.ObservableElementList;
 
 import static de.kuschku.util.AndroidAssert.assertNotNull;
 
@@ -39,7 +45,7 @@ public class Client {
     @NonNull
     private final Map<Integer, Network> networks = new HashMap<>();
     @NonNull
-    private final IObservableList<UICallback, NetworkWrapper> networkList = new ObservableComparableSortedList<>(NetworkWrapper.class);
+    private final ObservableElementList<Integer> networkList = new ObservableElementList<>();
     @NonNull
     private final Map<Integer, Buffer> buffers = new HashMap<>();
     @NonNull
@@ -47,8 +53,10 @@ public class Client {
     @NonNull
     private final BacklogManager backlogManager;
     @NonNull
+    private final NotificationManager notificationManager = new NotificationManager();
+    @NonNull
     private final BusProvider busProvider;
-    public int lag;
+    private long lag;
     private ConnectionChangeEvent.Status connectionStatus;
     private ClientInitAck core;
     @Nullable
@@ -56,6 +64,7 @@ public class Client {
     private BufferViewManager bufferViewManager;
     private BufferSyncer bufferSyncer;
     private ClientData clientData;
+    private IgnoreListManager ignoreListManager;
 
     public Client(@NonNull final BusProvider busProvider) {
         this(new SimpleBacklogManager(busProvider), busProvider);
@@ -64,6 +73,7 @@ public class Client {
     public Client(@NonNull final BacklogManager backlogManager, @NonNull final BusProvider busProvider) {
         this.backlogManager = backlogManager;
         this.busProvider = busProvider;
+        this.backlogManager.setClient(this);
     }
 
     public void sendInput(@NonNull final BufferInfo info, @NonNull final String input) {
@@ -86,6 +96,7 @@ public class Client {
         assertNotNull(state);
 
         networks.put(network.getNetworkId(), network);
+        networkList.add(network.getNetworkId());
 
         for (BufferInfo info : state.BufferInfos) {
             if (info.networkId == network.getNetworkId()) {
@@ -104,6 +115,7 @@ public class Client {
 
     public void putBuffer(@NonNull final Buffer buffer) {
         this.buffers.put(buffer.getInfo().id, buffer);
+        this.notificationManager.init(buffer.getInfo().id);
     }
 
     @Nullable
@@ -111,11 +123,11 @@ public class Client {
         return this.buffers.get(bufferId);
     }
 
-    void sendInitRequest(@NonNull final String className, @Nullable final String objectName) {
+    public void sendInitRequest(@NonNull final String className, @Nullable final String objectName) {
         sendInitRequest(className, objectName, false);
     }
 
-    void sendInitRequest(@NonNull final String className, @Nullable final String objectName, boolean addToList) {
+    public void sendInitRequest(@NonNull final String className, @Nullable final String objectName, boolean addToList) {
         busProvider.dispatch(new InitRequestFunction(className, objectName));
 
         if (addToList)
@@ -135,33 +147,40 @@ public class Client {
     }
 
     @Nullable
-    public SyncableObject getObjectByIdentifier(@NonNull final String className, @NonNull final String objectName) {
+    public SyncableObject getObjectByIdentifier(@NonNull final String className, @Nullable final String objectName) {
         switch (className) {
             case "BacklogManager":
                 return getBacklogManager();
             case "IrcChannel": {
+                assertNotNull(objectName);
                 final int networkId = Integer.parseInt(objectName.split("/")[0]);
                 final String channelname = objectName.split("/")[1];
 
                 // Assert that networkId is valid
                 Network network = getNetwork(networkId);
                 assertNotNull(network);
-                return network.getChannels().get(channelname);
+                IrcChannel channel = network.getChannels().get(channelname);
+                assertNotNull("Channel " + channelname + " not found in " + network.getChannels().keySet(), channel);
+                return channel;
             }
             case "BufferSyncer":
                 return bufferSyncer;
             case "BufferViewConfig":
                 assertNotNull(getBufferViewManager());
-
+                assertNotNull(objectName);
                 return getBufferViewManager().BufferViews.get(Integer.valueOf(objectName));
             case "IrcUser": {
+                assertNotNull(objectName);
                 final int networkId = Integer.parseInt(objectName.split("/")[0]);
                 final String username = objectName.split("/")[1];
                 Network network = getNetwork(networkId);
                 assertNotNull(network);
-                return network.getUser(username);
+                IrcUser networkUser = network.getUser(username);
+                assertNotNull("User " + username + " not found in " + network.getUsers().keySet(), networkUser);
+                return networkUser;
             }
             case "Network": {
+                assertNotNull(objectName);
                 return getNetwork(Integer.parseInt(objectName));
             }
             default:
@@ -184,7 +203,7 @@ public class Client {
     }
 
     @NonNull
-    public BacklogManager getBacklogManager() {
+    public BacklogManager<?> getBacklogManager() {
         return backlogManager;
     }
 
@@ -226,8 +245,8 @@ public class Client {
     }
 
     @NonNull
-    public Collection<Network> getNetworks() {
-        return networks.values();
+    public ObservableElementList<Integer> getNetworks() {
+        return networkList;
     }
 
     @NonNull
@@ -240,8 +259,31 @@ public class Client {
         busProvider.sendEvent(new ConnectionChangeEvent(connectionStatus));
     }
 
+    public void login(String username, String password) {
+        busProvider.dispatch(new HandshakeFunction(new ClientLogin(
+                username, password
+        )));
+    }
+
     @NonNull
-    public IObservableList<UICallback, NetworkWrapper> getNetworkList() {
-        return networkList;
+    public NotificationManager getNotificationManager() {
+        return notificationManager;
+    }
+
+    public void setLag(long l) {
+        lag = l;
+        busProvider.sendEvent(new LagChangedEvent(lag));
+    }
+
+    public long getLag() {
+        return lag;
+    }
+
+    public IgnoreListManager getIgnoreListManager() {
+        return ignoreListManager;
+    }
+
+    public void setIgnoreListManager(IgnoreListManager ignoreListManager) {
+        this.ignoreListManager = ignoreListManager;
     }
 }

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

@@ -5,6 +5,8 @@ import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.util.Log;
 
+import org.joda.time.DateTime;
+
 import java.io.IOException;
 import java.net.InetSocketAddress;
 import java.net.Socket;
@@ -20,6 +22,7 @@ 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.functions.types.Heartbeat;
 import de.kuschku.libquassel.objects.types.ClientInit;
 import de.kuschku.libquassel.primitives.QMetaTypeRegistry;
 import de.kuschku.libquassel.primitives.serializers.ProtocolSerializer;
@@ -50,7 +53,9 @@ public class CoreConnection {
     @Nullable
     private ExecutorService outputExecutor;
     @Nullable
-    private ExecutorService inputExecutor;
+    private EndableThread inputThread;
+    @Nullable
+    private EndableThread heartbeatThread;
     @Nullable
     private RemotePeer remotePeer;
     @Nullable
@@ -95,7 +100,6 @@ public class CoreConnection {
 
         // Create executor for write events
         outputExecutor = Executors.newSingleThreadExecutor();
-        inputExecutor = Executors.newSingleThreadExecutor();
 
         // Execute handshake
         handshake();
@@ -112,7 +116,8 @@ public class CoreConnection {
         client.setConnectionStatus(ConnectionChangeEvent.Status.DISCONNECTED);
 
         // We can do this because we clean up the file handles ourselves
-        if (inputExecutor != null) inputExecutor.shutdownNow();
+        if (inputThread != null) inputThread.end();
+        if (heartbeatThread != null) heartbeatThread.end();
         if (outputExecutor != null) outputExecutor.shutdownNow();
 
         // Which we do exactly here
@@ -154,7 +159,6 @@ public class CoreConnection {
      */
     private void handshake() throws IOException {
         assertNotNull(channel);
-        assertNotNull(inputExecutor);
 
         // Start protocol handshake with magic version and feature flags
         QMetaTypeRegistry.serialize(UInt, channel, 0x42b33f00 | clientData.flags.flags);
@@ -166,7 +170,10 @@ public class CoreConnection {
         QMetaTypeRegistry.serialize(UInt, channel, 0x01 << 31);
 
         // Spawn and start a new read thread
-        inputExecutor.submit(new ReadRunnable());
+        inputThread = new ReadThread();
+        heartbeatThread = new HeartbeatThread();
+        inputThread.start();
+        heartbeatThread.start();
     }
 
     public void onEventAsync(HandshakeFailedEvent event) {
@@ -192,14 +199,20 @@ public class CoreConnection {
     /**
      * A runnable that reads from the channel and calls the functions responsible for processing the read data.
      */
-    private class ReadRunnable implements Runnable {
+    private class ReadThread extends EndableThread {
+        private boolean running = true;
+
+        public ReadThread() {
+            setName(getClass().getSimpleName());
+        }
+
         @Override
         public void run() {
             assertNotNull(client);
 
             try {
                 boolean hasReadPreHandshake = false;
-                while (true) {
+                while (running) {
                     if (!hasReadPreHandshake) {
                         final ByteBuffer buffer = ByteBuffer.allocate(4);
                         assertNotNull(buffer);
@@ -248,5 +261,42 @@ public class CoreConnection {
                 busProvider.sendEvent(new GeneralErrorEvent(e));
             }
         }
+
+        @Override
+        public void end() {
+            running = false;
+        }
+    }
+
+    private class HeartbeatThread extends EndableThread {
+        private boolean running = true;
+
+        public HeartbeatThread() {
+            setName(getClass().getSimpleName());
+        }
+
+        @Override
+        public void run() {
+            try {
+                assertNotNull(client);
+
+                while (running) {
+                    busProvider.dispatch(new Heartbeat(DateTime.now()));
+
+                    Thread.sleep(30 * 1000);
+                }
+            } catch (InterruptedException e) {
+                e.printStackTrace();
+            }
+        }
+
+        @Override
+        public void end() {
+            running = false;
+        }
+    }
+
+    private abstract class EndableThread extends Thread {
+        public abstract void end();
     }
 }

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

@@ -21,15 +21,15 @@ public interface IProtocolHandler {
 
     void onEventMainThread(SyncFunction packedFunc);
 
-    void onEventMainThread(ClientInitReject message);
+    void onEvent(ClientInitReject message);
 
-    void onEventMainThread(ClientInitAck message);
+    void onEvent(ClientInitAck message);
 
-    void onEventMainThread(ClientLoginAck message);
+    void onEvent(ClientLoginAck message);
 
-    void onEventMainThread(ClientLoginReject message);
+    void onEvent(ClientLoginReject message);
 
-    void onEventMainThread(SessionInit message);
+    void onEvent(SessionInit message);
 
     @NonNull
     Client getClient();

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

@@ -3,12 +3,16 @@ package de.kuschku.libquassel;
 import android.support.annotation.NonNull;
 import android.util.Log;
 
+import org.joda.time.DateTime;
+
 import de.kuschku.libquassel.events.ConnectionChangeEvent;
 import de.kuschku.libquassel.events.GeneralErrorEvent;
 import de.kuschku.libquassel.events.HandshakeFailedEvent;
 import de.kuschku.libquassel.events.LoginFailedEvent;
 import de.kuschku.libquassel.events.LoginSuccessfulEvent;
 import de.kuschku.libquassel.exceptions.UnknownTypeException;
+import de.kuschku.libquassel.functions.types.Heartbeat;
+import de.kuschku.libquassel.functions.types.HeartbeatReply;
 import de.kuschku.libquassel.functions.types.InitDataFunction;
 import de.kuschku.libquassel.functions.types.InitRequestFunction;
 import de.kuschku.libquassel.functions.types.RpcCallFunction;
@@ -20,10 +24,13 @@ import de.kuschku.libquassel.objects.types.ClientLoginReject;
 import de.kuschku.libquassel.objects.types.SessionInit;
 import de.kuschku.libquassel.primitives.types.BufferInfo;
 import de.kuschku.libquassel.syncables.SyncableRegistry;
+import de.kuschku.libquassel.syncables.types.BufferViewConfig;
 import de.kuschku.libquassel.syncables.types.SyncableObject;
 import de.kuschku.util.AndroidAssert;
 import de.kuschku.util.ReflectionUtils;
 
+import static de.kuschku.util.AndroidAssert.assertNotNull;
+
 public class ProtocolHandler implements IProtocolHandler {
     @NonNull
     public final Client client;
@@ -51,7 +58,7 @@ public class ProtocolHandler implements IProtocolHandler {
                 }
             }
             SyncableObject object = SyncableRegistry.from(packedFunc);
-            AndroidAssert.assertNotNull(object);
+            assertNotNull(object);
 
             object.init(packedFunc, busProvider, client);
         } catch (Exception e) {
@@ -79,21 +86,21 @@ public class ProtocolHandler implements IProtocolHandler {
     public void onEventMainThread(@NonNull SyncFunction packedFunc) {
         try {
             final Object syncable = client.getObjectByIdentifier(packedFunc.className, packedFunc.objectName);
-            if (syncable != null) {
+            AndroidAssert.assertNotNull("Object not found: " + packedFunc.className+":"+packedFunc.objectName, syncable);
             ReflectionUtils.invokeMethod(syncable, packedFunc.methodName, packedFunc.params);
-            } else {
-                busProvider.sendEvent(new GeneralErrorEvent(new UnknownTypeException(packedFunc.className)));
-            }
         } catch (Exception e) {
-            busProvider.sendEvent(new GeneralErrorEvent(e));
+            busProvider.sendEvent(new GeneralErrorEvent(e, packedFunc.toString()));
+        } catch (Error e) {
+            e.printStackTrace();
+            Log.e("EVENT", packedFunc.toString());
         }
     }
 
-    public void onEventMainThread(@NonNull ClientInitReject message) {
+    public void onEvent(@NonNull ClientInitReject message) {
         busProvider.sendEvent(new HandshakeFailedEvent(message.Error));
     }
 
-    public void onEventMainThread(ClientInitAck message) {
+    public void onEvent(ClientInitAck message) {
         client.setCore(message);
 
         if (client.getCore().Configured) {
@@ -105,16 +112,16 @@ public class ProtocolHandler implements IProtocolHandler {
         }
     }
 
-    public void onEventMainThread(ClientLoginAck message) {
+    public void onEvent(ClientLoginAck message) {
         busProvider.sendEvent(new LoginSuccessfulEvent());
         client.setConnectionStatus(ConnectionChangeEvent.Status.CONNECTING);
     }
 
-    public void onEventMainThread(@NonNull ClientLoginReject message) {
+    public void onEvent(@NonNull ClientLoginReject message) {
         busProvider.sendEvent(new LoginFailedEvent(message.Error));
     }
 
-    public void onEventMainThread(@NonNull SessionInit message) {
+    public void onEvent(@NonNull SessionInit message) {
         client.setState(message.SessionState);
 
         client.setConnectionStatus(ConnectionChangeEvent.Status.INITIALIZING_DATA);
@@ -134,6 +141,17 @@ public class ProtocolHandler implements IProtocolHandler {
         }
     }
 
+    public void onEvent(@NonNull Heartbeat heartbeat) {
+        busProvider.dispatch(new HeartbeatReply(heartbeat.dateTime));
+    }
+
+    public void onEventMainThread(@NonNull HeartbeatReply heartbeat) {
+        long roundtrip = DateTime.now().getMillis() - heartbeat.dateTime.getMillis();
+        long lag = (long) (roundtrip * 0.5);
+
+        client.setLag(lag);
+    }
+
     @NonNull
     @Override
     public Client getClient() {

app/src/main/java/de/kuschku/libquassel/events/BacklogReceivedEvent.java

@@ -4,7 +4,7 @@ import android.support.annotation.IntRange;
 
 @SuppressWarnings("WeakerAccess")
 public class BacklogReceivedEvent {
-    @IntRange(from = 0)
+    @IntRange(from = -1)
     public final int bufferId;
 
     public BacklogReceivedEvent(int bufferId) {

app/src/main/java/de/kuschku/libquassel/events/GeneralErrorEvent.java

@@ -13,11 +13,18 @@ public class GeneralErrorEvent {
         this.exception = exception;
     }
 
+    public GeneralErrorEvent(Exception exception, String debugInfo) {
+        this.debugInfo = debugInfo;
+        this.exception = exception;
+    }
+
     @Override
     public String toString() {
         if (debugInfo == null)
             return String.format("%s: %s", exception.getClass().getSimpleName(), exception.getLocalizedMessage());
-        else
+        else if (exception == null)
             return debugInfo;
+        else
+            return String.format("%s: %s\n%s", exception.getClass().getSimpleName(), exception.getLocalizedMessage(), debugInfo);
     }
 }

app/src/main/java/de/kuschku/libquassel/events/LagChangedEvent.java

+package de.kuschku.libquassel.events;
+
+public class LagChangedEvent {
+    public final long lag;
+
+    public LagChangedEvent(long lag) {
+        this.lag = lag;
+    }
+
+    @Override
+    public String toString() {
+        return "LagChangedEvent{" +
+                "lag=" + lag +
+                '}';
+    }
+}

app/src/main/java/de/kuschku/libquassel/exceptions/UnknownTypeException.java

@@ -4,9 +4,15 @@ import android.support.annotation.Nullable;
 
 public class UnknownTypeException extends IllegalArgumentException {
     public final String typeName;
+    public final String additionalData;
 
     public UnknownTypeException(String typeName) {
+        this(typeName, null);
+    }
+
+    public UnknownTypeException(String typeName, Object additionalData) {
         this.typeName = typeName;
+        this.additionalData = String.valueOf(additionalData);
     }
 
     @Nullable
@@ -17,6 +23,6 @@ public class UnknownTypeException extends IllegalArgumentException {
 
     @Override
     public String getMessage() {
-        return String.format("Unknown type: %s", typeName);
+        return String.format("Unknown type: %s; %s", typeName, additionalData);
     }
 }

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

+package de.kuschku.libquassel.functions.serializers;
+
+import android.support.annotation.NonNull;
+
+import org.joda.time.DateTime;
+
+import java.util.Arrays;
+import java.util.Collections;
+import java.util.List;
+
+import de.kuschku.libquassel.functions.FunctionType;
+import de.kuschku.libquassel.functions.types.Heartbeat;
+import de.kuschku.libquassel.functions.types.HeartbeatReply;
+import de.kuschku.libquassel.primitives.types.QVariant;
+
+import static de.kuschku.util.AndroidAssert.assertTrue;
+
+public class HeartbeatReplySerializer implements FunctionSerializer<HeartbeatReply> {
+    @NonNull
+    private static final HeartbeatReplySerializer serializer = new HeartbeatReplySerializer();
+
+    private HeartbeatReplySerializer() {
+    }
+
+    @NonNull
+    public static HeartbeatReplySerializer get() {
+        return serializer;
+    }
+
+    @NonNull
+    @Override
+    public List serialize(@NonNull HeartbeatReply data) {
+        return Arrays.asList(
+                FunctionType.HEARTBEATREPLY.id,
+                new QVariant<>(data.dateTime)
+        );
+    }
+
+    @NonNull
+    @Override
+    public HeartbeatReply deserialize(@NonNull List packedFunc) {
+        assertTrue(packedFunc.size() == 1);
+
+        return new HeartbeatReply((DateTime) ((QVariant) packedFunc.remove(0)).data);
+    }
+}

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

+package de.kuschku.libquassel.functions.serializers;
+
+import android.support.annotation.NonNull;
+
+import org.joda.time.DateTime;
+
+import java.util.Arrays;
+import java.util.List;
+
+import de.kuschku.libquassel.functions.FunctionType;
+import de.kuschku.libquassel.functions.types.Heartbeat;
+import de.kuschku.libquassel.primitives.types.QVariant;
+
+import static de.kuschku.util.AndroidAssert.assertTrue;
+
+public class HeartbeatSerializer implements FunctionSerializer<Heartbeat> {
+    @NonNull
+    private static final HeartbeatSerializer serializer = new HeartbeatSerializer();
+
+    private HeartbeatSerializer() {
+    }
+
+    @NonNull
+    public static HeartbeatSerializer get() {
+        return serializer;
+    }
+
+    @NonNull
+    @Override
+    public List serialize(@NonNull Heartbeat data) {
+        return Arrays.asList(
+                FunctionType.HEARTBEAT.id,
+                new QVariant<>(data.dateTime)
+        );
+    }
+
+    @NonNull
+    @Override
+    public Heartbeat deserialize(@NonNull List packedFunc) {
+        assertTrue(packedFunc.size() == 1);
+
+        return new Heartbeat((DateTime) ((QVariant) packedFunc.remove(0)).data);
+    }
+}

app/src/main/java/de/kuschku/libquassel/functions/types/Heartbeat.java

+package de.kuschku.libquassel.functions.types;
+
+import org.joda.time.DateTime;
+
+public class Heartbeat {
+    public final DateTime dateTime;
+
+    public Heartbeat(DateTime dateTime) {
+        this.dateTime = dateTime;
+    }
+
+    @Override
+    public String toString() {
+        return "Heartbeat{" +
+                "dateTime=" + dateTime +
+                '}';
+    }
+}

app/src/main/java/de/kuschku/libquassel/functions/types/HeartbeatReply.java

+package de.kuschku.libquassel.functions.types;
+
+import org.joda.time.DateTime;
+
+public class HeartbeatReply {
+    public final DateTime dateTime;
+
+    public HeartbeatReply(DateTime dateTime) {
+        this.dateTime = dateTime;
+    }
+
+    @Override
+    public String toString() {
+        return "HeartbeatReply{" +
+                "dateTime=" + dateTime +
+                '}';
+    }
+}

app/src/main/java/de/kuschku/libquassel/localtypes/Buffer.java

@@ -11,4 +11,6 @@ public interface Buffer {
 
     @Nullable
     String getName();
+
+    boolean isActive();
 }

app/src/main/java/de/kuschku/libquassel/localtypes/ChannelBuffer.java

@@ -9,10 +9,10 @@ import de.kuschku.libquassel.syncables.types.IrcChannel;
 public class ChannelBuffer implements Buffer {
     @NonNull
     private final BufferInfo info;
-    @NonNull
+    @Nullable
     private final IrcChannel channel;
 
-    public ChannelBuffer(@NonNull BufferInfo info, @NonNull IrcChannel channel) {
+    public ChannelBuffer(@NonNull BufferInfo info, @Nullable IrcChannel channel) {
         this.info = info;
         this.channel = channel;
     }
@@ -29,7 +29,12 @@ public class ChannelBuffer implements Buffer {
         return getInfo().name;
     }
 
-    @NonNull
+    @Override
+    public boolean isActive() {
+        return channel != null;
+    }
+
+    @Nullable
     public IrcChannel getChannel() {
         return channel;
     }

app/src/main/java/de/kuschku/libquassel/localtypes/NotificationManager.java

+package de.kuschku.libquassel.localtypes;
+
+import android.util.SparseArray;
+
+import de.kuschku.libquassel.message.Message;
+import de.kuschku.util.observables.lists.ObservableComparableSortedList;
+
+public class NotificationManager {
+    private SparseArray<ObservableComparableSortedList<Message>> notifications = new SparseArray<>();
+
+    public ObservableComparableSortedList<Message> getNotifications(int bufferid) {
+        return notifications.get(bufferid);
+    }
+
+    public void init(int id) {
+        notifications.put(id, new ObservableComparableSortedList<>(Message.class));
+    }
+}

app/src/main/java/de/kuschku/libquassel/localtypes/QueryBuffer.java

@@ -29,6 +29,11 @@ public class QueryBuffer implements Buffer {
         return getInfo().name;
     }
 
+    @Override
+    public boolean isActive() {
+        return user != null;
+    }
+
     @Nullable
     public IrcUser getUser() {
         return user;

app/src/main/java/de/kuschku/libquassel/localtypes/StatusBuffer.java

@@ -29,6 +29,11 @@ public class StatusBuffer implements Buffer {
         return network.getNetworkName();
     }
 
+    @Override
+    public boolean isActive() {
+        return network.isConnected();
+    }
+
     @NonNull
     @Override
     public String toString() {

app/src/main/java/de/kuschku/libquassel/localtypes/backlogmanagers/BacklogFilter.java

+package de.kuschku.libquassel.localtypes.backlogmanagers;
+
+import android.support.annotation.NonNull;
+
+import com.android.internal.util.Predicate;
+
+import de.kuschku.libquassel.Client;
+import de.kuschku.libquassel.message.Message;
+import de.kuschku.quasseldroid_ng.ui.AppContext;
+import de.kuschku.util.observables.callbacks.UICallback;
+import de.kuschku.util.observables.lists.ObservableSortedList;
+
+public class BacklogFilter implements UICallback {
+    @NonNull
+    private final Client client;
+    @NonNull
+    private final ObservableSortedList<Message> unfiltered;
+    @NonNull
+    private final ObservableSortedList<Message> filtered;
+
+    public BacklogFilter(@NonNull Client client, @NonNull ObservableSortedList<Message> unfiltered, @NonNull ObservableSortedList<Message> filtered) {
+        this.client = client;
+        this.unfiltered = unfiltered;
+        this.filtered = filtered;
+    }
+
+    @Override
+    public void notifyItemInserted(int position) {
+        Message message = unfiltered.get(position);
+        if (filterItem(message)) filtered.add(message);
+    }
+
+    private boolean filterItem(Message message) {
+        return !client.getIgnoreListManager().matches(message);
+    }
+
+    @Override
+    public void notifyItemChanged(int position) {
+        filtered.notifyItemChanged(position);
+    }
+
+    @Override
+    public void notifyItemRemoved(int position) {
+        filtered.remove(position);
+    }
+
+    @Override
+    public void notifyItemMoved(int from, int to) {
+        // Can’t occur: Sorted List
+    }
+
+    @Override
+    public void notifyItemRangeInserted(int position, int count) {
+        for (int i = position; i < position + count; i++) {
+            notifyItemInserted(i);
+        }
+    }
+
+    @Override
+    public void notifyItemRangeChanged(int position, int count) {
+        for (int i = position; i < position + count; i++) {
+            notifyItemChanged(i);
+        }
+    }
+
+    @Override
+    public void notifyItemRangeRemoved(int position, int count) {
+        for (int i = position; i < position + count; i++) {
+            notifyItemRemoved(i);
+        }
+    }
+}