Implements reconnection logic

app/src/main/java/de/kuschku/quasseldroid_ng/persistence/PersistentSession.kt

-package de.kuschku.quasseldroid_ng.persistence
-
-import de.kuschku.libquassel.protocol.IdentityId
-import de.kuschku.libquassel.protocol.NetworkId
-import de.kuschku.libquassel.quassel.syncables.*
-import de.kuschku.libquassel.session.ConnectionState
-import de.kuschku.libquassel.session.ISession
-import io.reactivex.subjects.BehaviorSubject
-
-class PersistentSession : ISession {
-  override val aliasManager: AliasManager? = null
-  override val backlogManager: BacklogManager? = null
-  override val bufferSyncer: BufferSyncer? = null
-  override val bufferViewManager: BufferViewManager? = null
-  override val certManagers: Map<IdentityId, CertManager> = emptyMap()
-  override val coreInfo: CoreInfo? = null
-  override val dccConfig: DccConfig? = null
-  override val identities: Map<IdentityId, Identity> = emptyMap()
-  override val ignoreListManager: IgnoreListManager? = null
-  override val ircListHelper: IrcListHelper? = null
-  override val networks: Map<NetworkId, Network> = emptyMap()
-  override val networkConfig: NetworkConfig? = null
-
-  override fun close() = Unit
-  override val state: BehaviorSubject<ConnectionState>
-    = BehaviorSubject.createDefault(ConnectionState.DISCONNECTED)
-}

app/src/main/java/de/kuschku/quasseldroid_ng/persistence/QuasselDatabase.kt

@@ -7,24 +7,11 @@ import de.kuschku.libquassel.protocol.Message_Flag
 import de.kuschku.libquassel.protocol.Message_Type
 import org.threeten.bp.Instant
 
-@Database(entities = arrayOf(QuasselDatabase.Buffer::class, QuasselDatabase.Network::class,
-                             QuasselDatabase.DatabaseMessage::class),
-          version = 2)
+@Database(entities = arrayOf(QuasselDatabase.DatabaseMessage::class), version = 2)
 @TypeConverters(QuasselDatabase.DatabaseMessage.MessageTypeConverters::class)
 abstract class QuasselDatabase : RoomDatabase() {
-  abstract fun networks(): NetworkDao
-  abstract fun buffers(): BufferDao
   abstract fun message(): MessageDao
 
-  @Entity(indices = arrayOf(Index("networkId")))
-  class Buffer(
-    @PrimaryKey var bufferId: Int,
-    var networkId: Int,
-    var type: Int,
-    var groupId: Int,
-    var bufferName: String
-  )
-
   @Entity(tableName = "message")
   open class DatabaseMessage(
     @PrimaryKey var messageId: Int,
@@ -51,60 +38,6 @@ abstract class QuasselDatabase : RoomDatabase() {
     }
   }
 
-  @Entity
-  class Network(
-    @PrimaryKey var networkId: Int,
-    var networkName: String
-  )
-
-  @Entity
-  class BufferViewConfig(
-    @PrimaryKey var id: Int,
-    var name: String
-  )
-
-  @Dao
-  interface NetworkDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun save(vararg entities: QuasselDatabase.Network)
-
-    @Query("SELECT * FROM network WHERE networkId = :networkId")
-    fun findById(networkId: Int): QuasselDatabase.Network
-
-    @Query("SELECT * FROM network")
-    fun all(): List<QuasselDatabase.Network>
-
-    @Delete
-    fun delete(Network: QuasselDatabase.Network)
-
-    @Query("DELETE FROM network")
-    fun clear()
-  }
-
-  @Dao
-  interface BufferDao {
-    @Insert(onConflict = OnConflictStrategy.REPLACE)
-    fun save(vararg entities: QuasselDatabase.Buffer)
-
-    @Query("SELECT * FROM buffer WHERE networkId = :bufferId")
-    fun findById(bufferId: Int): QuasselDatabase.Buffer
-
-    @Query("SELECT * FROM buffer WHERE networkId = :networkId")
-    fun findByNetwork(networkId: Int): List<QuasselDatabase.Buffer>
-
-    @Query("DELETE FROM buffer WHERE networkId = :networkId")
-    fun deleteByNetwork(networkId: Int)
-
-    @Query("SELECT * FROM buffer")
-    fun all(): List<QuasselDatabase.Buffer>
-
-    @Delete
-    fun delete(buffer: QuasselDatabase.Buffer)
-
-    @Query("DELETE FROM buffer")
-    fun clear()
-  }
-
   @Dao
   interface MessageDao {
     @Query("SELECT * FROM message WHERE messageId = :messageId")

app/src/main/java/de/kuschku/quasseldroid_ng/service/QuasselService.kt

 package de.kuschku.quasseldroid_ng.service
 
 import android.arch.lifecycle.LifecycleService
+import android.arch.lifecycle.Observer
 import android.content.Intent
 import android.os.Binder
 import de.kuschku.libquassel.protocol.*
 import de.kuschku.libquassel.session.Backend
+import de.kuschku.libquassel.session.ISession
 import de.kuschku.libquassel.session.SessionManager
 import de.kuschku.libquassel.session.SocketAddress
 import de.kuschku.quasseldroid_ng.BuildConfig
 import de.kuschku.quasseldroid_ng.R
-import de.kuschku.quasseldroid_ng.persistence.PersistentSession
 import de.kuschku.quasseldroid_ng.persistence.QuasselDatabase
 import de.kuschku.quasseldroid_ng.util.AndroidHandlerThread
 import de.kuschku.quasseldroid_ng.util.compatibility.AndroidHandlerService
+import de.kuschku.quasseldroid_ng.util.helper.toLiveData
 import org.threeten.bp.Instant
 import java.security.cert.X509Certificate
+import java.util.concurrent.TimeUnit
 import javax.net.ssl.X509TrustManager
 
 class QuasselService : LifecycleService() {
@@ -35,16 +38,21 @@ class QuasselService : LifecycleService() {
   private val backendImplementation = object : Backend {
     override fun sessionManager() = sessionManager
 
-    override fun connectUnlessConnected(address: SocketAddress, user: String, pass: String) {
+    override fun connectUnlessConnected(address: SocketAddress, user: String, pass: String,
+                                        reconnect: Boolean) {
       sessionManager.ifDisconnected {
-        this.connect(address, user, pass)
+        this.connect(address, user, pass, reconnect)
       }
     }
 
-    override fun connect(address: SocketAddress, user: String, pass: String) {
+    override fun connect(address: SocketAddress, user: String, pass: String, reconnect: Boolean) {
       disconnect()
-      val handlerService = AndroidHandlerService()
-      sessionManager.connect(clientData, trustManager, address, handlerService, user to pass)
+      sessionManager.connect(clientData, trustManager, address, ::AndroidHandlerService,
+                             user to pass, reconnect)
+    }
+
+    override fun reconnect() {
+      sessionManager.reconnect()
     }
 
     override fun disconnect() {
@@ -55,15 +63,22 @@ class QuasselService : LifecycleService() {
   private val handler = AndroidHandlerThread("Backend")
 
   private val asyncBackend = object : Backend {
-    override fun connectUnlessConnected(address: SocketAddress, user: String, pass: String) {
+    override fun connectUnlessConnected(address: SocketAddress, user: String, pass: String,
+                                        reconnect: Boolean) {
+      handler.post {
+        backendImplementation.connectUnlessConnected(address, user, pass, reconnect)
+      }
+    }
+
+    override fun connect(address: SocketAddress, user: String, pass: String, reconnect: Boolean) {
       handler.post {
-        backendImplementation.connectUnlessConnected(address, user, pass)
+        backendImplementation.connect(address, user, pass, reconnect)
       }
     }
 
-    override fun connect(address: SocketAddress, user: String, pass: String) {
+    override fun reconnect() {
       handler.post {
-        backendImplementation.connect(address, user, pass)
+        backendImplementation.reconnect()
       }
     }
 
@@ -87,7 +102,7 @@ class QuasselService : LifecycleService() {
     handler.onCreate()
     super.onCreate()
     database = QuasselDatabase.Creator.init(application)
-    sessionManager = SessionManager(PersistentSession())
+    sessionManager = SessionManager(ISession.NULL)
     clientData = ClientData(
       identifier = "${resources.getString(R.string.app_name)} ${BuildConfig.VERSION_NAME}",
       buildDate = Instant.ofEpochSecond(BuildConfig.GIT_COMMIT_DATE),
@@ -98,6 +113,13 @@ class QuasselService : LifecycleService() {
       ),
       supportedProtocols = listOf(Protocol.Datastream)
     )
+    sessionManager.state
+      .distinctUntilChanged()
+      .debounce(50, TimeUnit.MILLISECONDS)
+      .toLiveData()
+      .observe(this, Observer {
+        sessionManager.reconnect()
+      })
   }
 
   override fun onBind(intent: Intent?): QuasselBinder {

app/src/main/java/de/kuschku/quasseldroid_ng/ui/chat/ChatActivity.kt

@@ -107,7 +107,8 @@ class ChatActivity : ServiceBoundActivity() {
             backendValue.connectUnlessConnected(
               SocketAddress(account.host, account.port.toShort()),
               account.user,
-              account.pass
+              account.pass,
+              true
             )
           }
         }