Automatically add newly joined buffers

lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferSyncer.kt

@@ -4,12 +4,14 @@ import de.kuschku.libquassel.protocol.*
 import de.kuschku.libquassel.protocol.Type
 import de.kuschku.libquassel.quassel.BufferInfo
 import de.kuschku.libquassel.quassel.syncables.interfaces.IBufferSyncer
+import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.session.SignalProxy
 import io.reactivex.Observable
 import io.reactivex.subjects.BehaviorSubject
 
 class BufferSyncer constructor(
-  proxy: SignalProxy
+  proxy: SignalProxy,
+  private val session: ISession
 ) : SyncableObject(proxy, "BufferSyncer"), IBufferSyncer {
   fun lastSeenMsg(buffer: BufferId): MsgId = _lastSeenMsg[buffer] ?: 0
   fun liveLastSeenMsg(buffer: BufferId): Observable<MsgId>
@@ -39,6 +41,7 @@ class BufferSyncer constructor(
   fun liveBufferInfo(bufferId: BufferId)
     = live_bufferInfos.map { bufferInfo(bufferId) }.distinctUntilChanged()
 
+  fun bufferInfos(): Collection<BufferInfo> = _bufferInfos.values
   fun liveBufferInfos(): Observable<Map<BufferId, BufferInfo>> = live_bufferInfos
 
   override fun toVariantMap(): QVariantMap = mapOf(
@@ -158,9 +161,14 @@ class BufferSyncer constructor(
   }
 
   fun bufferInfoUpdated(info: BufferInfo) {
-    if (info != _bufferInfos[info.bufferId]) {
+    val oldInfo = _bufferInfos[info.bufferId]
+    if (info != oldInfo) {
       _bufferInfos[info.bufferId] = info
       live_bufferInfos.onNext(_bufferInfos)
+
+      if (oldInfo == null) {
+        session.bufferViewManager?.handleBuffer(info, this)
+      }
     }
   }
 

lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewConfig.kt

@@ -3,13 +3,16 @@ package de.kuschku.libquassel.quassel.syncables
 import clamp
 import de.kuschku.libquassel.protocol.*
 import de.kuschku.libquassel.protocol.Type
+import de.kuschku.libquassel.quassel.BufferInfo
 import de.kuschku.libquassel.quassel.syncables.interfaces.IBufferViewConfig
+import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.session.SignalProxy
 import io.reactivex.subjects.BehaviorSubject
 
 class BufferViewConfig constructor(
   bufferViewId: Int,
-  proxy: SignalProxy
+  proxy: SignalProxy,
+  private val session: ISession
 ) : SyncableObject(proxy, "BufferViewConfig"), IBufferViewConfig {
   override fun init() {
     renameObject("$_bufferViewId")
@@ -26,6 +29,13 @@ class BufferViewConfig constructor(
     initSetRemovedBuffers(properties["RemovedBuffers"].valueOr(::emptyList))
     initSetTemporarilyRemovedBuffers(properties["TemporarilyRemovedBuffers"].valueOr(::emptyList))
     initSetProperties(properties)
+
+    val bufferSyncer = session.bufferSyncer
+    if (bufferSyncer != null) {
+      for (info in bufferSyncer.bufferInfos()) {
+        handleBuffer(info, bufferSyncer)
+      }
+    }
   }
 
   override fun initBufferList(): QVariantList = _buffers.map {
@@ -253,4 +263,19 @@ class BufferViewConfig constructor(
     override fun compare(a: BufferViewConfig?, b: BufferViewConfig?)
       = (a?.bufferViewName() ?: "").compareTo((b?.bufferViewName() ?: ""), true)
   }
+
+  fun handleBuffer(info: BufferInfo, bufferSyncer: BufferSyncer) {
+    if (_addNewBuffersAutomatically &&
+        !_buffers.contains(info.bufferId) &&
+        !_temporarilyRemovedBuffers.contains(info.bufferId) &&
+        !_removedBuffers.contains(info.bufferId)) {
+      val position = if (_sortAlphabetically) {
+        val sortedBuffers = _buffers.mapNotNull { bufferSyncer.bufferInfo(it)?.bufferName }
+        -sortedBuffers.binarySearch(info.bufferName)
+      } else {
+        _buffers.size
+      }
+      requestAddBuffer(info.bufferId, position)
+    }
+  }
 }

lib/src/main/java/de/kuschku/libquassel/quassel/syncables/BufferViewManager.kt

 package de.kuschku.libquassel.quassel.syncables
 
 import de.kuschku.libquassel.protocol.*
+import de.kuschku.libquassel.quassel.BufferInfo
 import de.kuschku.libquassel.quassel.syncables.interfaces.IBufferViewManager
+import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.session.SignalProxy
 import io.reactivex.Observable
 import io.reactivex.subjects.BehaviorSubject
 
 class BufferViewManager constructor(
-  proxy: SignalProxy
+  proxy: SignalProxy,
+  private val session: ISession
 ) : SyncableObject(proxy, "BufferViewManager"), IBufferViewManager {
   override fun toVariantMap(): QVariantMap = mapOf(
     "BufferViewIds" to QVariant_(initBufferViewIds(), Type.QVariantList)
@@ -46,7 +49,7 @@ class BufferViewManager constructor(
     if (_bufferViewConfigs.contains(bufferViewConfigId))
       return
 
-    addBufferViewConfig(BufferViewConfig(bufferViewConfigId, proxy))
+    addBufferViewConfig(BufferViewConfig(bufferViewConfigId, proxy, session))
   }
 
   override fun deleteBufferViewConfig(bufferViewConfigId: Int) {
@@ -62,4 +65,10 @@ class BufferViewManager constructor(
 
   private val live_bufferViewConfigs: BehaviorSubject<Set<Int>>
     = BehaviorSubject.createDefault<Set<Int>>(emptySet())
+
+  fun handleBuffer(info: BufferInfo, bufferSyncer: BufferSyncer) {
+    for (bufferViewConfig in bufferViewConfigs()) {
+      bufferViewConfig.handleBuffer(info, bufferSyncer)
+    }
+  }
 }

lib/src/main/java/de/kuschku/libquassel/session/Session.kt

@@ -35,8 +35,8 @@ class Session(
 
   override val aliasManager = AliasManager(this)
   override val backlogManager = BacklogManager(this, backlogStorage)
-  override val bufferSyncer = BufferSyncer(this)
-  override val bufferViewManager = BufferViewManager(this)
+  override val bufferViewManager = BufferViewManager(this, this)
+  override val bufferSyncer = BufferSyncer(this, this)
   override val certManagers = mutableMapOf<IdentityId, CertManager>()
   override val coreInfo = CoreInfo(this)
   override val dccConfig = DccConfig(this)
@@ -76,17 +76,17 @@ class Session(
 
     f.networkIds?.forEach {
       val network = Network(it.value(-1), this)
-      networks.put(network.networkId(), network)
+      networks[network.networkId()] = network
     }
 
     f.identities?.forEach {
       val identity = Identity(this)
       identity.fromVariantMap(it.valueOr(::emptyMap))
       identity.initialized = true
-      identities.put(identity.id(), identity)
+      identities[identity.id()] = identity
 
       val certManager = CertManager(identity.id(), this)
-      certManagers.put(identity.id(), certManager)
+      certManagers[identity.id()] = certManager
     }
 
     isInitializing = true