Split the project into library and app modules

app/build.gradle.kts

@@ -101,7 +101,7 @@ dependencies {
   kapt(appArch("persistence.room", "compiler"))
 
   implementation(appArch("paging", "runtime", version = "1.0.0-alpha1")) {
-    exclude(group = "junit", module = "junit")
+    exclude(group = "com.android.support", module = "support-media-compat")
   }
 
   implementation("org.threeten:threetenbp:1.3.6") {
@@ -117,28 +117,16 @@ dependencies {
     exclude(group = "com.android.support", module = "support-media-compat")
   }
 
+  implementation(project(":lib"))
+
   implementation(project(":invokerannotations"))
   kapt(project(":invokergenerator"))
 
-  testImplementation("android.arch.persistence.room:testing:1.0.0-alpha9") {
-    exclude(group = "com.android.support", module = "support-media-compat")
-  }
-  testImplementation("junit:junit:4.12") {
-    exclude(group = "com.android.support", module = "support-media-compat")
-  }
-
-  androidTestImplementation("com.android.support.test:runner:0.5") {
-    exclude(group = "com.android.support", module = "support-media-compat")
-  }
-  androidTestImplementation("com.android.support.test:rules:0.5") {
-    exclude(group = "com.android.support", module = "support-media-compat")
-  }
-}
+  testImplementation("android.arch.persistence.room:testing:1.0.0-alpha9")
+  testImplementation("junit:junit:4.12")
 
-kapt {
-  arguments(delegateClosureOf<KaptAnnotationProcessorOptions> {
-    arg("eventBusIndex", "de.kuschku.quasseldroid_ng.EventBusIndex")
-  })
+  androidTestImplementation("com.android.support.test:runner:0.5")
+  androidTestImplementation("com.android.support.test:rules:0.5")
 }
 
 fun cmd(vararg command: String) = try {

app/src/main/java/de/kuschku/quasseldroid_ng/Exceptions.kt

-package de.kuschku.quasseldroid_ng
-
-abstract class QuasselException : Exception()
-data class ObjectNotFoundException(val className: String, val objectName: String) :
-  QuasselException()
-
-data class WrongObjectTypeException(val obj: Any?, val type: String) : QuasselException()
-data class UnknownMethodException(val className: String, val methodName: String) :
-  QuasselException()

app/src/main/java/de/kuschku/quasseldroid_ng/QuasseldroidNG.kt

@@ -8,7 +8,9 @@ import android.content.pm.ShortcutManager
 import android.graphics.drawable.Icon
 import android.os.Build
 import de.kuschku.quasseldroid_ng.service.QuasselService
-import de.kuschku.quasseldroid_ng.util.helpers.systemService
+import de.kuschku.quasseldroid_ng.util.AndroidCompatibilityUtils
+import de.kuschku.quasseldroid_ng.util.AndroidLoggingHandler
+import de.kuschku.quasseldroid_ng.util.helper.systemService
 import org.acra.ACRA
 import org.acra.ReportingInteractionMode
 import org.acra.config.ConfigurationBuilder
@@ -30,6 +32,10 @@ class QuasseldroidNG : Application() {
     super.onCreate()
 
     if (!ACRA.isACRASenderServiceProcess()) {
+      // Init compatibility utils
+      AndroidCompatibilityUtils.init()
+      AndroidLoggingHandler.init()
+
       startService(Intent(this, QuasselService::class.java))
       if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.O) {
         systemService<ShortcutManager>().dynamicShortcuts = listOf(

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

@@ -3,19 +3,14 @@ package de.kuschku.quasseldroid_ng.persistence
 import android.arch.persistence.room.*
 import android.content.Context
 import android.support.annotation.IntRange
-import de.kuschku.quasseldroid_ng.protocol.Message_Flag
-import de.kuschku.quasseldroid_ng.protocol.Message_Flags
-import de.kuschku.quasseldroid_ng.protocol.Message_Type
-import de.kuschku.quasseldroid_ng.protocol.Message_Types
-import de.kuschku.quasseldroid_ng.quassel.BufferInfo
-import de.kuschku.quasseldroid_ng.util.Flag
-import de.kuschku.quasseldroid_ng.util.Flags
+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.Message::class),
+                             QuasselDatabase.DatabaseMessage::class),
           version = 2)
-@TypeConverters(QuasselDatabase.Message.MessageTypeConverters::class)
+@TypeConverters(QuasselDatabase.DatabaseMessage.MessageTypeConverters::class)
 abstract class QuasselDatabase : RoomDatabase() {
   abstract fun networks(): NetworkDao
   abstract fun buffers(): BufferDao
@@ -30,20 +25,8 @@ abstract class QuasselDatabase : RoomDatabase() {
     var bufferName: String
   )
 
-  class RawMessage(
-    messageId: Int,
-    time: Instant,
-    type: Message_Types,
-    flag: Message_Flags,
-    var bufferInfo: BufferInfo,
-    sender: String,
-    senderPrefixes: String,
-    content: String
-  ) : Message(messageId, time, type.toInt(), flag.toInt(), bufferInfo.bufferId, sender,
-              senderPrefixes, content)
-
-  @Entity
-  open class Message(
+  @Entity(tableName = "message")
+  open class DatabaseMessage(
     @PrimaryKey var messageId: Int,
     var time: Instant,
     var type: Int,
@@ -53,48 +36,6 @@ abstract class QuasselDatabase : RoomDatabase() {
     var senderPrefixes: String,
     var content: String
   ) {
-    enum class MessageType(override val bit: Int) : Flag<MessageType> {
-      Plain(0x00001),
-      Notice(0x00002),
-      Action(0x00004),
-      Nick(0x00008),
-      Mode(0x00010),
-      Join(0x00020),
-      Part(0x00040),
-      Quit(0x00080),
-      Kick(0x00100),
-      Kill(0x00200),
-      Server(0x00400),
-      Info(0x00800),
-      Error(0x01000),
-      DayChange(0x02000),
-      Topic(0x04000),
-      NetsplitJoin(0x08000),
-      NetsplitQuit(0x10000),
-      Invite(0x20000),
-      Markerline(0x40000);
-
-      companion object : Flags.Factory<MessageType> {
-        override val NONE = MessageType.of()
-        override fun of(bit: Int) = Flags.of<MessageType>(bit)
-        override fun of(vararg flags: MessageType) = Flags.of(*flags)
-      }
-    }
-
-    enum class MessageFlag(override val bit: Int) : Flag<MessageFlag> {
-      Self(0x01),
-      Highlight(0x02),
-      Redirected(0x04),
-      ServerMsg(0x08),
-      Backlog(0x80);
-
-      companion object : Flags.Factory<MessageFlag> {
-        override val NONE = MessageFlag.of()
-        override fun of(bit: Int) = Flags.of<MessageFlag>(bit)
-        override fun of(vararg flags: MessageFlag) = Flags.of(*flags)
-      }
-    }
-
     class MessageTypeConverters {
       @TypeConverter
       fun convertInstant(value: Long) = Instant.ofEpochMilli(value)
@@ -161,16 +102,16 @@ abstract class QuasselDatabase : RoomDatabase() {
   @Dao
   interface MessageDao {
     @Query("SELECT * FROM message WHERE messageId = :messageId")
-    fun find(messageId: Int): Message
+    fun find(messageId: Int): DatabaseMessage
 
     @Query("SELECT * FROM message WHERE bufferId = :bufferId")
-    fun findByBufferId(bufferId: Int): List<Message>
+    fun findByBufferId(bufferId: Int): List<DatabaseMessage>
 
     @Query("SELECT * FROM message WHERE bufferId = :bufferId ORDER BY messageId DESC LIMIT 1")
-    fun findLastByBufferId(bufferId: Int): Message
+    fun findLastByBufferId(bufferId: Int): DatabaseMessage
 
     @Update(onConflict = OnConflictStrategy.REPLACE)
-    fun save(entity: Message)
+    fun save(entity: DatabaseMessage)
 
     @Query("UPDATE message SET bufferId = :bufferId1 WHERE bufferId = :bufferId2")
     fun merge(@IntRange(from = 0) bufferId1: Int, @IntRange(from = 0) bufferId2: Int)

app/src/main/java/de/kuschku/quasseldroid_ng/quassel/NetworkInfo.kt

-package de.kuschku.quasseldroid_ng.quassel
-

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

@@ -8,8 +8,9 @@ import android.os.Binder
 import de.kuschku.quasseldroid_ng.BuildConfig
 import de.kuschku.quasseldroid_ng.R
 import de.kuschku.quasseldroid_ng.persistence.QuasselDatabase
-import de.kuschku.quasseldroid_ng.protocol.*
-import de.kuschku.quasseldroid_ng.session.*
+import de.kuschku.libquassel.protocol.*
+import de.kuschku.libquassel.session.*
+import de.kuschku.quasseldroid_ng.util.AndroidHandlerService
 import org.threeten.bp.Instant
 import java.security.cert.X509Certificate
 import javax.net.ssl.X509TrustManager
@@ -22,15 +23,15 @@ class QuasselService : LifecycleService() {
 
     override fun connect(address: SocketAddress, user: String, pass: String) {
       disconnect()
-      session.coreConnection = CoreConnection(session, address)
+      val handlerService = AndroidHandlerService()
+      session.coreConnection = CoreConnection(session, address, handlerService)
       session.coreConnection?.start()
       session.userData = user to pass
       connection.postValue(session.coreConnection)
     }
 
     override fun disconnect() {
-      session.coreConnection?.close()
-      session.coreConnection = null
+      session.cleanUp()
       connection.postValue(null)
       ABSENT.postValue(ConnectionState.DISCONNECTED)
     }
@@ -38,9 +39,6 @@ class QuasselService : LifecycleService() {
     private val connection = MutableLiveData<CoreConnection>()
 
     val ABSENT = MutableLiveData<ConnectionState>()
-    override val status = Transformations.switchMap(connection) { input: CoreConnection? ->
-      input?.liveState ?: ABSENT
-    }
   }
 
   private lateinit var database: QuasselDatabase

app/src/main/java/de/kuschku/quasseldroid_ng/ui/MainActivity.kt

 package de.kuschku.quasseldroid_ng.ui
 
 import android.arch.lifecycle.LiveData
-import android.arch.lifecycle.Observer
 import android.os.Bundle
 import android.support.design.widget.Snackbar
-import android.util.Log
 import android.view.Menu
 import android.view.MenuItem
 import android.widget.Button
@@ -12,17 +10,17 @@ import android.widget.EditText
 import android.widget.TextView
 import butterknife.BindView
 import butterknife.ButterKnife
+import de.kuschku.libquassel.session.Backend
+import de.kuschku.libquassel.session.Session
+import de.kuschku.libquassel.session.SocketAddress
 import de.kuschku.quasseldroid_ng.R
-import de.kuschku.quasseldroid_ng.session.Backend
-import de.kuschku.quasseldroid_ng.session.ConnectionState
-import de.kuschku.quasseldroid_ng.session.Session
-import de.kuschku.quasseldroid_ng.session.SocketAddress
-import de.kuschku.quasseldroid_ng.util.helpers.Logger
-import de.kuschku.quasseldroid_ng.util.helpers.stickyMapNotNull
-import de.kuschku.quasseldroid_ng.util.helpers.stickySwitchMapNotNull
+import de.kuschku.quasseldroid_ng.util.helper.stickyMapNotNull
+import org.threeten.bp.Instant
 import org.threeten.bp.ZoneOffset
-import org.threeten.bp.ZonedDateTime
 import org.threeten.bp.format.DateTimeFormatter
+import java.util.logging.Handler
+import java.util.logging.LogManager
+import java.util.logging.LogRecord
 
 class MainActivity : ServiceBoundActivity() {
   @BindView(R.id.host)
@@ -49,28 +47,39 @@ class MainActivity : ServiceBoundActivity() {
   @BindView(R.id.errorList)
   lateinit var errorList: TextView
 
+  /*
   private val status: LiveData<ConnectionState>
-    = stickySwitchMapNotNull(backend, Backend::status, ConnectionState.DISCONNECTED)
+    = stickySwitchMapNotNull(backend, Backend::status,
+                                                                    ConnectionState.DISCONNECTED)
+                                                                    */
   private val session: LiveData<Session?>
     = stickyMapNotNull(backend, Backend::session, null)
 
   private var snackbar: Snackbar? = null
 
-  private val handler = { tag: String, message: String?, throwable: Throwable? ->
+  private val dateTimeFormatter: DateTimeFormatter = DateTimeFormatter.ISO_TIME
+  private val handler = object : Handler() {
+    override fun publish(p0: LogRecord?) {
+      if (p0 != null) {
         runOnUiThread {
-      errorList.append(DateTimeFormatter.ISO_TIME.format(ZonedDateTime.now(ZoneOffset.UTC)))
+          errorList.append(
+            dateTimeFormatter.format(Instant.ofEpochMilli(p0.millis).atZone(ZoneOffset.UTC)))
           errorList.append(" ")
-      errorList.append(tag)
+          errorList.append(p0.loggerName)
           errorList.append(": ")
-      errorList.append(message)
-      errorList.append("\n")
-      if (throwable != null) {
-        errorList.append(Log.getStackTraceString(throwable))
+          errorList.append(p0.message)
           errorList.append("\n")
         }
       }
     }
 
+    override fun flush() {
+    }
+
+    override fun close() {
+    }
+  }
+
   override fun onCreate(savedInstanceState: Bundle?) {
     setTheme(R.style.AppTheme)
     super.onCreate(savedInstanceState)
@@ -93,6 +102,7 @@ class MainActivity : ServiceBoundActivity() {
       errorList.text = ""
     }
 
+    /*
     status.observe(this, Observer {
       val disconnected = it == ConnectionState.DISCONNECTED
       disconnect.isEnabled = !disconnected
@@ -102,6 +112,7 @@ class MainActivity : ServiceBoundActivity() {
       snackbar = Snackbar.make(errorList, it!!.name, Snackbar.LENGTH_SHORT)
       snackbar?.show()
     })
+    */
   }
 
   override fun onCreateOptionsMenu(menu: Menu?): Boolean {
@@ -115,11 +126,11 @@ class MainActivity : ServiceBoundActivity() {
 
   override fun onStart() {
     super.onStart()
-    Logger.handler = handler
+    LogManager.getLogManager().getLogger("").addHandler(handler)
   }
 
   override fun onStop() {
-    Logger.handler = null
+    LogManager.getLogManager().getLogger("").removeHandler(handler)
     super.onStop()
   }
 }

app/src/main/java/de/kuschku/quasseldroid_ng/ui/ServiceBoundActivity.kt

@@ -7,7 +7,7 @@ import android.content.ServiceConnection
 import android.os.IBinder
 import android.support.v7.app.AppCompatActivity
 import de.kuschku.quasseldroid_ng.service.QuasselService
-import de.kuschku.quasseldroid_ng.session.Backend
+import de.kuschku.libquassel.session.Backend
 
 abstract class ServiceBoundActivity : AppCompatActivity() {
   protected val backend = MutableLiveData<Backend?>()

app/src/main/java/de/kuschku/quasseldroid_ng/util/AndroidCompatibilityUtils.kt

+package de.kuschku.quasseldroid_ng.util
+
+import android.os.Build
+import de.kuschku.libquassel.util.CompatibilityUtils
+import java.util.*
+
+object AndroidCompatibilityUtils {
+  fun init() {
+    /**
+     * This is used to check if the current device supports Sockets with the KeepAlive flag.
+     * As that feature is only missing on Chromium devices, we just check for that
+     *
+     * @return Does the current device support KeepAlive sockets?
+     */
+    CompatibilityUtils.supportsKeepAlive = !isChromeBook()
+
+    /**
+     * This is used to check if the device supports SyncFlush
+     * As that feature was only added in KitKat, we just check for the device version.
+     */
+    CompatibilityUtils.supportsCompression = Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
+  }
+
+  private fun isChromeBook(): Boolean {
+    return Build.MANUFACTURER.toLowerCase(Locale.ENGLISH).contains("chromium") ||
+      Build.MANUFACTURER.toLowerCase(Locale.ENGLISH).contains("chrome") ||
+      Build.BRAND.toLowerCase(Locale.ENGLISH).contains("chromium") ||
+      Build.BRAND.toLowerCase(Locale.ENGLISH).contains("chrome")
+  }
+}

app/src/main/java/de/kuschku/quasseldroid_ng/util/AndroidHandlerService.kt

+package de.kuschku.quasseldroid_ng.util
+
+import android.os.Handler
+import android.os.HandlerThread
+import android.os.Process
+import de.kuschku.libquassel.util.HandlerService
+
+class AndroidHandlerService : HandlerService {
+  override fun parse(f: () -> Unit) {
+    parseHandler.post(f)
+  }
+
+  override fun write(f: () -> Unit) {
+    writeHandler.post(f)
+  }
+
+  override fun handle(f: () -> Unit) {
+    backendHandler.post(f)
+  }
+
+  private val parseThread = HandlerThread("parse", Process.THREAD_PRIORITY_BACKGROUND)
+  private val writeThread = HandlerThread("write", Process.THREAD_PRIORITY_BACKGROUND)
+  private val backendThread = HandlerThread("backend", Process.THREAD_PRIORITY_BACKGROUND)
+
+  private val parseHandler: Handler
+  private val writeHandler: Handler
+  private val backendHandler: Handler
+
+  private val internalExceptionHandler = Thread.UncaughtExceptionHandler { thread: Thread, throwable: Throwable ->
+    exceptionHandler?.uncaughtException(thread, throwable)
+  }
+
+  init {
+    parseThread.uncaughtExceptionHandler = internalExceptionHandler
+    writeThread.uncaughtExceptionHandler = internalExceptionHandler
+    backendThread.uncaughtExceptionHandler = internalExceptionHandler
+
+    parseThread.start()
+    writeThread.start()
+    backendThread.start()
+
+    parseHandler = Handler(parseThread.looper)
+    writeHandler = Handler(writeThread.looper)
+    backendHandler = Handler(backendThread.looper)
+  }
+
+  override var exceptionHandler: Thread.UncaughtExceptionHandler? = null
+
+  override fun quit() {
+    parseThread.quit()
+    writeThread.quit()
+    backendThread.quit()
+  }
+}

app/src/main/java/de/kuschku/quasseldroid_ng/util/AndroidLoggingHandler.kt

+package de.kuschku.quasseldroid_ng.util
+
+import android.util.Log
+import java.util.logging.Handler
+import java.util.logging.Level
+import java.util.logging.LogManager
+import java.util.logging.LogRecord
+
+/**
+ * Make JUL work on Android.
+ */
+class AndroidLoggingHandler : Handler() {
+  override fun close() {}
+  override fun flush() {}
+  override fun publish(record: LogRecord) {
+    if (!super.isLoggable(record))
+      return
+
+    val name = record.loggerName
+    val maxLength = 30
+    val tag = if (name.length > maxLength) name.substring(name.length - maxLength) else name
+
+    try {
+      val level = getAndroidLevel(record.level)
+      Log.println(level, tag, record.message)
+      if (record.thrown != null) {
+        Log.println(level, tag, Log.getStackTraceString(record.thrown))
+      }
+    } catch (e: RuntimeException) {
+      Log.e("AndroidLoggingHandler", "Error logging message.", e)
+    }
+
+  }
+
+  companion object {
+    fun reset(rootHandler: Handler) {
+      val rootLogger = LogManager.getLogManager().getLogger("")
+      val handlers = rootLogger.handlers
+      for (handler in handlers) {
+        rootLogger.removeHandler(handler)
+      }
+      rootLogger.addHandler(rootHandler)
+    }
+
+    fun init() {
+      reset(AndroidLoggingHandler())
+    }
+
+    private fun getAndroidLevel(level: Level): Int {
+      val value = level.intValue()
+      return when {
+        value >= 1000 -> Log.ERROR
+        value >= 900  -> Log.WARN
+        value >= 800  -> Log.INFO
+        else          -> Log.DEBUG
+      }
+    }
+  }
+}

app/src/main/java/de/kuschku/quasseldroid_ng/util/CompatibilityUtils.kt → app/src/main/java/de/kuschku/quasseldroid_ng/util/helper/ActivityHelper.kt

-package de.kuschku.quasseldroid_ng.util
+package de.kuschku.quasseldroid_ng.util.helper
 
 import android.annotation.TargetApi
 import android.app.Activity
 import android.app.ActivityManager
-import android.content.Context
-import android.content.res.Resources
 import android.graphics.Bitmap
 import android.graphics.BitmapFactory
 import android.os.Build
-import android.support.annotation.ColorInt
 import android.support.annotation.ColorRes
 import android.support.annotation.DrawableRes
 import android.support.annotation.StringRes
-import java.io.OutputStream
-import java.util.*
-import java.util.zip.Deflater
-import java.util.zip.DeflaterOutputStream
-
-object CompatibilityUtils {
-  /**
-   * This method is used to check if the current device supports Sockets with the KeepAlive flag.
-   *
-   *
-   * As that feature is only missing on Chromium devices, we just check for that
-   *
-   * @return Does the current device support KeepAlive sockets?
-   */
-  fun deviceSupportsKeepAlive(): Boolean {
-    return !isChromeBook()
-  }
-
-  fun isChromeBook(): Boolean {
-    return Build.MANUFACTURER.toLowerCase(Locale.ENGLISH).contains("chromium") ||
-      Build.MANUFACTURER.toLowerCase(Locale.ENGLISH).contains("chrome") ||
-      Build.BRAND.toLowerCase(Locale.ENGLISH).contains("chromium") ||
-      Build.BRAND.toLowerCase(Locale.ENGLISH).contains("chrome")
-  }
-
-  /**
-   * This method is used to check if the device supports SyncFlush
-   * As that feature was only added in KitKat, we just check for the device version.
-   *
-   * @return Does the current device support SyncFlush natively?
-   */
-  fun deviceSupportsCompression(): Boolean {
-    return Build.VERSION.SDK_INT >= Build.VERSION_CODES.KITKAT
-  }
-
-  /**
-   * Creates a SyncFlush output stream, even if the current device does not support doing so
-   * natively.
-   *
-   * @param rawOut the raw output stream to be wrapped
-   * @return The wrapping output stream
-   */
-  fun createDeflaterOutputStream(rawOut: OutputStream?): DeflaterOutputStream {
-    return if (deviceSupportsCompression())
-      DeflaterOutputStream(rawOut, true)
-    else
-      DeflaterOutputStream(rawOut, createSyncFlushDeflater())
-  }
-
-  /**
-   * Creates a SyncFlush Deflater for use on pre-KitKat Android
-   *
-   * @return The modified Deflater, or null if the creation failed
-   */
-  private fun createSyncFlushDeflater(): Deflater? {
-    val def = Deflater()
-    try {
-      val f = def.javaClass.getDeclaredField("flushParm")
-      f.isAccessible = true
-      f.setInt(def, 2) // Z_SYNC_FLUSH
-    } catch (e: Exception) {
-      return null
-    }
-
-    return def
-  }
-}
-
-fun Context.getStatusBarHeight(): Int {
-  var result = 0
-  val resourceId = resources.getIdentifier("status_bar_height", "dimen", "android")
-  if (resourceId > 0) {
-    result = resources.getDimensionPixelSize(resourceId)
-  }
-  return result
-}
-
-/**
- * Because Android’s String::split is broken
- *
- * @return A list with all substrings of length 1, in order
- */
-fun String.split(): Array<String> {
-  val chars = arrayOfNulls<String>(length)
-  val charArray = toCharArray()
-  return chars.indices.map { String(charArray, it, 1) }.toTypedArray()
-}
 
 /**
  * Modifies the display of an {@see Activity} in the Android Recents menu if the current version
@@ -112,21 +22,10 @@ fun String.split(): Array<String> {
 fun Activity.updateRecentsHeaderIfExisting(@StringRes label: Int, @DrawableRes icon: Int, @ColorRes colorPrimary: Int) {
   val labelRaw = resources.getString(label)
   val iconRaw = BitmapFactory.decodeResource(resources, icon)
-  val colorPrimaryRaw = getColor(colorPrimary, theme, resources)
+  val colorPrimaryRaw = resources.getColorBackport(colorPrimary, theme)
   updateRecentsHeaderIfExisting(labelRaw, iconRaw, colorPrimaryRaw)
 }
 
-@ColorInt
-private fun getColor(@ColorRes color: Int, theme: Resources.Theme, resources: Resources): Int {
-  return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
-    resources.getColor(color, theme)
-  } else {
-    // We have to use this method on older systems that don’t yet support the new method
-    // which is used above
-    resources.getColor(color)
-  }
-}
-
 /**
  * Modifies the display of an {@see Activity} in the Android Recents menu if the current version
  * of Android supports doing so.

app/src/main/java/de/kuschku/quasseldroid_ng/util/helpers/ContextHelper.kt → app/src/main/java/de/kuschku/quasseldroid_ng/util/helper/ContextHelper.kt

-package de.kuschku.quasseldroid_ng.util.helpers
+package de.kuschku.quasseldroid_ng.util.helper
 
 import android.content.Context
 import android.os.Build
 
+fun Context.getStatusBarHeight(): Int {
+  var result = 0
+  val resourceId = resources.getIdentifier("status_bar_height", "dimen", "android")
+  if (resourceId > 0) {
+    result = resources.getDimensionPixelSize(resourceId)
+  }
+  return result
+}
+
 inline fun <reified T> Context.systemService(): T = if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
   getSystemService(T::class.java)
 } else {

app/src/main/java/de/kuschku/quasseldroid_ng/util/helper/ResourcesHelper.kt

+package de.kuschku.quasseldroid_ng.util.helper
+
+import android.content.res.Resources
+import android.os.Build
+import android.support.annotation.ColorInt
+import android.support.annotation.ColorRes
+
+@ColorInt
+fun Resources.getColorBackport(@ColorRes color: Int, theme: Resources.Theme): Int {
+  return if (Build.VERSION.SDK_INT >= Build.VERSION_CODES.M) {
+    getColor(color, theme)
+  } else {
+    // We have to use this method on older systems that don’t yet support the new method
+    // which is used above
+    getColor(color)
+  }
+}

app/src/main/java/de/kuschku/quasseldroid_ng/util/helpers/TransformationsHelper.kt → app/src/main/java/de/kuschku/quasseldroid_ng/util/helper/TransformationsHelper.kt

-package de.kuschku.quasseldroid_ng.util.helpers
+package de.kuschku.quasseldroid_ng.util.helper
 
 import android.arch.lifecycle.LifecycleOwner
 import android.arch.lifecycle.LiveData

app/src/main/java/de/kuschku/quasseldroid_ng/util/helpers/LogHelper.kt

-package de.kuschku.quasseldroid_ng.util.helpers
-
-import android.util.Log
-import de.kuschku.quasseldroid_ng.BuildConfig
-
-class Logger {
-  companion object {
-    var handler: ((String, String?, Throwable?) -> Unit)? = null
-  }
-}
-
-inline fun Logger.Companion.loggable(tag: String, level: Int, f: Logger.Companion.() -> Unit) {
-  if (BuildConfig.DEBUG || Log.isLoggable(tag, level) || true) {
-    Logger.Companion.f()
-  }
-}
-
-/* VERBOSE */
-
-inline fun Logger.Companion.verbose(tag: String, msg: String)
-  = loggable(tag, Log.VERBOSE) {
-  Log.v(tag, msg)
-  handler?.invoke(tag, msg, null)
-}
-
-inline fun Logger.Companion.verbose(tag: String, msg: () -> String)
-  = loggable(tag, Log.VERBOSE) {
-  val msg1 = msg()
-  Log.v(tag, msg1)
-  handler?.invoke(tag, msg1, null)
-}
-
-inline fun Logger.Companion.verbose(tag: String, msg: String, tr: Throwable)
-  = loggable(tag, Log.VERBOSE) {
-  Log.v(tag, msg, tr)
-  handler?.invoke(tag, msg, tr)
-}
-
-inline fun Logger.Companion.verbose(tag: String, msg: () -> String, tr: Throwable)
-  = loggable(tag, Log.VERBOSE) {
-  val msg1 = msg()
-  Log.v(tag, msg1, tr)
-  handler?.invoke(tag, msg1, tr)
-}
-
-inline fun Logger.Companion.verbose(tag: String, msg: String, tr: () -> Throwable)
-  = loggable(tag, Log.VERBOSE) {
-  val tr1 = tr()
-  Log.v(tag, msg, tr1)
-  handler?.invoke(tag, msg, tr1)
-}
-
-inline fun Logger.Companion.verbose(tag: String, msg: () -> String, tr: () -> Throwable)
-  = loggable(tag, Log.VERBOSE) {
-  val tr1 = tr()
-  val msg1 = msg()
-  Log.v(tag, msg1, tr1)
-  handler?.invoke(tag, msg1, tr1)
-}
-
-
-/* DEBUG */
-
-inline fun Logger.Companion.debug(tag: String, msg: String)
-  = loggable(tag, Log.DEBUG) {
-  Log.d(tag, msg)
-  handler?.invoke(tag, msg, null)
-}
-
-inline fun Logger.Companion.debug(tag: String, msg: () -> String)
-  = loggable(tag, Log.DEBUG) {
-  val msg1 = msg()
-  Log.d(tag, msg1)
-  handler?.invoke(tag, msg1, null)
-}
-
-inline fun Logger.Companion.debug(tag: String, msg: String, tr: Throwable)
-  = loggable(tag, Log.DEBUG) {
-  Log.d(tag, msg, tr)
-  handler?.invoke(tag, msg, tr)
-}
-
-inline fun Logger.Companion.debug(tag: String, msg: () -> String, tr: Throwable)
-  = loggable(tag, Log.DEBUG) {
-  val msg1 = msg()
-  Log.d(tag, msg1, tr)
-  handler?.invoke(tag, msg1, tr)
-}
-
-inline fun Logger.Companion.debug(tag: String, msg: String, tr: () -> Throwable)
-  = loggable(tag, Log.DEBUG) {
-  val tr1 = tr()
-  Log.d(tag, msg, tr1)
-  handler?.invoke(tag, msg, tr1)
-}
-
-inline fun Logger.Companion.debug(tag: String, msg: () -> String, tr: () -> Throwable)
-  = loggable(tag, Log.DEBUG) {
-  val tr1 = tr()
-  val msg1 = msg()
-  Log.d(tag, msg1, tr1)
-  handler?.invoke(tag, msg1, tr1)
-}
-
-
-/* INFO */
-
-inline fun Logger.Companion.info(tag: String, msg: String)
-  = loggable(tag, Log.INFO) {
-  Log.i(tag, msg)
-  handler?.invoke(tag, msg, null)
-}
-
-inline fun Logger.Companion.info(tag: String, msg: () -> String)
-  = loggable(tag, Log.INFO) {
-  val msg1 = msg()
-  Log.i(tag, msg1)
-  handler?.invoke(tag, msg1, null)
-}
-
-inline fun Logger.Companion.info(tag: String, msg: String, tr: Throwable)
-  = loggable(tag, Log.INFO) {
-  Log.i(tag, msg, tr)
-  handler?.invoke(tag, msg, tr)
-}
-
-inline fun Logger.Companion.info(tag: String, msg: () -> String, tr: Throwable)
-  = loggable(tag, Log.INFO) {
-  val msg1 = msg()
-  Log.i(tag, msg1, tr)
-  handler?.invoke(tag, msg1, tr)
-}
-
-inline fun Logger.Companion.info(tag: String, msg: String, tr: () -> Throwable)
-  = loggable(tag, Log.INFO) {
-  val tr1 = tr()
-  Log.i(tag, msg, tr1)
-  handler?.invoke(tag, msg, tr1)
-}
-
-inline fun Logger.Companion.info(tag: String, msg: () -> String, tr: () -> Throwable)
-  = loggable(tag, Log.INFO) {
-  val tr1 = tr()
-  val msg1 = msg()
-  Log.i(tag, msg1, tr1)
-  handler?.invoke(tag, msg1, tr1)
-}
-
-/* WARN */
-
-inline fun Logger.Companion.warn(tag: String, msg: String)
-  = loggable(tag, Log.WARN) {
-  Log.w(tag, msg)
-  handler?.invoke(tag, msg, null)
-}
-
-inline fun Logger.Companion.warn(tag: String, msg: () -> String)
-  = loggable(tag, Log.WARN) {
-  val msg1 = msg()
-  Log.w(tag, msg1)
-  handler?.invoke(tag, msg1, null)
-}
-
-inline fun Logger.Companion.warn(tag: String, msg: String, tr: Throwable)
-  = loggable(tag, Log.WARN) {
-  Log.w(tag, msg, tr)
-  handler?.invoke(tag, msg, tr)
-}
-
-inline fun Logger.Companion.warn(tag: String, msg: () -> String, tr: Throwable)
-  = loggable(tag, Log.WARN) {
-  val msg1 = msg()
-  Log.w(tag, msg1, tr)
-  handler?.invoke(tag, msg1, tr)
-}
-
-inline fun Logger.Companion.warn(tag: String, msg: String, tr: () -> Throwable)
-  = loggable(tag, Log.WARN) {
-  val tr1 = tr()
-  Log.w(tag, msg, tr1)
-  handler?.invoke(tag, msg, tr1)
-}
-
-inline fun Logger.Companion.warn(tag: String, msg: () -> String, tr: () -> Throwable)
-  = loggable(tag, Log.WARN) {
-  val tr1 = tr()
-  val msg1 = msg()
-  Log.w(tag, msg1, tr1)
-  handler?.invoke(tag, msg1, tr1)
-}
-
-/* ERROR */
-
-inline fun Logger.Companion.error(tag: String, msg: String)
-  = loggable(tag, Log.ERROR) {
-  Log.e(tag, msg)
-  handler?.invoke(tag, msg, null)
-}
-
-inline fun Logger.Companion.error(tag: String, msg: () -> String)
-  = loggable(tag, Log.ERROR) {
-  val msg1 = msg()
-  Log.e(tag, msg1)
-  handler?.invoke(tag, msg1, null)
-}
-
-inline fun Logger.Companion.error(tag: String, msg: String, tr: Throwable)
-  = loggable(tag, Log.ERROR) {
-  Log.e(tag, msg, tr)
-  handler?.invoke(tag, msg, tr)
-}
-
-inline fun Logger.Companion.error(tag: String, msg: () -> String, tr: Throwable)
-  = loggable(tag, Log.ERROR) {
-  val msg1 = msg()
-  Log.e(tag, msg1, tr)
-  handler?.invoke(tag, msg1, tr)
-}
-
-inline fun Logger.Companion.error(tag: String, msg: String, tr: () -> Throwable)
-  = loggable(tag, Log.ERROR) {
-  val tr1 = tr()
-  Log.e(tag, msg, tr1)
-  handler?.invoke(tag, msg, tr1)
-}
-
-inline fun Logger.Companion.error(tag: String, msg: () -> String, tr: () -> Throwable)
-  = loggable(tag, Log.ERROR) {
-  val tr1 = tr()
-  val msg1 = msg()
-  Log.e(tag, msg1, tr1)
-  handler?.invoke(tag, msg1, tr1)
-}

app/src/test/java/de/kuschku/quasseldroid_ng/SerializerUnitTest.kt

 package de.kuschku.quasseldroid_ng
 
-import de.kuschku.quasseldroid_ng.protocol.Quassel_Feature
-import de.kuschku.quasseldroid_ng.protocol.Quassel_Features
-import de.kuschku.quasseldroid_ng.protocol.primitive.serializer.*
-import de.kuschku.quasseldroid_ng.util.nio.ChainedByteBuffer
+import de.kuschku.libquassel.protocol.Quassel_Feature
+import de.kuschku.libquassel.protocol.Quassel_Features
+import de.kuschku.libquassel.protocol.primitive.serializer.*
+import de.kuschku.libquassel.util.nio.ChainedByteBuffer
 import org.junit.Assert.assertArrayEquals
 import org.junit.Assert.assertEquals
 import org.junit.Test

invokergenerator/src/main/java/de/kuschku/libquassel/annotations/InvokerProcessor.java

@@ -121,8 +121,8 @@ public class InvokerProcessor extends AbstractProcessor {
         String invokerName = element.annotation.name() + "Invoker";
 
         ClassName type = ClassName.get(packageName, invokerName);
-        ClassName wrongObjectTypeException = ClassName.get("de.kuschku.quasseldroid_ng", "WrongObjectTypeException");
-        ClassName unknownMethodException = ClassName.get("de.kuschku.quasseldroid_ng", "UnknownMethodException");
+        ClassName wrongObjectTypeException = ClassName.get("de.kuschku.libquassel.quassel.exceptions", "WrongObjectTypeException");
+        ClassName unknownMethodException = ClassName.get("de.kuschku.libquassel.quassel.exceptions", "UnknownMethodException");
         ClassName nonNullAnnotation = ClassName.get("android.support.annotation", "NonNull");
 
         MethodSpec methodSpecConstructor = MethodSpec
@@ -164,7 +164,7 @@ public class InvokerProcessor extends AbstractProcessor {
                         ParameterizedTypeName.get(
                                 ClassName.get(List.class),
                                 ParameterizedTypeName.get(
-                                        ClassName.get("de.kuschku.quasseldroid_ng.protocol", "QVariant"),
+                                        ClassName.get("de.kuschku.libquassel.protocol", "QVariant"),
                                         TypeName.get(Object.class)
                                 )
                         ),

lib/build.gradle.kts

+
+import org.gradle.api.Project
+import org.gradle.api.artifacts.ExternalModuleDependency
+import org.gradle.kotlin.dsl.*
+import org.jetbrains.kotlin.gradle.plugin.KaptExtension
+
+apply {
+  plugin("kotlin")
+  plugin("kotlin-kapt")
+}
+
+val appCompatVersion = "26.1.0"
+dependencies {
+  implementation(kotlin("stdlib"))
+
+  implementation(appCompat("support-annotations"))
+  implementation("org.threeten:threetenbp:1.3.6")
+  implementation("io.reactivex.rxjava2:rxjava:2.1.3")
+
+  implementation(project(":invokerannotations"))
+  kapt(project(":invokergenerator"))
+
+  testImplementation("junit:junit:4.12")
+}
+
+/**
+ * Builds the dependency notation for the named AppCompat [module] at the given [version].
+ *
+ * @param module simple name of the AppCompat module, for example "cardview-v7".
+ * @param version optional desired version, null implies [appCompatVersion].
+ */
+fun appCompat(module: String, version: String? = null)
+  = "com.android.support:$module:${version ?: appCompatVersion}"
+
+fun Project.kapt(f: KaptExtension.() -> Unit)
+  = configure(f)
+
+fun DependencyHandlerScope.archives(dependencyNotation: Any)
+  = "archives"(dependencyNotation)
+
+fun DependencyHandlerScope.archives(dependencyNotation: String,
+                                    dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "archives"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.implementation(dependencyNotation: Any)
+  = "implementation"(dependencyNotation)
+
+fun DependencyHandlerScope.implementation(dependencyNotation: String,
+                                          dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "implementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.debugAnnotationProcessor(dependencyNotation: Any)
+  = "debugAnnotationProcessor"(dependencyNotation)
+
+fun DependencyHandlerScope.debugAnnotationProcessor(dependencyNotation: String,
+                                                    dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "debugAnnotationProcessor"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.debugImplementation(dependencyNotation: Any)
+  = "debugImplementation"(dependencyNotation)
+
+fun DependencyHandlerScope.debugImplementation(dependencyNotation: String,
+                                               dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "debugImplementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.debugProvided(dependencyNotation: Any)
+  = "debugProvided"(dependencyNotation)
+
+fun DependencyHandlerScope.debugProvided(dependencyNotation: String,
+                                         dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "debugProvided"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.default(dependencyNotation: Any)
+  = "default"(dependencyNotation)
+
+fun DependencyHandlerScope.default(dependencyNotation: String,
+                                   dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "default"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kapt(dependencyNotation: Any)
+  = "kapt"(dependencyNotation)
+
+fun DependencyHandlerScope.kapt(dependencyNotation: String,
+                                dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kapt"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kaptDebug(dependencyNotation: Any)
+  = "kaptDebug"(dependencyNotation)
+
+fun DependencyHandlerScope.kaptDebug(dependencyNotation: String,
+                                     dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kaptDebug"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kaptRelease(dependencyNotation: Any)
+  = "kaptRelease"(dependencyNotation)
+
+fun DependencyHandlerScope.kaptRelease(dependencyNotation: String,
+                                       dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kaptRelease"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kaptTest(dependencyNotation: Any)
+  = "kaptTest"(dependencyNotation)
+
+fun DependencyHandlerScope.kaptTest(dependencyNotation: String,
+                                    dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kaptTest"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kaptTestDebug(dependencyNotation: Any)
+  = "kaptTestDebug"(dependencyNotation)
+
+fun DependencyHandlerScope.kaptTestDebug(dependencyNotation: String,
+                                         dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kaptTestDebug"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.kaptTestRelease(dependencyNotation: Any)
+  = "kaptTestRelease"(dependencyNotation)
+
+fun DependencyHandlerScope.kaptTestRelease(dependencyNotation: String,
+                                           dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "kaptTestRelease"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.provided(dependencyNotation: Any)
+  = "provided"(dependencyNotation)
+
+fun DependencyHandlerScope.provided(dependencyNotation: String,
+                                    dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "provided"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.releaseAnnotationProcessor(dependencyNotation: Any)
+  = "releaseAnnotationProcessor"(dependencyNotation)
+
+fun DependencyHandlerScope.releaseAnnotationProcessor(dependencyNotation: String,
+                                                      dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "releaseAnnotationProcessor"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.releaseImplementation(dependencyNotation: Any)
+  = "releaseImplementation"(dependencyNotation)
+
+fun DependencyHandlerScope.releaseImplementation(dependencyNotation: String,
+                                                 dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "releaseImplementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.releaseProvided(dependencyNotation: Any)
+  = "releaseProvided"(dependencyNotation)
+
+fun DependencyHandlerScope.releaseProvided(dependencyNotation: String,
+                                           dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "releaseProvided"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testAnnotationProcessor(dependencyNotation: Any)
+  = "testAnnotationProcessor"(dependencyNotation)
+
+fun DependencyHandlerScope.testAnnotationProcessor(dependencyNotation: String,
+                                                   dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testAnnotationProcessor"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testImplementation(dependencyNotation: Any)
+  = "testImplementation"(dependencyNotation)
+
+fun DependencyHandlerScope.testImplementation(dependencyNotation: String,
+                                              dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testImplementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testDebugAnnotationProcessor(dependencyNotation: Any)
+  = "testDebugAnnotationProcessor"(dependencyNotation)
+
+fun DependencyHandlerScope.testDebugAnnotationProcessor(dependencyNotation: String,
+                                                        dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testDebugAnnotationProcessor"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testDebugImplementation(dependencyNotation: Any)
+  = "testDebugImplementation"(dependencyNotation)
+
+fun DependencyHandlerScope.testDebugImplementation(dependencyNotation: String,
+                                                   dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testDebugImplementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testDebugProvided(dependencyNotation: Any)
+  = "testDebugProvided"(dependencyNotation)
+
+fun DependencyHandlerScope.testDebugProvided(dependencyNotation: String,
+                                             dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testDebugProvided"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testProvided(dependencyNotation: Any)
+  = "testProvided"(dependencyNotation)
+
+fun DependencyHandlerScope.testProvided(dependencyNotation: String,
+                                        dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testProvided"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testReleaseAnnotationProcessor(dependencyNotation: Any)
+  = "testReleaseAnnotationProcessor"(dependencyNotation)
+
+fun DependencyHandlerScope.testReleaseAnnotationProcessor(dependencyNotation: String,
+                                                          dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testReleaseAnnotationProcessor"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testReleaseImplementation(dependencyNotation: Any)
+  = "testReleaseImplementation"(dependencyNotation)
+
+fun DependencyHandlerScope.testReleaseImplementation(dependencyNotation: String,
+                                                     dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testReleaseImplementation"(dependencyNotation, dependencyConfiguration)
+
+fun DependencyHandlerScope.testReleaseProvided(dependencyNotation: Any)
+  = "testReleaseProvided"(dependencyNotation)
+
+fun DependencyHandlerScope.testReleaseProvided(dependencyNotation: String,
+                                               dependencyConfiguration: ExternalModuleDependency.() -> Unit)
+  = "testReleaseProvided"(dependencyNotation, dependencyConfiguration)

app/src/main/java/de/kuschku/quasseldroid_ng/protocol/ClientData.kt → lib/src/main/java/de/kuschku/libquassel/protocol/ClientData.kt

-package de.kuschku.quasseldroid_ng.protocol
+package de.kuschku.libquassel.protocol
 
 import org.threeten.bp.Instant