Fixed a lot of bugs

Improved UI to show buffer status
Added notification manager

app/build.gradle

@@ -46,6 +46,7 @@ if (versionPropsFile.canRead()) {
   throw new GradleException("Could not read version.properties!"+versionPropsFile.toString())
 }
 
+
 def rawVersionName = "0.2.0"
 
 android {
@@ -61,20 +62,9 @@ android {
     }
     buildTypes {
         release {
-            //minifyEnabled true
-            //shrinkResources true
-            //proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
-
-            applicationVariants.all { variant ->
-                variant.outputs.each { output ->
-                    if ('assemble' in runTasks || 'assembleRelease' in runTasks || 'aR' in runTasks) {
-                        def fileName = output.outputFile.name
-                                .replace(".apk", String.format("-%s-build%d.apk", rawVersionName, versionCode))
-                                .replace("app-", "QuasselDroidNG-")
-                        output.outputFile = new File(output.outputFile.parent, fileName)
-                    }
-                }
-            }
+            minifyEnabled true
+            shrinkResources true
+            proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
         }
     }
     compileOptions {
@@ -93,6 +83,31 @@ android {
         exclude 'META-INF/dependencies.txt'
         exclude 'META-INF/LGPL2.1'
     }
+    lintOptions {
+        abortOnError false
+    }
+}
+
+def runTasks = gradle.startParameter.taskNames
+if ('assemble' in runTasks || 'assembleRelease' in runTasks || 'aR' in runTasks) {
+    android {
+        buildTypes {
+            release {
+                //minifyEnabled true
+                //shrinkResources true
+                //proguardFiles getDefaultProguardFile('proguard-android.txt'), 'proguard-rules.pro'
+
+                applicationVariants.all { variant ->
+                    variant.outputs.each { output ->
+                        def fileName = output.outputFile.name
+                                .replace(".apk", String.format("-%s-build%d.apk", rawVersionName, versionBuild))
+                                .replace("app-", "QuasselDroidNG-")
+                        output.outputFile = new File(output.outputFile.parent, fileName)
+                    }
+                }
+            }
+        }
+    }
 }
 
 

app/proguard-rules.pro

@@ -26,13 +26,16 @@
 -dontwarn sun.misc.Unsafe
 -dontwarn org.codehaus.mojo.animal_sniffer.IgnoreJRERequirement
 -dontwarn javax.annotation.processing.ProcessingEnvironment
+-dontwarn com.nineoldandroids.view.animation.AnimatorProxy
 
--keepclasseswithmembernames class **.libquassel.** {
+-keepclasseswithmembernames class de.kuschku.** {
     <methods>;
+    <fields>;
 }
 
--keepclassmembers class **.libquassel.** {
+-keepclassmembers class de.kuschku.** {
     <methods>;
+    <fields>;
 }
 
 

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

@@ -54,7 +54,7 @@ public class Client {
     @NonNull
     private final BacklogManager backlogManager;
     @NonNull
-    private final NotificationManager notificationManager = new NotificationManager();
+    private final NotificationManager notificationManager = new NotificationManager(this);
     @NonNull
     private final BusProvider busProvider;
     private long lag;
@@ -197,6 +197,7 @@ public class Client {
 
     public void setState(@Nullable SessionState state) {
         this.state = state;
+        Log.e("DEBUG", String.valueOf(this.state));
     }
 
     @NonNull

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

@@ -281,12 +281,13 @@ public class CoreConnection {
                 assertNotNull(client);
 
                 while (running) {
-                    busProvider.dispatch(new Heartbeat(DateTime.now()));
+                    Heartbeat heartbeat = new Heartbeat(DateTime.now());
+                    Log.e("heartbeat", String.valueOf(heartbeat));
+                    busProvider.dispatch(heartbeat);
 
                     Thread.sleep(30 * 1000);
                 }
             } catch (InterruptedException e) {
-                e.printStackTrace();
             }
         }
 

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

@@ -2,6 +2,8 @@ package de.kuschku.libquassel;
 
 import android.support.annotation.NonNull;
 
+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;
@@ -31,6 +33,10 @@ public interface IProtocolHandler {
 
     void onEvent(SessionInit message);
 
+    void onEvent(Heartbeat message);
+
+    void onEventMainThread(HeartbeatReply message);
+
     @NonNull
     Client getClient();
 }

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

@@ -5,6 +5,8 @@ import android.util.Log;
 
 import org.joda.time.DateTime;
 
+import java.util.List;
+
 import de.kuschku.libquassel.events.ConnectionChangeEvent;
 import de.kuschku.libquassel.events.GeneralErrorEvent;
 import de.kuschku.libquassel.events.HandshakeFailedEvent;
@@ -25,6 +27,7 @@ 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.Identity;
 import de.kuschku.libquassel.syncables.types.SyncableObject;
 import de.kuschku.util.AndroidAssert;
 import de.kuschku.util.ReflectionUtils;
@@ -135,6 +138,9 @@ public class ProtocolHandler implements IProtocolHandler {
         for (int NetworkId : client.getState().NetworkIds) {
             client.sendInitRequest("Network", String.valueOf(NetworkId), true);
         }
+        for (Identity identity : client.getState().Identities) {
+            identity.init(null, busProvider, client);
+        }
         for (BufferInfo info : message.SessionState.BufferInfos) {
             final int initialBacklogCount = 10;
             client.getBacklogManager().requestBacklog(info.id, -1, -1, initialBacklogCount, 0);
@@ -146,6 +152,8 @@ public class ProtocolHandler implements IProtocolHandler {
     }
 
     public void onEventMainThread(@NonNull HeartbeatReply heartbeat) {
+        Log.e("heartbeatreply", String.valueOf(heartbeat));
+
         long roundtrip = DateTime.now().getMillis() - heartbeat.dateTime.getMillis();
         long lag = (long) (roundtrip * 0.5);
 

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

@@ -9,6 +9,7 @@ import java.util.List;
 
 import de.kuschku.libquassel.functions.FunctionType;
 import de.kuschku.libquassel.functions.types.Heartbeat;
+import de.kuschku.libquassel.primitives.QMetaType;
 import de.kuschku.libquassel.primitives.types.QVariant;
 
 import static de.kuschku.util.AndroidAssert.assertTrue;
@@ -30,7 +31,7 @@ public class HeartbeatSerializer implements FunctionSerializer<Heartbeat> {
     public List serialize(@NonNull Heartbeat data) {
         return Arrays.asList(
                 FunctionType.HEARTBEAT.id,
-                new QVariant<>(data.dateTime)
+                new QVariant<>(QMetaType.Type.QDateTime, data.dateTime)
         );
     }
 

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

@@ -12,5 +12,5 @@ public interface Buffer {
     @Nullable
     String getName();
 
-    boolean isActive();
+    BufferInfo.BufferStatus getStatus();
 }

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

@@ -30,8 +30,8 @@ public class ChannelBuffer implements Buffer {
     }
 
     @Override
-    public boolean isActive() {
-        return channel != null;
+    public BufferInfo.BufferStatus getStatus() {
+        return channel == null ? BufferInfo.BufferStatus.OFFLINE : BufferInfo.BufferStatus.ONLINE;
     }
 
     @Nullable

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

@@ -2,17 +2,82 @@ package de.kuschku.libquassel.localtypes;
 
 import android.util.SparseArray;
 
+import java.util.ArrayList;
+import java.util.List;
+import java.util.regex.Pattern;
+
+import de.kuschku.libquassel.Client;
 import de.kuschku.libquassel.message.Message;
+import de.kuschku.libquassel.syncables.types.Identity;
+import de.kuschku.libquassel.syncables.types.Network;
 import de.kuschku.util.observables.lists.ObservableComparableSortedList;
 
 public class NotificationManager {
     private SparseArray<ObservableComparableSortedList<Message>> notifications = new SparseArray<>();
+    private List<HighlightRule> highlights = new ArrayList<>();
+    private Client client;
+
+    public NotificationManager(Client client) {
+        this.client = client;
+    }
 
     public ObservableComparableSortedList<Message> getNotifications(int bufferid) {
+        if (notifications.get(bufferid) == null)
+            notifications.put(bufferid, new ObservableComparableSortedList<>(Message.class));
+
         return notifications.get(bufferid);
     }
 
     public void init(int id) {
         notifications.put(id, new ObservableComparableSortedList<>(Message.class));
     }
+
+    public void receiveMessage(Message message) {
+        if (checkMessage(message)) {
+            getNotifications(message.bufferInfo.id).add(message);
+        }
+    }
+
+    public boolean checkMessage(Message message) {
+        Buffer buffer = client.getBuffer(message.bufferInfo.id);
+        if (buffer == null) return false;
+        Network network = client.getNetwork(buffer.getInfo().networkId);
+        if (network == null) return false;
+        Identity identity = client.getIdentity(network.getIdentityId());
+        if (identity == null) return false;
+
+        for (String nick : identity.getNicks()) {
+            if (message.content.contains(nick))
+                return true;
+        }
+        for (HighlightRule rule : highlights) {
+            if (rule.matches(message.content, buffer.getName()))
+                return true;
+        }
+        return false;
+    }
+
+    public void receiveMessages(List<Message> messages) {
+        for (Message message : messages) {
+            receiveMessage(message);
+        }
+    }
+
+    private class HighlightRule {
+        public final Pattern rule;
+        public final Pattern channelRule;
+        public final boolean invertChannelRule;
+        public final boolean caseSensitive;
+
+        public HighlightRule(String rule, String channelRule, boolean invertChannelRule, boolean caseSensitive) {
+            this.rule = rule.isEmpty() ? Pattern.compile(".*") : Pattern.compile(rule);
+            this.channelRule = channelRule.isEmpty() ? Pattern.compile(".*") : Pattern.compile(channelRule);
+            this.invertChannelRule = invertChannelRule;
+            this.caseSensitive = caseSensitive;
+        }
+
+        public boolean matches(String message, String channelName) {
+            return (invertChannelRule ^ channelRule.matcher(channelName).matches() && rule.matcher(message).matches());
+        }
+    }
 }

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

@@ -30,8 +30,10 @@ public class QueryBuffer implements Buffer {
     }
 
     @Override
-    public boolean isActive() {
-        return user != null;
+    public BufferInfo.BufferStatus getStatus() {
+        return  (user == null) ?    BufferInfo.BufferStatus.OFFLINE :
+                (user.isAway()) ?   BufferInfo.BufferStatus.AWAY :
+                                    BufferInfo.BufferStatus.ONLINE;
     }
 
     @Nullable

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

@@ -30,8 +30,8 @@ public class StatusBuffer implements Buffer {
     }
 
     @Override
-    public boolean isActive() {
-        return network.isConnected();
+    public BufferInfo.BufferStatus getStatus() {
+        return network.isConnected() ? BufferInfo.BufferStatus.ONLINE : BufferInfo.BufferStatus.OFFLINE;
     }
 
     @NonNull

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

 package de.kuschku.libquassel.localtypes.backlogmanagers;
 
 import android.support.annotation.NonNull;
-import android.util.Log;
 
 import org.joda.time.DateTime;
+import org.joda.time.DateTimeUtils;
 
 import java.util.HashSet;
 import java.util.Set;
@@ -47,7 +47,7 @@ public class BacklogFilter implements UICallback {
         int id = -1;
         while (now.isAfter(earliestMessage)) {
             filtered.add(new Message(
-                    id,
+                    (int) DateTimeUtils.toJulianDay(now.getMillis()),
                     now,
                     Message.Type.DayChange,
                     new Message.Flags(false, false, false, false, false),
@@ -79,21 +79,22 @@ public class BacklogFilter implements UICallback {
         updateAdd();
     }
 
-    private void updateRemove() {
+    public void update() {
+        updateAdd();
+        updateRemove();
+    }
+
+    public void updateRemove() {
         for (Message message : unfiltered) {
-            if (filterItem(message) && filtered.contains(message)) {
-                String simpleName = getClass().getSimpleName();
-                Log.e(simpleName, "Filtered: "+message);
+            if (filterItem(message)) {
                 filtered.remove(message);
             }
         }
     }
 
-    private void updateAdd() {
+    public void updateAdd() {
         for (Message message : unfiltered) {
-            if (!filterItem(message) && !filtered.contains(message)) {
-                String simpleName = getClass().getSimpleName();
-                Log.e(simpleName, "Unfiltered: "+message);
+            if (!filterItem(message)) {
                 filtered.add(message);
             }
         }
@@ -134,4 +135,29 @@ public class BacklogFilter implements UICallback {
             notifyItemRemoved(i);
         }
     }
+
+    public void setFilters(int filters) {
+        Set<Message.Type> removed = new HashSet<>();
+        for (Message.Type type : filteredTypes) {
+            if ((filters & type.value) == 0)
+                removed.add(type);
+        }
+        for (Message.Type type : removed) {
+            removeFilter(type);
+        }
+
+        for (Message.Type type : Message.Type.values()) {
+            if ((filters & type.value) != 0) {
+                addFilter(type);
+            }
+        }
+    }
+
+    public int getFilters() {
+        int filters = 0x00000000;
+        for (Message.Type type : filteredTypes) {
+            filters |= type.value;
+        }
+        return filters;
+    }
 }

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

@@ -4,7 +4,6 @@ import android.support.annotation.IntRange;
 import android.support.annotation.NonNull;
 import android.support.annotation.Nullable;
 import android.support.v7.widget.RecyclerView;
-import android.util.Log;
 import android.util.SparseArray;
 
 import com.google.common.collect.Lists;
@@ -19,13 +18,11 @@ 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.AndroidAssert;
 import de.kuschku.util.observables.AutoScroller;
 import de.kuschku.util.observables.callbacks.wrappers.AdapterUICallbackWrapper;
 import de.kuschku.util.observables.lists.ObservableComparableSortedList;
 import de.kuschku.util.observables.lists.ObservableSortedList;
 
-import static de.kuschku.util.AndroidAssert.*;
 import static de.kuschku.util.AndroidAssert.assertNotNull;
 
 public class SimpleBacklogManager extends BacklogManager<SimpleBacklogManager> {
@@ -60,6 +57,7 @@ public class SimpleBacklogManager extends BacklogManager<SimpleBacklogManager> {
 
     public void receiveBacklog(@IntRange(from = 0) int bufferId, int from, int to, int count, int extra, @NonNull List<Message> messages) {
         get(bufferId).addAll(messages);
+        client.getNotificationManager().receiveMessages(messages);
 
         busProvider.sendEvent(new BacklogReceivedEvent(bufferId));
     }
@@ -70,6 +68,7 @@ public class SimpleBacklogManager extends BacklogManager<SimpleBacklogManager> {
         assertNotNull(messages);
 
         messages.add(message);
+        client.getNotificationManager().receiveMessage(message);
     }
 
     public void bind(@IntRange(from = 0) int bufferId, @NonNull RecyclerView.Adapter adapter, @Nullable AutoScroller scroller) {

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

@@ -52,20 +52,13 @@ public class Message implements ContentComparable<Message> {
     }
 
     @Override
-    public boolean equalsContent(@NonNull Message message) {
-        return messageId == message.messageId &&
-                time.equals(message.time) &&
-                type == message.type &&
-                flags.equals(message.flags) &&
-                bufferInfo.equals(message.bufferInfo) &&
-                sender.equals(message.sender) &&
-                content.equals(message.content);
+    public boolean areContentsTheSame(@NonNull Message message) {
+        return this == message;
     }
 
     @Override
-    public boolean equals(@Nullable Object o) {
-        return this == o || !(o == null || getClass() != o.getClass()) && messageId == ((Message) o).messageId;
-
+    public boolean areItemsTheSame(Message other) {
+        return this.messageId == other.messageId;
     }
 
     @Override
@@ -75,6 +68,9 @@ public class Message implements ContentComparable<Message> {
 
     @Override
     public int compareTo(@NonNull Message another) {
+        if (this.type != Type.DayChange && another.type != Type.DayChange)
+            return this.messageId - another.messageId;
+        else
             return this.time.compareTo(another.time);
     }
 

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

@@ -13,6 +13,7 @@ import de.kuschku.libquassel.functions.types.UnpackedFunction;
 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.Identity;
 
 @SuppressWarnings({"unchecked", "ConstantConditions"})
 public class SessionStateSerializer implements ObjectSerializer<SessionState> {
@@ -43,7 +44,7 @@ public class SessionStateSerializer implements ObjectSerializer<SessionState> {
     @Override
     public SessionState fromLegacy(@NonNull Map<String, QVariant> map) {
         return new SessionState(
-                (List<Map<String, QVariant>>) map.get("Identities").or(new ArrayList<>()),
+                (List<Identity>) map.get("Identities").or(new ArrayList<>()),
                 (List<BufferInfo>) map.get("BufferInfos").or(new ArrayList<>()),
                 (List<Integer>) map.get("NetworkIds").or(new ArrayList<>())
         );

app/src/main/java/de/kuschku/libquassel/objects/types/SessionState.java

@@ -3,20 +3,19 @@ package de.kuschku.libquassel.objects.types;
 import android.support.annotation.NonNull;
 
 import java.util.List;
-import java.util.Map;
 
 import de.kuschku.libquassel.primitives.types.BufferInfo;
-import de.kuschku.libquassel.primitives.types.QVariant;
+import de.kuschku.libquassel.syncables.types.Identity;
 
 public class SessionState {
     @NonNull
-    public final List<Map<String, QVariant>> Identities;
+    public final List<Identity> Identities;
     @NonNull
     public final List<BufferInfo> BufferInfos;
     @NonNull
     public final List<Integer> NetworkIds;
 
-    public SessionState(@NonNull List<Map<String, QVariant>> identities, @NonNull List<BufferInfo> bufferInfos,
+    public SessionState(@NonNull List<Identity> identities, @NonNull List<BufferInfo> bufferInfos,
                         @NonNull List<Integer> networkIds) {
         this.Identities = identities;
         this.BufferInfos = bufferInfos;

app/src/main/java/de/kuschku/libquassel/primitives/types/BufferInfo.java

@@ -65,4 +65,17 @@ public class BufferInfo {
             }
         }
     }
+
+    public enum BufferStatus {
+        OFFLINE,
+        AWAY,
+        ONLINE
+    }
+
+    public enum ContentStatus {
+        NONE,
+        ACTIVITY,
+        MESSAGES,
+        HIGHLIGHTS
+    }
 }

app/src/main/java/de/kuschku/libquassel/syncables/serializers/BufferViewConfigSerializer.java

@@ -33,7 +33,7 @@ public class BufferViewConfigSerializer implements ObjectSerializer<BufferViewCo
         map.data.put("bufferViewName", new QVariant<>(data.getBufferViewName()));
         map.data.put("TemporarilyRemovedBuffers", new QVariant<>(data.getTemporarilyRemovedBuffers()));
         map.data.put("hideInactiveNetworks", new QVariant<>(data.isHideInactiveNetworks()));
-        map.data.put("BufferList", new QVariant<>(data.getBufferList()));
+        map.data.put("BufferList", new QVariant<>(data.getBuffers()));
         map.data.put("allowedBufferTypes", new QVariant<>(data.getAllowedBufferTypes()));
         map.data.put("sortAlphabetically", new QVariant<>(data.isSortAlphabetically()));
         map.data.put("disableDecoration", new QVariant<>(data.isDisableDecoration()));

app/src/main/java/de/kuschku/libquassel/syncables/types/BufferViewConfig.java

 package de.kuschku.libquassel.syncables.types;
 
-import android.net.*;
 import android.support.annotation.NonNull;
+import android.util.Log;
 
 import java.util.Collections;
 import java.util.List;
@@ -11,20 +11,18 @@ import de.kuschku.libquassel.BusProvider;
 import de.kuschku.libquassel.Client;
 import de.kuschku.libquassel.functions.types.InitDataFunction;
 import de.kuschku.libquassel.primitives.types.QVariant;
-import de.kuschku.libquassel.syncables.serializers.BufferSyncerSerializer;
 import de.kuschku.libquassel.syncables.serializers.BufferViewConfigSerializer;
-import de.kuschku.util.AndroidAssert;
 import de.kuschku.util.observables.callbacks.ElementCallback;
 import de.kuschku.util.observables.lists.IObservableList;
 import de.kuschku.util.observables.lists.ObservableElementList;
 
-import static de.kuschku.util.AndroidAssert.*;
+import static de.kuschku.util.AndroidAssert.assertNotNull;
 
 public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
     private String bufferViewName;
-    private List<Integer> TemporarilyRemovedBuffers;
+    private List<Integer> temporarilyRemovedBuffers;
     private boolean hideInactiveNetworks;
-    private IObservableList<ElementCallback<Integer>, Integer> BufferList;
+    private IObservableList<ElementCallback<Integer>, Integer> buffers;
     private IObservableList<ElementCallback<Integer>, Integer> NetworkList = new ObservableElementList<>();
     private int allowedBufferTypes;
     private boolean sortAlphabetically;
@@ -33,14 +31,14 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
     private int networkId;
     private int minimumActivity;
     private boolean hideInactiveBuffers;
-    private List<Integer> RemovedBuffers;
+    private List<Integer> removedBuffers;
     private Client client;
 
     public BufferViewConfig(String bufferViewName, List<Integer> temporarilyRemovedBuffers, boolean hideInactiveNetworks, @NonNull List<Integer> bufferList, int allowedBufferTypes, boolean sortAlphabetically, boolean disableDecoration, boolean addNewBuffersAutomatically, int networkId, int minimumActivity, boolean hideInactiveBuffers, List<Integer> removedBuffers) {
         this.bufferViewName = bufferViewName;
-        this.TemporarilyRemovedBuffers = temporarilyRemovedBuffers;
+        this.temporarilyRemovedBuffers = temporarilyRemovedBuffers;
         this.hideInactiveNetworks = hideInactiveNetworks;
-        this.BufferList = new ObservableElementList<>(bufferList);
+        this.buffers = new ObservableElementList<>(bufferList);
         this.allowedBufferTypes = allowedBufferTypes;
         this.sortAlphabetically = sortAlphabetically;
         this.disableDecoration = disableDecoration;
@@ -48,7 +46,7 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         this.networkId = networkId;
         this.minimumActivity = minimumActivity;
         this.hideInactiveBuffers = hideInactiveBuffers;
-        this.RemovedBuffers = removedBuffers;
+        this.removedBuffers = removedBuffers;
     }
 
     public String getBufferViewName() {
@@ -60,11 +58,11 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
     }
 
     public List<Integer> getTemporarilyRemovedBuffers() {
-        return TemporarilyRemovedBuffers;
+        return temporarilyRemovedBuffers;
     }
 
     public void setTemporarilyRemovedBuffers(List<Integer> temporarilyRemovedBuffers) {
-        TemporarilyRemovedBuffers = temporarilyRemovedBuffers;
+        this.temporarilyRemovedBuffers = temporarilyRemovedBuffers;
     }
 
     public boolean isHideInactiveNetworks() {
@@ -75,16 +73,23 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         this.hideInactiveNetworks = hideInactiveNetworks;
     }
 
-    public IObservableList<ElementCallback<Integer>, Integer> getBufferList() {
-        return BufferList;
+
+    public void SYNC_setHideInactiveNetworks(boolean hideInactiveNetworks) {
+        if (this.hideInactiveNetworks == hideInactiveNetworks) return;
+        setHideInactiveNetworks(hideInactiveBuffers);
+        sync("setHideInactiveBuffers", new Object[]{hideInactiveNetworks});
+    }
+
+    public IObservableList<ElementCallback<Integer>, Integer> getBuffers() {
+        return buffers;
     }
 
-    public void setBufferList(IObservableList<ElementCallback<Integer>, Integer> bufferList) {
-        BufferList = bufferList;
+    public void setBuffers(IObservableList<ElementCallback<Integer>, Integer> buffers) {
+        this.buffers = buffers;
     }
 
     public void setBufferList(@NonNull List<Integer> bufferList) {
-        BufferList = new ObservableElementList<>(bufferList);
+        buffers = new ObservableElementList<>(bufferList);
     }
 
     public int getAllowedBufferTypes() {
@@ -125,10 +130,11 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
 
     public void setNetworkId(int networkId) {
         this.networkId = networkId;
-        if (this.networkId != -1) {
-            this.NetworkList.addAll(client.getNetworks());
+        if (this.networkId != 0) {
+            if (client.getNetworks().contains(networkId))
+                this.NetworkList.add(networkId);
         } else {
-            this.NetworkList.retainAll(Collections.singletonList(networkId));
+            this.NetworkList.addAll(client.getNetworks());
         }
     }
 
@@ -148,12 +154,18 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         this.hideInactiveBuffers = hideInactiveBuffers;
     }
 
+    public void SYNC_setHideInactiveBuffers(boolean hideInactiveBuffers) {
+        if (this.hideInactiveBuffers == hideInactiveBuffers) return;
+        setHideInactiveBuffers(hideInactiveBuffers);
+        sync("setHideInactiveBuffers", new Object[]{hideInactiveBuffers});
+    }
+
     public List<Integer> getRemovedBuffers() {
-        return RemovedBuffers;
+        return removedBuffers;
     }
 
     public void setRemovedBuffers(List<Integer> removedBuffers) {
-        RemovedBuffers = removedBuffers;
+        this.removedBuffers = removedBuffers;
     }
 
     @NonNull
@@ -161,9 +173,9 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
     public String toString() {
         return "BufferViewConfig{" +
                 "bufferViewName='" + bufferViewName + '\'' +
-                ", TemporarilyRemovedBuffers=" + TemporarilyRemovedBuffers +
+                ", temporarilyRemovedBuffers=" + temporarilyRemovedBuffers +
                 ", hideInactiveNetworks=" + hideInactiveNetworks +
-                ", BufferList=" + BufferList +
+                ", buffers=" + buffers +
                 ", allowedBufferTypes=" + allowedBufferTypes +
                 ", sortAlphabetically=" + sortAlphabetically +
                 ", disableDecoration=" + disableDecoration +
@@ -171,7 +183,7 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
                 ", networkId=" + networkId +
                 ", minimumActivity=" + minimumActivity +
                 ", hideInactiveBuffers=" + hideInactiveBuffers +
-                ", RemovedBuffers=" + RemovedBuffers +
+                ", removedBuffers=" + removedBuffers +
                 '}';
     }
 
@@ -186,9 +198,9 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
     @Override
     public void update(BufferViewConfig from) {
         this.bufferViewName = from.bufferViewName;
-        this.TemporarilyRemovedBuffers = from.TemporarilyRemovedBuffers;
+        this.temporarilyRemovedBuffers = from.temporarilyRemovedBuffers;
         this.hideInactiveNetworks = from.hideInactiveNetworks;
-        this.BufferList = from.BufferList;
+        this.buffers = from.buffers;
         this.allowedBufferTypes = from.allowedBufferTypes;
         this.sortAlphabetically = from.sortAlphabetically;
         this.disableDecoration = from.disableDecoration;
@@ -196,7 +208,7 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         this.networkId = from.networkId;
         this.minimumActivity = from.minimumActivity;
         this.hideInactiveBuffers = from.hideInactiveBuffers;
-        this.RemovedBuffers = from.RemovedBuffers;
+        this.removedBuffers = from.removedBuffers;
     }
 
     @Override
@@ -204,8 +216,22 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         update(BufferViewConfigSerializer.get().fromDatastream(from));
     }
 
-    public void addBuffer(int bufferId, int position) {
-        BufferList.add(position, bufferId);
+    public void addBuffer(int bufferId, int pos) {
+        if (buffers.contains(bufferId))
+            return;
+
+        if (pos < 0)
+            pos = 0;
+        if (pos > buffers.size())
+            pos = buffers.size();
+
+        if (removedBuffers.contains(bufferId))
+            removedBuffers.remove(removedBuffers.indexOf(bufferId));
+
+        if (temporarilyRemovedBuffers.contains(bufferId))
+            temporarilyRemovedBuffers.remove(temporarilyRemovedBuffers.indexOf(bufferId));
+
+        buffers.add(pos, bufferId);
     }
 
     public void SYNC_addBuffer(int bufferId, int position) {
@@ -213,8 +239,36 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         sync("addBuffer", new Object[]{bufferId, position});
     }
 
+    public void moveBuffer(int bufferId, int pos) {
+        if (!buffers.contains(bufferId))
+            return;
+
+        if (pos < 0)
+            pos = 0;
+        if (pos >= buffers.size())
+            pos = buffers.size() - 1;
+
+        int index = buffers.indexOf(bufferId);
+        if (pos == index)
+            return;
+        if (pos > index)
+            pos--;
+
+        buffers.remove(index);
+        buffers.add(pos, bufferId);
+    }
+
+    public void SYNC_moveBuffer(int bufferId, int position) {
+        moveBuffer(bufferId, position);
+        sync("moveBuffer", new Object[]{bufferId, position});
+    }
+
     public void removeBuffer(int bufferId) {
-        if (BufferList.contains(bufferId)) BufferList.remove(BufferList.indexOf(bufferId));
+        if (buffers.contains(bufferId))
+            buffers.remove(buffers.indexOf(bufferId));
+        if (removedBuffers.contains(bufferId))
+            removedBuffers.remove(removedBuffers.indexOf(bufferId));
+        temporarilyRemovedBuffers.add(bufferId);
     }
 
     public void SYNC_removeBuffer(int bufferId) {
@@ -222,6 +276,21 @@ public class BufferViewConfig extends SyncableObject<BufferViewConfig> {
         sync("removeBuffer", new Object[]{bufferId});
     }
 
+    public void removeBufferPermanently(int bufferId) {
+        if (buffers.contains(bufferId))
+            buffers.remove(buffers.indexOf(bufferId));
+        if (temporarilyRemovedBuffers.contains(bufferId))
+            temporarilyRemovedBuffers.remove(temporarilyRemovedBuffers.indexOf(bufferId));
+        removedBuffers.add(bufferId);
+    }
+
+    public void SYNC_removeBufferPermanently(int bufferId) {
+        removeBufferPermanently(bufferId);
+        sync("removeBufferPermanently", new Object[]{bufferId});
+    }
+
+
+
     @NonNull
     public IObservableList<ElementCallback<Integer>, Integer> getNetworkList() {
         return NetworkList;