Enhancement/ktlint (#179)

* Add spotless dependency

* Apply ktlint

* Add license headers

58 files changed, 1421 insertions, 463 deletions

diff --git a/core/src/androidTest/kotlin/ca/allanwang/kau/kpref/KPrefTest.kt b/core/src/androidTest/kotlin/ca/allanwang/kau/kpref/KPrefTest.kt
index 52f344b..29f5af1 100644
--- a/core/src/androidTest/kotlin/ca/allanwang/kau/kpref/KPrefTest.kt
+++ b/core/src/androidTest/kotlin/ca/allanwang/kau/kpref/KPrefTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kpref
 
 import android.annotation.SuppressLint
@@ -84,11 +99,9 @@ class KPrefTest {
         assertEquals(-1, pref.one, "Kpref did not refetch from shared prefs upon reset")
     }
 
-
     @Test
     fun single() {
         assertTrue(pref.oneShot)
         assertFalse(pref.oneShot)
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/androidTest/kotlin/ca/allanwang/kau/utils/KotterknifeTest.kt b/core/src/androidTest/kotlin/ca/allanwang/kau/utils/KotterknifeTest.kt
index 13a3c77..96ebd3a 100644
--- a/core/src/androidTest/kotlin/ca/allanwang/kau/utils/KotterknifeTest.kt
+++ b/core/src/androidTest/kotlin/ca/allanwang/kau/utils/KotterknifeTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.Context
@@ -197,4 +212,4 @@ class KotterknifeTest {
         view.id = id
         return view
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/androidTest/kotlin/ca/allanwang/kau/xml/FaqTest.kt b/core/src/androidTest/kotlin/ca/allanwang/kau/xml/FaqTest.kt
index 7a6d2e0..2d02dbc 100644
--- a/core/src/androidTest/kotlin/ca/allanwang/kau/xml/FaqTest.kt
+++ b/core/src/androidTest/kotlin/ca/allanwang/kau/xml/FaqTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.xml
 
 import android.content.Context
@@ -25,7 +40,11 @@ class FaqTest {
             assertEquals(2, data.size, "FAQ size is incorrect")
             assertEquals("1. This is a question", data.first().question.toString(), "First question does not match")
             assertEquals("This is an answer", data.first().answer.toString(), "First answer does not match")
-            assertEquals("2. This is another question", data.last().question.toString(), "Second question does not match")
+            assertEquals(
+                "2. This is another question",
+                data.last().question.toString(),
+                "Second question does not match"
+            )
             assertEquals("This is another answer", data.last().answer.toString(), "Second answer does not match")
         }
     }
@@ -40,5 +59,4 @@ class FaqTest {
             assertEquals("This is another answer", data.last().answer.toString(), "Second answer does not match")
         }
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/email/EmailBuilder.kt b/core/src/main/kotlin/ca/allanwang/kau/email/EmailBuilder.kt
index 0184b9a..e6ad97a 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/email/EmailBuilder.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/email/EmailBuilder.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.email
 
 import android.app.Activity
@@ -6,12 +21,15 @@ import android.content.Intent
 import android.content.pm.PackageManager
 import android.net.Uri
 import android.os.Build
-import androidx.annotation.StringRes
 import android.util.DisplayMetrics
+import androidx.annotation.StringRes
 import ca.allanwang.kau.R
 import ca.allanwang.kau.logging.KL
-import ca.allanwang.kau.utils.*
-
+import ca.allanwang.kau.utils.boolean
+import ca.allanwang.kau.utils.installerPackageName
+import ca.allanwang.kau.utils.isAppInstalled
+import ca.allanwang.kau.utils.string
+import ca.allanwang.kau.utils.toast
 
 /**
  * Created by Allan Wang on 2017-06-20.
@@ -28,7 +46,7 @@ class EmailBuilder(val email: String, val subject: String) {
     private var attachment: Uri? = null
 
     fun checkPackage(packageName: String, appName: String) =
-            packages.add(Package(packageName, appName))
+        packages.add(Package(packageName, appName))
 
     fun addItem(key: String, value: String) = pairs.put(key, value)
 
@@ -45,19 +63,19 @@ class EmailBuilder(val email: String, val subject: String) {
 
     fun getIntent(context: Context): Intent {
         val intent = Intent(Intent.ACTION_SEND)
-                .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
-                .putExtra(Intent.EXTRA_EMAIL, arrayOf(email))
-                .putExtra(Intent.EXTRA_SUBJECT, subject)
+            .addFlags(Intent.FLAG_ACTIVITY_NEW_TASK)
+            .putExtra(Intent.EXTRA_EMAIL, arrayOf(email))
+            .putExtra(Intent.EXTRA_SUBJECT, subject)
         val emailBuilder = StringBuilder()
         emailBuilder.append(message).append("\n\n")
         if (deviceDetails) {
             val deviceItems = mutableMapOf(
-                    "OS Version" to "${System.getProperty("os.version")} (${Build.VERSION.INCREMENTAL})",
-                    "OS SDK" to Build.VERSION.SDK_INT,
-                    "Device (Manufacturer)" to "${Build.DEVICE} (${Build.MANUFACTURER})",
-                    "Model (Product)" to "${Build.MODEL} (${Build.PRODUCT})",
-                    "Package Installer" to (context.installerPackageName ?: "None"),
-                    "Tablet" to context.boolean(R.bool.kau_is_tablet)
+                "OS Version" to "${System.getProperty("os.version")} (${Build.VERSION.INCREMENTAL})",
+                "OS SDK" to Build.VERSION.SDK_INT,
+                "Device (Manufacturer)" to "${Build.DEVICE} (${Build.MANUFACTURER})",
+                "Model (Product)" to "${Build.MODEL} (${Build.PRODUCT})",
+                "Package Installer" to (context.installerPackageName ?: "None"),
+                "Tablet" to context.boolean(R.bool.kau_is_tablet)
             )
             if (context is Activity) {
                 val metric = DisplayMetrics()
@@ -75,8 +93,8 @@ class EmailBuilder(val email: String, val subject: String) {
                     appInfo.versionCode.toString()
                 }
                 emailBuilder.append("\nApp: ").append(context.packageName)
-                        .append("\nApp Version Name: ").append(appInfo.versionName)
-                        .append("\nApp Version Code: ").append(versionCode).append("\n")
+                    .append("\nApp Version Name: ").append(appInfo.versionName)
+                    .append("\nApp Version Code: ").append(versionCode).append("\n")
             } catch (e: PackageManager.NameNotFoundException) {
                 KL.e { "EmailBuilder packageInfo not found" }
             }
@@ -111,7 +129,7 @@ class EmailBuilder(val email: String, val subject: String) {
         val intent = getIntent(context)
         intent.extras()
         val packageName = intent.resolveActivity(context.packageManager)?.packageName
-                ?: return context.toast(R.string.kau_error_no_email, log = true)
+            ?: return context.toast(R.string.kau_error_no_email, log = true)
 
         val attachment = this.attachment
         if (attachment != null) {
@@ -123,12 +141,12 @@ class EmailBuilder(val email: String, val subject: String) {
     }
 }
 
-fun Context.sendEmail(@StringRes emailId: Int, @StringRes subjectId: Int, builder: EmailBuilder.() -> Unit = {}) = sendEmail(string(emailId), string(subjectId), builder)
-
+fun Context.sendEmail(@StringRes emailId: Int, @StringRes subjectId: Int, builder: EmailBuilder.() -> Unit = {}) =
+    sendEmail(string(emailId), string(subjectId), builder)
 
 fun Context.sendEmail(email: String, subject: String, builder: EmailBuilder.() -> Unit = {}) {
     EmailBuilder(email, subject).apply {
         builder()
         execute(this@sendEmail)
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/internal/KauBaseActivity.kt b/core/src/main/kotlin/ca/allanwang/kau/internal/KauBaseActivity.kt
index c71761d..85e711b 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/internal/KauBaseActivity.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/internal/KauBaseActivity.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.internal
 
 import androidx.appcompat.app.AppCompatActivity
@@ -18,4 +33,4 @@ abstract class KauBaseActivity : AppCompatActivity() {
         super.onRequestPermissionsResult(requestCode, permissions, grantResults)
         kauOnRequestPermissionsResult(permissions, grantResults)
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Debouncer.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Debouncer.kt
index de5d148..ea13f73 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Debouncer.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Debouncer.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import ca.allanwang.kau.logging.KL
@@ -56,7 +71,6 @@ open class Debouncer(var interval: Long) {
             task = null
         }
     }
-
 }
 
 /*
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/FlyWeight.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/FlyWeight.kt
index 03e98d2..165295a 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/FlyWeight.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/FlyWeight.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 /**
@@ -36,5 +51,4 @@ class FlyWeight<K : Any, V : Any>(private val creator: (key: K) -> V) : Map<K, V
             map.put(key, creator(key))
         return map[key]!!
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyContext.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyContext.kt
index 3d98633..e2a59d7 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyContext.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyContext.kt
@@ -1,11 +1,26 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import android.content.Context
-import androidx.annotation.AnimRes
-import androidx.annotation.InterpolatorRes
 import android.view.animation.Animation
 import android.view.animation.AnimationUtils
 import android.view.animation.Interpolator
+import androidx.annotation.AnimRes
+import androidx.annotation.InterpolatorRes
 
 /**
  * Created by Allan Wang on 2017-05-30.
@@ -47,5 +62,4 @@ class LazyContext<out T>(private val initializer: (context: Context) -> T, lock:
             }
         }
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyResettable.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyResettable.kt
index 979f7a7..ee38d48 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyResettable.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/LazyResettable.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import java.io.Serializable
@@ -80,4 +95,4 @@ class LazyResettableRegistry : ILazyResettableRegistry {
     override fun invalidateAll() = lazyRegistry.forEach { it.invalidate() }
 
     override fun clear() = lazyRegistry.clear()
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Streams.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Streams.kt
index 303153f..bfa73fd 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Streams.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Streams.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 /**
@@ -27,4 +42,4 @@ inline fun <T : Any> Iterator<T>.firstOrNull(predicate: (T) -> Boolean): T? {
         if (predicate(data)) return data
     }
     return null
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Utils.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Utils.kt
index 1ba1de6..1e35ecf 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Utils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Utils.kt
@@ -1,6 +1,21 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 /**
  * Created by Allan Wang on 07/04/18.
  */
-inline fun <reified T : Any> javaClass(): Class<T> = T::class.java
\ No newline at end of file
+inline fun <reified T : Any> javaClass(): Class<T> = T::class.java
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Zip.kt b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Zip.kt
index 17ae5e5..b767b30 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kotlin/Zip.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kotlin/Zip.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import org.jetbrains.anko.doAsync
@@ -48,7 +63,8 @@ class ZipEmptyCallback(val onReceived: () -> Unit) : ZipCallbackBase() {
  * ALl tasks must invoke the task callback for [onFinished] to execute
  */
 inline fun <reified T> Collection<(ZipCallback<T>) -> Unit>.zip(
-        defaultResult: T, crossinline onFinished: (results: Array<T>) -> Unit
+    defaultResult: T,
+    crossinline onFinished: (results: Array<T>) -> Unit
 ) {
     val result = Array(size) { defaultResult }
     val countDown = AtomicInteger(size)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPref.kt b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPref.kt
index 12f9606..7a6330f 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPref.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPref.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kpref
 
 import android.content.Context
@@ -47,5 +62,4 @@ open class KPref {
     operator fun get(key: String): ILazyResettable<*>? = prefMap[key]
 
     open fun deleteKeys(): Array<String> = arrayOf()
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefDelegate.kt b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefDelegate.kt
index b80479e..9813f24 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefDelegate.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefDelegate.kt
@@ -1,31 +1,47 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kpref
 
 import ca.allanwang.kau.kotlin.ILazyResettable
 
-
 fun KPref.kpref(key: String, fallback: Boolean, postSetter: (value: Boolean) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefBooleanTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefBooleanTransaction, postSetter)
 
 fun KPref.kpref(key: String, fallback: Float, postSetter: (value: Float) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefFloatTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefFloatTransaction, postSetter)
 
-@Deprecated("Double is not supported in SharedPreferences; cast to float yourself",
-        ReplaceWith("kpref(key, fallback.toFloat(), postSetter)"),
-        DeprecationLevel.WARNING)
+@Deprecated(
+    "Double is not supported in SharedPreferences; cast to float yourself",
+    ReplaceWith("kpref(key, fallback.toFloat(), postSetter)"),
+    DeprecationLevel.WARNING
+)
 fun KPref.kpref(key: String, fallback: Double, postSetter: (value: Float) -> Unit = {}) =
-        kpref(key, fallback.toFloat(), postSetter)
+    kpref(key, fallback.toFloat(), postSetter)
 
 fun KPref.kpref(key: String, fallback: Int, postSetter: (value: Int) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefIntTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefIntTransaction, postSetter)
 
 fun KPref.kpref(key: String, fallback: Long, postSetter: (value: Long) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefLongTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefLongTransaction, postSetter)
 
 fun KPref.kpref(key: String, fallback: Set<String>, postSetter: (value: Set<String>) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefSetTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefSetTransaction, postSetter)
 
 fun KPref.kpref(key: String, fallback: String, postSetter: (value: String) -> Unit = {}) =
-        KPrefDelegate(key, fallback, this, KPrefStringTransaction, postSetter)
+    KPrefDelegate(key, fallback, this, KPrefStringTransaction, postSetter)
 
 /**
  * Created by Allan Wang on 2017-06-07.
@@ -35,11 +51,11 @@ fun KPref.kpref(key: String, fallback: String, postSetter: (value: String) -> Un
  * Also contains an optional mutable postSetter that will be called every time a new value is given
  */
 class KPrefDelegate<T> internal constructor(
-        private val key: String,
-        private val fallback: T,
-        private val pref: KPref,
-        private val transaction: KPrefTransaction<T>,
-        private var postSetter: (value: T) -> Unit = {}
+    private val key: String,
+    private val fallback: T,
+    private val pref: KPref,
+    private val transaction: KPrefTransaction<T>,
+    private var postSetter: (value: T) -> Unit = {}
 ) : ILazyResettable<T> {
 
     private object UNINITIALIZED
@@ -91,4 +107,4 @@ class KPrefDelegate<T> internal constructor(
     }
 }
 
-class KPrefException(message: String) : IllegalAccessException(message)
\ No newline at end of file
+class KPrefException(message: String) : IllegalAccessException(message)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefSingleDelegate.kt b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefSingleDelegate.kt
index ed30a44..204e07e 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefSingleDelegate.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefSingleDelegate.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kpref
 
 import ca.allanwang.kau.kotlin.ILazyResettable
@@ -12,7 +27,8 @@ fun KPref.kprefSingle(key: String) = KPrefSingleDelegate(key, this)
  * All subsequent retrievals will be [false]
  * This is useful for one time toggles such as showcasing items
  */
-class KPrefSingleDelegate internal constructor(private val key: String, private val pref: KPref, lock: Any? = null) : ILazyResettable<Boolean> {
+class KPrefSingleDelegate internal constructor(private val key: String, private val pref: KPref, lock: Any? = null) :
+    ILazyResettable<Boolean> {
 
     @Volatile
     private var _value: Boolean? = null
@@ -52,5 +68,4 @@ class KPrefSingleDelegate internal constructor(private val key: String, private
     override fun isInitialized(): Boolean = _value != null
 
     override fun toString(): String = if (isInitialized()) value.toString() else "Lazy kPref $key not initialized yet."
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefTransaction.kt b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefTransaction.kt
index 773d208..1070e11 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefTransaction.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/kpref/KPrefTransaction.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kpref
 
 import android.content.SharedPreferences
@@ -9,7 +24,7 @@ internal interface KPrefTransaction<T> {
 
 internal object KPrefBooleanTransaction : KPrefTransaction<Boolean> {
     override fun get(prefs: SharedPreferences, key: String, fallback: Boolean) =
-            prefs.getBoolean(key, fallback)
+        prefs.getBoolean(key, fallback)
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: Boolean) {
         editor.putBoolean(key, data)
@@ -18,7 +33,7 @@ internal object KPrefBooleanTransaction : KPrefTransaction<Boolean> {
 
 internal object KPrefIntTransaction : KPrefTransaction<Int> {
     override fun get(prefs: SharedPreferences, key: String, fallback: Int) =
-            prefs.getInt(key, fallback)
+        prefs.getInt(key, fallback)
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: Int) {
         editor.putInt(key, data)
@@ -27,7 +42,7 @@ internal object KPrefIntTransaction : KPrefTransaction<Int> {
 
 internal object KPrefLongTransaction : KPrefTransaction<Long> {
     override fun get(prefs: SharedPreferences, key: String, fallback: Long) =
-            prefs.getLong(key, fallback)
+        prefs.getLong(key, fallback)
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: Long) {
         editor.putLong(key, data)
@@ -36,7 +51,7 @@ internal object KPrefLongTransaction : KPrefTransaction<Long> {
 
 internal object KPrefFloatTransaction : KPrefTransaction<Float> {
     override fun get(prefs: SharedPreferences, key: String, fallback: Float) =
-            prefs.getFloat(key, fallback)
+        prefs.getFloat(key, fallback)
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: Float) {
         editor.putFloat(key, data)
@@ -45,7 +60,7 @@ internal object KPrefFloatTransaction : KPrefTransaction<Float> {
 
 internal object KPrefStringTransaction : KPrefTransaction<String> {
     override fun get(prefs: SharedPreferences, key: String, fallback: String) =
-            prefs.getString(key, fallback)
+        prefs.getString(key, fallback)
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: String) {
         editor.putString(key, data)
@@ -54,11 +69,9 @@ internal object KPrefStringTransaction : KPrefTransaction<String> {
 
 internal object KPrefSetTransaction : KPrefTransaction<Set<String>> {
     override fun get(prefs: SharedPreferences, key: String, fallback: Set<String>) =
-            prefs.getStringSet(key, fallback)!!
+        prefs.getStringSet(key, fallback)!!
 
     override fun set(editor: SharedPreferences.Editor, key: String, data: Set<String>) {
         editor.putStringSet(key, data)
     }
 }
-
-
diff --git a/core/src/main/kotlin/ca/allanwang/kau/logging/KL.kt b/core/src/main/kotlin/ca/allanwang/kau/logging/KL.kt
index 9f48ab5..f92edb3 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/logging/KL.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/logging/KL.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.logging
 
 import ca.allanwang.kau.BuildConfig
@@ -7,4 +22,4 @@ import ca.allanwang.kau.BuildConfig
  *
  * Internal KAU logger
  */
-object KL : KauLogger("KAU", { BuildConfig.DEBUG })
\ No newline at end of file
+object KL : KauLogger("KAU", { BuildConfig.DEBUG })
diff --git a/core/src/main/kotlin/ca/allanwang/kau/logging/KauLogger.kt b/core/src/main/kotlin/ca/allanwang/kau/logging/KauLogger.kt
index 799d32f..d01859f 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/logging/KauLogger.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/logging/KauLogger.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 @file:Suppress("NOTHING_TO_INLINE")
 
 package ca.allanwang.kau.logging
@@ -25,15 +40,15 @@ import android.util.Log
  * for production builds
  */
 open class KauLogger(
-        /**
-         * Tag to be used for each log
-         */
-        val tag: String,
-        /**
-         * Toggle to dictate whether a message should be logged
-         */
-        var shouldLog: (priority: Int) -> Boolean = { true }) {
-
+    /**
+     * Tag to be used for each log
+     */
+    val tag: String,
+    /**
+     * Toggle to dictate whether a message should be logged
+     */
+    var shouldLog: (priority: Int) -> Boolean = { true }
+) {
 
     inline fun v(message: () -> Any?) = log(Log.VERBOSE, message)
 
@@ -96,11 +111,11 @@ class KauLoggerExtension(val tag: String, val logger: KauLogger) {
     }
 
     inline fun log(priority: Int, message: () -> Any?, t: Throwable? = null) =
-            logger.log(priority, {
-                val msg = message()?.toString()
-                if (msg == null) null
-                else "$tag: $msg"
-            }, t)
+        logger.log(priority, {
+            val msg = message()?.toString()
+            if (msg == null) null
+            else "$tag: $msg"
+        }, t)
 
     inline fun checkThread(id: Int) {
         d {
diff --git a/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionManager.kt b/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionManager.kt
index 922dc09..57a6f42 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionManager.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionManager.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.permissions
 
 import android.app.Activity
@@ -12,7 +27,6 @@ import ca.allanwang.kau.utils.hasPermission
 import ca.allanwang.kau.utils.toast
 import java.lang.ref.WeakReference
 
-
 /**
  * Created by Allan Wang on 2017-07-03.
  *
@@ -30,13 +44,17 @@ internal object PermissionManager {
     private val manifestPermission = lazyContext<Array<String>> {
         try {
             it.packageManager.getPackageInfo(it.packageName, PackageManager.GET_PERMISSIONS)?.requestedPermissions
-                    ?: emptyArray()
+                ?: emptyArray()
         } catch (e: Exception) {
             emptyArray()
         }
     }
 
-    operator fun invoke(context: Context, permissions: Array<out String>, callback: (granted: Boolean, deniedPerm: String?) -> Unit) {
+    operator fun invoke(
+        context: Context,
+        permissions: Array<out String>,
+        callback: (granted: Boolean, deniedPerm: String?) -> Unit
+    ) {
         KL.d { "Permission manager for: ${permissions.contentToString()}" }
         if (!buildIsMarshmallowAndUp) return callback(true, null)
         val missingPermissions = permissions.filter { !context.hasPermission(it) }
@@ -58,7 +76,7 @@ internal object PermissionManager {
             }
         }
         val activity = (context as? Activity)
-                ?: throw KauException("Context is not an instance of an activity; cannot request permissions")
+            ?: throw KauException("Context is not an instance of an activity; cannot request permissions")
         KL.i { "Requesting permissions ${permissions.contentToString()}" }
         ActivityCompat.requestPermissions(activity, permissions, 1)
     }
@@ -89,5 +107,4 @@ internal object PermissionManager {
         }
         KL.i { "Post on permission result: pending ${pendingResults.size}" }
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionResult.kt b/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionResult.kt
index ba3e6dd..8888c91 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionResult.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/permissions/PermissionResult.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.permissions
 
 import android.content.pm.PackageManager
@@ -25,4 +40,4 @@ class PermissionResult(permissions: Array<out String>, val callback: (granted: B
         callback(true, null)
         return true
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/permissions/Permissions.kt b/core/src/main/kotlin/ca/allanwang/kau/permissions/Permissions.kt
index 83cd2ed..3c90b05 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/permissions/Permissions.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/permissions/Permissions.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.permissions
 
 import android.Manifest
@@ -6,7 +21,6 @@ import android.content.Context
 import android.os.Build
 import androidx.annotation.RequiresApi
 
-
 /**
  * Created by Allan Wang on 2017-07-02.
  *
@@ -22,7 +36,8 @@ import androidx.annotation.RequiresApi
 /**
  * Hook that should be added inside all [Activity.onRequestPermissionsResult] so that the Permission manager can handle the responses
  */
-fun Activity.kauOnRequestPermissionsResult(permissions: Array<out String>, grantResults: IntArray) = PermissionManager.onRequestPermissionsResult(this, permissions, grantResults)
+fun Activity.kauOnRequestPermissionsResult(permissions: Array<out String>, grantResults: IntArray) =
+    PermissionManager.onRequestPermissionsResult(this, permissions, grantResults)
 
 /**
  * Request a permission with a callback
@@ -31,7 +46,10 @@ fun Activity.kauOnRequestPermissionsResult(permissions: Array<out String>, grant
  * The [callback] returns [granted], which is true if all permissions are granted
  * [deniedPerm] is the first denied permission, if granted is false
  */
-fun Context.kauRequestPermissions(vararg permissions: String, callback: (granted: Boolean, deniedPerm: String?) -> Unit) = PermissionManager(this, permissions, callback)
+fun Context.kauRequestPermissions(
+    vararg permissions: String,
+    callback: (granted: Boolean, deniedPerm: String?) -> Unit
+) = PermissionManager(this, permissions, callback)
 
 /**
  * See http://developer.android.com/guide/topics/security/permissions.html#normal-dangerous for a
@@ -72,4 +90,4 @@ const val PERMISSION_RECEIVE_MMS = Manifest.permission.RECEIVE_MMS
 const val PERMISSION_READ_EXTERNAL_STORAGE = Manifest.permission.READ_EXTERNAL_STORAGE
 const val PERMISSION_WRITE_EXTERNAL_STORAGE = Manifest.permission.WRITE_EXTERNAL_STORAGE
 
-const val PERMISSION_SYSTEM_ALERT_WINDOW = Manifest.permission.SYSTEM_ALERT_WINDOW
\ No newline at end of file
+const val PERMISSION_SYSTEM_ALERT_WINDOW = Manifest.permission.SYSTEM_ALERT_WINDOW
diff --git a/core/src/main/kotlin/ca/allanwang/kau/swipe/RelativeSlider.kt b/core/src/main/kotlin/ca/allanwang/kau/swipe/RelativeSlider.kt
index f14f5cf..0b1dd88 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/swipe/RelativeSlider.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/swipe/RelativeSlider.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.swipe
 
 /**
@@ -30,10 +45,14 @@ internal class RelativeSlider(var curPage: SwipeBackPage) : SwipeListener {
             return
         }
         when (edgeFlag) {
-            SWIPE_EDGE_LEFT -> page.swipeBackLayout.x = Math.min(-offset * Math.max(1 - percent, 0f) + DEFAULT_OFFSET, 0f)
-            SWIPE_EDGE_RIGHT -> page.swipeBackLayout.x = Math.min(offset * Math.max(1 - percent, 0f) - DEFAULT_OFFSET, 0f)
-            SWIPE_EDGE_TOP -> page.swipeBackLayout.y = Math.min(-offset * Math.max(1 - percent, 0f) + DEFAULT_OFFSET, 0f)
-            SWIPE_EDGE_BOTTOM -> page.swipeBackLayout.y = Math.min(offset * Math.max(1 - percent, 0f) - DEFAULT_OFFSET, 0f)
+            SWIPE_EDGE_LEFT -> page.swipeBackLayout.x =
+                Math.min(-offset * Math.max(1 - percent, 0f) + DEFAULT_OFFSET, 0f)
+            SWIPE_EDGE_RIGHT -> page.swipeBackLayout.x =
+                Math.min(offset * Math.max(1 - percent, 0f) - DEFAULT_OFFSET, 0f)
+            SWIPE_EDGE_TOP -> page.swipeBackLayout.y =
+                Math.min(-offset * Math.max(1 - percent, 0f) + DEFAULT_OFFSET, 0f)
+            SWIPE_EDGE_BOTTOM -> page.swipeBackLayout.y =
+                Math.min(offset * Math.max(1 - percent, 0f) - DEFAULT_OFFSET, 0f)
         }
     }
 
diff --git a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackHelper.kt b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackHelper.kt
index 018d7c7..1c6de12 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackHelper.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackHelper.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.swipe
 
 import android.app.Activity
@@ -5,7 +20,7 @@ import ca.allanwang.kau.R
 import ca.allanwang.kau.kotlin.kauRemoveIf
 import ca.allanwang.kau.logging.KL
 import ca.allanwang.kau.swipe.SwipeBackHelper.onDestroy
-import java.util.*
+import java.util.Stack
 
 /**
  * Singleton to hold our swipe stack
@@ -16,7 +31,8 @@ internal object SwipeBackHelper {
 
     private val pageStack = Stack<SwipeBackPage>()
 
-    private operator fun get(activity: Activity): SwipeBackPage? = pageStack.firstOrNull { it.activityRef.get() === activity }
+    private operator fun get(activity: Activity): SwipeBackPage? =
+        pageStack.firstOrNull { it.activityRef.get() === activity }
 
     fun onCreate(activity: Activity, builder: SwipeBackContract.() -> Unit = {}) {
         val page = this[activity] ?: pageStack.push(SwipeBackPage(activity).apply { builder() })
@@ -93,4 +109,4 @@ const val SWIPE_EDGE_RIGHT = ViewDragHelper.EDGE_RIGHT
 
 const val SWIPE_EDGE_TOP = ViewDragHelper.EDGE_TOP
 
-const val SWIPE_EDGE_BOTTOM = ViewDragHelper.EDGE_BOTTOM
\ No newline at end of file
+const val SWIPE_EDGE_BOTTOM = ViewDragHelper.EDGE_BOTTOM
diff --git a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackLayout.kt b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackLayout.kt
index 4d7142c..1f564ce 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackLayout.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackLayout.kt
@@ -1,15 +1,30 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.swipe
 
 import android.annotation.SuppressLint
 import android.app.Activity
 import android.content.Context
 import android.graphics.Canvas
-import androidx.core.view.ViewCompat
 import android.util.AttributeSet
 import android.view.MotionEvent
 import android.view.View
 import android.view.ViewGroup
 import android.widget.FrameLayout
+import androidx.core.view.ViewCompat
 import ca.allanwang.kau.logging.KL
 import ca.allanwang.kau.utils.adjustAlpha
 import ca.allanwang.kau.utils.navigationBarColor
@@ -23,7 +38,10 @@ import java.lang.ref.WeakReference
  * If an edge detection occurs, this layout consumes all the touch events
  * Use the [swipeEnabled] toggle if you need the scroll events on the same axis
  */
-internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs: AttributeSet? = null, defStyle: Int = 0
+internal class SwipeBackLayout @JvmOverloads constructor(
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyle: Int = 0
 ) : FrameLayout(context, attrs, defStyle), SwipeBackContract, SwipeBackContractInternal {
 
     override val swipeBackLayout: SwipeBackLayout
@@ -96,11 +114,9 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
             override fun onEdgeTouch() {}
 
             override fun onScrollToClose(edgeFlag: Int) {}
-
         }
     }
 
-
     private var inLayout: Boolean = false
 
     override var edgeSize: Int
@@ -158,7 +174,8 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
     }
 
     override fun setEdgeSizePercent(swipeEdgePercent: Float) {
-        edgeSize = ((if (horizontal) resources.displayMetrics.widthPixels else resources.displayMetrics.heightPixels) * swipeEdgePercent).toInt()
+        edgeSize =
+            ((if (horizontal) resources.displayMetrics.widthPixels else resources.displayMetrics.heightPixels) * swipeEdgePercent).toInt()
     }
 
     /**
@@ -206,7 +223,7 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
      */
     override fun scrollToFinishActivity() {
         val contentView = contentViewRef.get()
-                ?: return KL.e { "KauSwipe cannot scroll to finish as contentView is null. Is onPostCreate called?" }
+            ?: return KL.e { "KauSwipe cannot scroll to finish as contentView is null. Is onPostCreate called?" }
         val swipeWidth = contentView.width + OVERSCROLL_DISTANCE
         val swipeHeight = contentView.height + OVERSCROLL_DISTANCE
         var top = 0
@@ -243,7 +260,7 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
 
     override fun onLayout(changed: Boolean, left: Int, top: Int, right: Int, bottom: Int) {
         val contentView = contentViewRef.get()
-                ?: return KL.e { "KauSwipe cannot change layout as contentView is null. Is onPostCreate called?" }
+            ?: return KL.e { "KauSwipe cannot change layout as contentView is null. Is onPostCreate called?" }
         inLayout = true
         val xOffset: Int
         val yOffset: Int
@@ -346,11 +363,12 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
         override fun onViewPositionChanged(changedView: View, left: Int, top: Int, dx: Int, dy: Int) {
             super.onViewPositionChanged(changedView, left, top, dx, dy)
             val contentView = contentViewRef.get()
-                    ?: return KL.e { "KauSwipe cannot change view position as contentView is null; is onPostCreate called?" }
+                ?: return KL.e { "KauSwipe cannot change view position as contentView is null; is onPostCreate called?" }
             //make sure that we are using the proper axis
             scrollPercent = Math.abs(
-                    if (horizontal) left.toFloat() / contentView.width
-                    else (top.toFloat() / contentView.height))
+                if (horizontal) left.toFloat() / contentView.width
+                else (top.toFloat() / contentView.height)
+            )
             contentOffset = if (horizontal) left else top
             invalidate()
             if (scrollPercent < scrollThreshold && !isScrollOverValid)
@@ -375,10 +393,11 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
             var result = Pair(0, 0)
             if (scrollPercent <= scrollThreshold) {
                 //threshold not met; check velocities
-                if ((edgeFlag == SWIPE_EDGE_LEFT && xvel > MIN_FLING_VELOCITY)
-                        || (edgeFlag == SWIPE_EDGE_RIGHT && xvel < -MIN_FLING_VELOCITY)
-                        || (edgeFlag == SWIPE_EDGE_TOP && yvel > MIN_FLING_VELOCITY)
-                        || (edgeFlag == SWIPE_EDGE_BOTTOM && yvel < -MIN_FLING_VELOCITY))
+                if ((edgeFlag == SWIPE_EDGE_LEFT && xvel > MIN_FLING_VELOCITY) ||
+                    (edgeFlag == SWIPE_EDGE_RIGHT && xvel < -MIN_FLING_VELOCITY) ||
+                    (edgeFlag == SWIPE_EDGE_TOP && yvel > MIN_FLING_VELOCITY) ||
+                    (edgeFlag == SWIPE_EDGE_BOTTOM && yvel < -MIN_FLING_VELOCITY)
+                )
                     result = exitCaptureOffsets(edgeFlag, releasedChild)
             } else {
                 //threshold met; fling to designated side
@@ -431,6 +450,5 @@ internal class SwipeBackLayout @JvmOverloads constructor(context: Context, attrs
         const val DEFAULT_SCROLL_THRESHOLD = 0.3f
 
         const val OVERSCROLL_DISTANCE = 10
-
     }
 }
diff --git a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackPage.kt b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackPage.kt
index 4dba622..bc5b459 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackPage.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeBackPage.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.swipe
 
 import android.app.Activity
@@ -24,7 +39,8 @@ internal class SwipeBackPage(activity: Activity) : SwipeBackContractInternal by
     init {
         activity.window.setBackgroundDrawable(ColorDrawable(Color.TRANSPARENT))
         activity.window.decorView.setBackgroundColor(Color.TRANSPARENT)
-        swipeBackLayout.layoutParams = ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
+        swipeBackLayout.layoutParams =
+            ViewGroup.LayoutParams(ViewGroup.LayoutParams.MATCH_PARENT, ViewGroup.LayoutParams.MATCH_PARENT)
         slider = RelativeSlider(this)
     }
 
@@ -41,7 +57,7 @@ internal class SwipeBackPage(activity: Activity) : SwipeBackContractInternal by
 
     private fun handleLayout() {
         val activity = activityRef.get()
-                ?: return KL.v { "KauSwipe activity ref gone during handleLayout" }
+            ?: return KL.v { "KauSwipe activity ref gone during handleLayout" }
         if (swipeEnabled) swipeBackLayout.attachToActivity(activity)
         else swipeBackLayout.removeFromActivity(activity)
     }
@@ -50,7 +66,6 @@ internal class SwipeBackPage(activity: Activity) : SwipeBackContractInternal by
         swipeBackLayout.scrollThreshold = percent
         return this
     }
-
 }
 
 internal interface SwipeBackContractInternal : SwipeBackContract {
@@ -104,4 +119,4 @@ interface SwipeBackContract {
     fun removeListener(listener: SwipeListener)
     fun hasListener(listener: SwipeListener): Boolean
     fun scrollToFinishActivity()
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeListener.kt b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeListener.kt
index 3ea62b5..07f8eb8 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeListener.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/swipe/SwipeListener.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.swipe
 
 interface SwipeListener {
@@ -16,4 +31,4 @@ interface SwipeListener {
      * Invoked when scroll percent over the threshold for the first time
      */
     fun onScrollToClose(edgeFlag: Int)
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/ui/ProgressAnimator.kt b/core/src/main/kotlin/ca/allanwang/kau/ui/ProgressAnimator.kt
index e37e59f..6f8bbc1 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/ui/ProgressAnimator.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/ui/ProgressAnimator.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.ui
 
 import android.animation.Animator
@@ -86,4 +101,4 @@ class ProgressAnimator private constructor(private vararg val values: Float) {
             start()
         }
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/ui/SimpleRippleDrawable.kt b/core/src/main/kotlin/ca/allanwang/kau/ui/SimpleRippleDrawable.kt
index 4700162..684a11c 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/ui/SimpleRippleDrawable.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/ui/SimpleRippleDrawable.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.ui
 
 import android.content.res.ColorStateList
@@ -19,4 +34,4 @@ fun createSimpleRippleDrawable(@ColorInt foregroundColor: Int, @ColorInt backgro
     val content = ColorDrawable(backgroundColor)
     val mask = ColorDrawable(foregroundColor.adjustAlpha(0.16f))
     return RippleDrawable(states, content, mask)
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/ui/views/CollapsibleViewDelegate.kt b/core/src/main/kotlin/ca/allanwang/kau/ui/views/CollapsibleViewDelegate.kt
index 8923775..b2a0d27 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/ui/views/CollapsibleViewDelegate.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/ui/views/CollapsibleViewDelegate.kt
@@ -1,8 +1,27 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.ui.views
 
 import android.animation.ValueAnimator
 import android.view.View
-import ca.allanwang.kau.utils.*
+import ca.allanwang.kau.utils.KAU_COLLAPSED
+import ca.allanwang.kau.utils.KAU_COLLAPSING
+import ca.allanwang.kau.utils.KAU_EXPANDED
+import ca.allanwang.kau.utils.KAU_EXPANDING
+import ca.allanwang.kau.utils.goneIf
 import java.lang.ref.WeakReference
 
 /**
@@ -48,10 +67,10 @@ class CollapsibleViewDelegate : CollapsibleView {
             if (v > 1) v = 1f
             else if (v < 0) v = 0f
             stateHolder =
-                    if (v == 0f) KAU_COLLAPSED
-                    else if (v == 1f) KAU_EXPANDED
-                    else if (v - field < 0) KAU_COLLAPSING
-                    else KAU_EXPANDING
+                if (v == 0f) KAU_COLLAPSED
+                else if (v == 1f) KAU_EXPANDED
+                else if (v - field < 0) KAU_COLLAPSING
+                else KAU_EXPANDING
             field = v
             view?.goneIf(state == KAU_COLLAPSED)
             view?.requestLayout()
@@ -101,5 +120,4 @@ class CollapsibleViewDelegate : CollapsibleView {
         val target = if (expand) 1f else 0f
         if (animate) animateSize(target) else expansion = target
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/ui/views/MeasureSpecDelegate.kt b/core/src/main/kotlin/ca/allanwang/kau/ui/views/MeasureSpecDelegate.kt
index 716fd71..6481306 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/ui/views/MeasureSpecDelegate.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/ui/views/MeasureSpecDelegate.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.ui.views
 
 import android.content.Context
@@ -84,10 +99,13 @@ class MeasureSpecDelegate : MeasureSpecContract {
         val styledAttrs = context.obtainStyledAttributes(attrs, R.styleable.MeasureSpecDelegate)
         relativeWidth = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeWidth, relativeWidth)
         relativeHeight = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeHeight, relativeHeight)
-        relativeWidthToParent = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeWidthToParent, relativeWidthToParent)
-        relativeHeightToParent = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeHeightToParent, relativeHeightToParent)
+        relativeWidthToParent =
+            styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeWidthToParent, relativeWidthToParent)
+        relativeHeightToParent =
+            styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_relativeHeightToParent, relativeHeightToParent)
         postRelativeWidth = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_postRelativeWidth, postRelativeWidth)
-        postRelativeHeight = styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_postRelativeHeight, postRelativeHeight)
+        postRelativeHeight =
+            styledAttrs.getFloat(R.styleable.MeasureSpecDelegate_postRelativeHeight, postRelativeHeight)
         styledAttrs.recycle()
     }
 
@@ -115,5 +133,4 @@ class MeasureSpecDelegate : MeasureSpecContract {
 
     private val Float.measureSpec: Int
         get() = View.MeasureSpec.makeMeasureSpec(this.toInt(), View.MeasureSpec.EXACTLY)
-
 }
diff --git a/core/src/main/kotlin/ca/allanwang/kau/ui/views/RippleCanvas.kt b/core/src/main/kotlin/ca/allanwang/kau/ui/views/RippleCanvas.kt
index 3d86419..176b9ea 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/ui/views/RippleCanvas.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/ui/views/RippleCanvas.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.ui.views
 
 import android.animation.Animator
@@ -5,7 +20,11 @@ import android.animation.AnimatorListenerAdapter
 import android.animation.ArgbEvaluator
 import android.animation.ValueAnimator
 import android.content.Context
-import android.graphics.*
+import android.graphics.Canvas
+import android.graphics.Color
+import android.graphics.Paint
+import android.graphics.PorterDuff
+import android.graphics.PorterDuffXfermode
 import android.util.AttributeSet
 import android.view.View
 
@@ -17,7 +36,9 @@ import android.view.View
  * Supports multiple ripples from varying locations
  */
 class RippleCanvas @JvmOverloads constructor(
-        context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = 0
+    context: Context,
+    attrs: AttributeSet? = null,
+    defStyleAttr: Int = 0
 ) : View(context, attrs, defStyleAttr) {
     private val paint: Paint = Paint().apply {
         isAntiAlias = true
@@ -53,11 +74,13 @@ class RippleCanvas @JvmOverloads constructor(
     /**
      * Creates a ripple effect from the given starting values
      */
-    fun ripple(color: Int,
-               startX: Float = 0f,
-               startY: Float = 0f,
-               duration: Long = 600L,
-               callback: (() -> Unit)? = null) {
+    fun ripple(
+        color: Int,
+        startX: Float = 0f,
+        startY: Float = 0f,
+        duration: Long = 600L,
+        callback: (() -> Unit)? = null
+    ) {
         val w = width.toFloat()
         val h = height.toFloat()
         val x = when (startX) {
@@ -112,11 +135,13 @@ class RippleCanvas @JvmOverloads constructor(
         animator.start()
     }
 
-    internal class Ripple(val color: Int,
-                          val x: Float,
-                          val y: Float,
-                          var radius: Float,
-                          val maxRadius: Float)
+    internal class Ripple(
+        val color: Int,
+        val x: Float,
+        val y: Float,
+        var radius: Float,
+        val maxRadius: Float
+    )
 
     companion object {
         const val MIDDLE = -1.0f
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/ActivityUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/ActivityUtils.kt
index eab9536..a655e5b 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/ActivityUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/ActivityUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 @file:Suppress("NOTHING_TO_INLINE")
 
 package ca.allanwang.kau.utils
@@ -36,19 +51,22 @@ annotation class KauActivity
  */
 @Suppress("DEPRECATION")
 inline fun <reified T : Activity> Activity.startActivityForResult(
-        requestCode: Int,
-        bundleBuilder: Bundle.() -> Unit = {},
-        intentBuilder: Intent.() -> Unit = {}
+    requestCode: Int,
+    bundleBuilder: Bundle.() -> Unit = {},
+    intentBuilder: Intent.() -> Unit = {}
 ) = startActivityForResult(T::class.java, requestCode, bundleBuilder, intentBuilder)
 
-@Deprecated("Use reified generic instead of passing class",
-        ReplaceWith("startActivityForResult<T>(requestCode, bundleBuilder, intentBuilder)"),
-        DeprecationLevel.WARNING)
+@Deprecated(
+    "Use reified generic instead of passing class",
+    ReplaceWith("startActivityForResult<T>(requestCode, bundleBuilder, intentBuilder)"),
+    DeprecationLevel.WARNING
+)
 inline fun <T : Activity> Activity.startActivityForResult(
-        clazz: Class<T>,
-        requestCode: Int,
-        bundleBuilder: Bundle.() -> Unit = {},
-        intentBuilder: Intent.() -> Unit = {}) {
+    clazz: Class<T>,
+    requestCode: Int,
+    bundleBuilder: Bundle.() -> Unit = {},
+    intentBuilder: Intent.() -> Unit = {}
+) {
     val intent = Intent(this, clazz)
     intent.intentBuilder()
     val bundle = Bundle()
@@ -72,7 +90,6 @@ inline fun Activity.restart(intentBuilder: Intent.() -> Unit = {}) {
     overridePendingTransition(R.anim.kau_fade_in, R.anim.kau_fade_out)
 }
 
-
 /**
  * Force restart an entire application
  */
@@ -119,8 +136,8 @@ inline var Activity.statusBarLight: Boolean
         if (buildIsMarshmallowAndUp) {
             val flags = window.decorView.systemUiVisibility
             window.decorView.systemUiVisibility =
-                    if (value) flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
-                    else flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
+                if (value) flags or View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
+                else flags and View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR.inv()
         }
     }
 
@@ -143,6 +160,14 @@ inline fun Activity.showKeyboard() {
     currentFocus?.showKeyboard()
 }
 
-inline fun Activity.snackbar(text: String, duration: Int = Snackbar.LENGTH_LONG, noinline builder: Snackbar.() -> Unit = {}) = contentView!!.snackbar(text, duration, builder)
-
-inline fun Activity.snackbar(@StringRes textId: Int, duration: Int = Snackbar.LENGTH_LONG, noinline builder: Snackbar.() -> Unit = {}) = contentView!!.snackbar(textId, duration, builder)
\ No newline at end of file
+inline fun Activity.snackbar(
+    text: String,
+    duration: Int = Snackbar.LENGTH_LONG,
+    noinline builder: Snackbar.() -> Unit = {}
+) = contentView!!.snackbar(text, duration, builder)
+
+inline fun Activity.snackbar(
+    @StringRes textId: Int,
+    duration: Int = Snackbar.LENGTH_LONG,
+    noinline builder: Snackbar.() -> Unit = {}
+) = contentView!!.snackbar(textId, duration, builder)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/AnimHolder.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/AnimHolder.kt
index b988085..0062361 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/AnimHolder.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/AnimHolder.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.os.Build
@@ -14,5 +29,4 @@ object AnimHolder {
     @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
     val fastOutSlowInInterpolator = lazyInterpolator(android.R.interpolator.fast_out_linear_in)
     val decelerateInterpolator = lazyInterpolator(android.R.interpolator.decelerate_cubic)
-
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/AnimUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/AnimUtils.kt
index d8e4681..0a548ce 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/AnimUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/AnimUtils.kt
@@ -1,15 +1,30 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.animation.Animator
 import android.animation.AnimatorListenerAdapter
 import android.annotation.SuppressLint
-import androidx.annotation.StringRes
 import android.view.View
 import android.view.ViewAnimationUtils
 import android.view.ViewPropertyAnimator
 import android.view.animation.Animation
 import android.view.animation.AnimationUtils
 import android.widget.TextView
+import androidx.annotation.StringRes
 
 /**
  * Created by Allan Wang on 2017-06-01.
@@ -19,7 +34,15 @@ import android.widget.TextView
 
 @SuppressLint("NewApi")
 @KauUtils
-fun View.circularReveal(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float = -1.0f, duration: Long = 500L, onStart: (() -> Unit)? = null, onFinish: (() -> Unit)? = null) {
+fun View.circularReveal(
+    x: Int = 0,
+    y: Int = 0,
+    offset: Long = 0L,
+    radius: Float = -1.0f,
+    duration: Long = 500L,
+    onStart: (() -> Unit)? = null,
+    onFinish: (() -> Unit)? = null
+) {
     if (!isAttachedToWindow) {
         onStart?.invoke()
         visible()
@@ -29,7 +52,10 @@ fun View.circularReveal(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float
     if (!buildIsLollipopAndUp) return fadeIn(offset, duration, onStart, onFinish)
 
     val r = if (radius >= 0) radius
-    else Math.max(Math.hypot(x.toDouble(), y.toDouble()), Math.hypot((width - x.toDouble()), (height - y.toDouble()))).toFloat()
+    else Math.max(
+        Math.hypot(x.toDouble(), y.toDouble()),
+        Math.hypot((width - x.toDouble()), (height - y.toDouble()))
+    ).toFloat()
 
     val anim = ViewAnimationUtils.createCircularReveal(this, x, y, 0f, r).setDuration(duration)
     anim.startDelay = offset
@@ -47,7 +73,15 @@ fun View.circularReveal(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float
 
 @SuppressLint("NewApi")
 @KauUtils
-fun View.circularHide(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float = -1.0f, duration: Long = 500L, onStart: (() -> Unit)? = null, onFinish: (() -> Unit)? = null) {
+fun View.circularHide(
+    x: Int = 0,
+    y: Int = 0,
+    offset: Long = 0L,
+    radius: Float = -1.0f,
+    duration: Long = 500L,
+    onStart: (() -> Unit)? = null,
+    onFinish: (() -> Unit)? = null
+) {
     if (!isAttachedToWindow) {
         onStart?.invoke()
         invisible()
@@ -57,7 +91,10 @@ fun View.circularHide(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float =
     if (!buildIsLollipopAndUp) return fadeOut(offset, duration, onStart, onFinish)
 
     val r = if (radius >= 0) radius
-    else Math.max(Math.hypot(x.toDouble(), y.toDouble()), Math.hypot((width - x.toDouble()), (height - y.toDouble()))).toFloat()
+    else Math.max(
+        Math.hypot(x.toDouble(), y.toDouble()),
+        Math.hypot((width - x.toDouble()), (height - y.toDouble()))
+    ).toFloat()
 
     val anim = ViewAnimationUtils.createCircularReveal(this, x, y, r, 0f).setDuration(duration)
     anim.startDelay = offset
@@ -75,7 +112,12 @@ fun View.circularHide(x: Int = 0, y: Int = 0, offset: Long = 0L, radius: Float =
 }
 
 @KauUtils
-fun View.fadeIn(offset: Long = 0L, duration: Long = 200L, onStart: (() -> Unit)? = null, onFinish: (() -> Unit)? = null) {
+fun View.fadeIn(
+    offset: Long = 0L,
+    duration: Long = 200L,
+    onStart: (() -> Unit)? = null,
+    onFinish: (() -> Unit)? = null
+) {
     if (!isAttachedToWindow) {
         onStart?.invoke()
         visible()
@@ -97,7 +139,12 @@ fun View.fadeIn(offset: Long = 0L, duration: Long = 200L, onStart: (() -> Unit)?
 }
 
 @KauUtils
-fun View.fadeOut(offset: Long = 0L, duration: Long = 200L, onStart: (() -> Unit)? = null, onFinish: (() -> Unit)? = null) {
+fun View.fadeOut(
+    offset: Long = 0L,
+    duration: Long = 200L,
+    onStart: (() -> Unit)? = null,
+    onFinish: (() -> Unit)? = null
+) {
     if (!isAttachedToWindow) {
         onStart?.invoke()
         invisible()
@@ -130,7 +177,8 @@ fun TextView.setTextWithFade(text: String, duration: Long = 200, onFinish: (() -
 }
 
 @KauUtils
-fun TextView.setTextWithFade(@StringRes textId: Int, duration: Long = 200, onFinish: (() -> Unit)? = null) = setTextWithFade(context.getString(textId), duration, onFinish)
+fun TextView.setTextWithFade(@StringRes textId: Int, duration: Long = 200, onFinish: (() -> Unit)? = null) =
+    setTextWithFade(context.getString(textId), duration, onFinish)
 
 @KauUtils
-fun ViewPropertyAnimator.scaleXY(value: Float) = scaleX(value).scaleY(value)
\ No newline at end of file
+fun ViewPropertyAnimator.scaleXY(value: Float) = scaleX(value).scaleY(value)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/BundleUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/BundleUtils.kt
index d628214..314ca60 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/BundleUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/BundleUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.annotation.SuppressLint
@@ -5,9 +20,9 @@ import android.app.Activity
 import android.app.ActivityOptions
 import android.content.Context
 import android.os.Bundle
-import androidx.annotation.AnimRes
 import android.util.Pair
 import android.view.View
+import androidx.annotation.AnimRes
 import ca.allanwang.kau.R
 
 /**
@@ -36,9 +51,9 @@ fun Bundle.withSceneTransitionAnimation(context: Context) {
  * create a scene transition animation
  */
 fun Bundle.withSceneTransitionAnimation(parent: View, data: Map<Int, String>) =
-        withSceneTransitionAnimation(parent.context, data.mapKeys { (id, _) ->
-            parent.findViewById<View>(id)
-        })
+    withSceneTransitionAnimation(parent.context, data.mapKeys { (id, _) ->
+        parent.findViewById<View>(id)
+    })
 
 /**
  * Given a mapping of views to tags,
@@ -48,22 +63,33 @@ fun Bundle.withSceneTransitionAnimation(parent: View, data: Map<Int, String>) =
 fun Bundle.withSceneTransitionAnimation(context: Context, data: Map<View, String>) {
     if (context !is Activity || !buildIsLollipopAndUp) return
     val options = ActivityOptions.makeSceneTransitionAnimation(context,
-            *data.map { (view, tag) -> Pair(view, tag) }.toTypedArray())
+        *data.map { (view, tag) -> Pair(view, tag) }.toTypedArray()
+    )
     putAll(options.toBundle())
 }
 
-fun Bundle.withCustomAnimation(context: Context,
-                               @AnimRes enterResId: Int,
-                               @AnimRes exitResId: Int) {
-    this with ActivityOptions.makeCustomAnimation(context,
-            enterResId, exitResId).toBundle()
+fun Bundle.withCustomAnimation(
+    context: Context,
+    @AnimRes enterResId: Int,
+    @AnimRes exitResId: Int
+) {
+    this with ActivityOptions.makeCustomAnimation(
+        context,
+        enterResId, exitResId
+    ).toBundle()
 }
 
-fun Bundle.withSlideIn(context: Context) = withCustomAnimation(context,
-        R.anim.kau_slide_in_right, R.anim.kau_fade_out)
+fun Bundle.withSlideIn(context: Context) = withCustomAnimation(
+    context,
+    R.anim.kau_slide_in_right, R.anim.kau_fade_out
+)
 
-fun Bundle.withSlideOut(context: Context) = withCustomAnimation(context,
-        R.anim.kau_fade_in, R.anim.kau_slide_out_right_top)
+fun Bundle.withSlideOut(context: Context) = withCustomAnimation(
+    context,
+    R.anim.kau_fade_in, R.anim.kau_slide_out_right_top
+)
 
-fun Bundle.withFade(context: Context) = withCustomAnimation(context,
-        android.R.anim.fade_in, android.R.anim.fade_out)
\ No newline at end of file
+fun Bundle.withFade(context: Context) = withCustomAnimation(
+    context,
+    android.R.anim.fade_in, android.R.anim.fade_out
+)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/ColorUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/ColorUtils.kt
index f010c6f..9e1832f 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/ColorUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/ColorUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.annotation.SuppressLint
@@ -7,15 +22,21 @@ import android.graphics.Color
 import android.graphics.PorterDuff
 import android.graphics.drawable.Drawable
 import android.os.Build
+import android.widget.CheckBox
+import android.widget.EditText
+import android.widget.ImageButton
+import android.widget.ProgressBar
+import android.widget.RadioButton
+import android.widget.SeekBar
+import android.widget.TextView
 import androidx.annotation.ColorInt
 import androidx.annotation.FloatRange
 import androidx.annotation.IntRange
-import androidx.core.graphics.drawable.DrawableCompat
 import androidx.appcompat.widget.AppCompatEditText
 import androidx.appcompat.widget.Toolbar
-import android.widget.*
+import androidx.core.graphics.drawable.DrawableCompat
 import com.afollestad.materialdialogs.R
-import java.util.*
+import java.util.Random
 
 /**
  * Created by Allan Wang on 2017-06-08.
@@ -38,7 +59,7 @@ inline val Int.isColorDark: Boolean
     get() = isColorDark(0.5f)
 
 fun Int.isColorDark(minDarkness: Float): Boolean =
-        ((0.299 * Color.red(this) + 0.587 * Color.green(this) + 0.114 * Color.blue(this)) / 255.0) < minDarkness
+    ((0.299 * Color.red(this) + 0.587 * Color.green(this) + 0.114 * Color.blue(this)) / 255.0) < minDarkness
 
 fun Int.toHexString(withAlpha: Boolean = false, withHexPrefix: Boolean = true): String {
     val hex = if (withAlpha) String.format("#%08X", this)
@@ -46,7 +67,8 @@ fun Int.toHexString(withAlpha: Boolean = false, withHexPrefix: Boolean = true):
     return if (withHexPrefix) hex else hex.substring(1)
 }
 
-fun Int.toRgbaString(): String = "rgba(${Color.red(this)}, ${Color.green(this)}, ${Color.blue(this)}, ${(Color.alpha(this) / 255f).round(3)})"
+fun Int.toRgbaString(): String =
+    "rgba(${Color.red(this)}, ${Color.green(this)}, ${Color.blue(this)}, ${(Color.alpha(this) / 255f).round(3)})"
 
 fun Int.toHSV(): FloatArray {
     val hsv = FloatArray(3)
@@ -59,13 +81,15 @@ inline val Int.isColorOpaque: Boolean
 
 fun FloatArray.toColor(): Int = Color.HSVToColor(this)
 
-fun Int.isColorVisibleOn(@ColorInt color: Int, @IntRange(from = 0L, to = 255L) delta: Int = 25,
-                         @IntRange(from = 0L, to = 255L) minAlpha: Int = 50): Boolean =
-        if (Color.alpha(this) < minAlpha) false
-        else !(Math.abs(Color.red(this) - Color.red(color)) < delta
-                && Math.abs(Color.green(this) - Color.green(color)) < delta
-                && Math.abs(Color.blue(this) - Color.blue(color)) < delta)
-
+fun Int.isColorVisibleOn(
+    @ColorInt color: Int,
+    @IntRange(from = 0L, to = 255L) delta: Int = 25,
+    @IntRange(from = 0L, to = 255L) minAlpha: Int = 50
+): Boolean =
+    if (Color.alpha(this) < minAlpha) false
+    else !(Math.abs(Color.red(this) - Color.red(color)) < delta &&
+        Math.abs(Color.green(this) - Color.green(color)) < delta &&
+        Math.abs(Color.blue(this) - Color.blue(color)) < delta)
 
 @ColorInt
 fun Context.getDisabledColor(): Int {
@@ -94,30 +118,34 @@ fun Int.blendWith(@ColorInt color: Int, @FloatRange(from = 0.0, to = 1.0) ratio:
 }
 
 @ColorInt
-fun Int.withAlpha(@IntRange(from = 0L, to = 255L) alpha: Int): Int = Color.argb(alpha, Color.red(this), Color.green(this), Color.blue(this))
+fun Int.withAlpha(@IntRange(from = 0L, to = 255L) alpha: Int): Int =
+    Color.argb(alpha, Color.red(this), Color.green(this), Color.blue(this))
 
 @ColorInt
-fun Int.withMinAlpha(@IntRange(from = 0L, to = 255L) alpha: Int): Int = Color.argb(Math.max(alpha, Color.alpha(this)), Color.red(this), Color.green(this), Color.blue(this))
+fun Int.withMinAlpha(@IntRange(from = 0L, to = 255L) alpha: Int): Int =
+    Color.argb(Math.max(alpha, Color.alpha(this)), Color.red(this), Color.green(this), Color.blue(this))
 
 @ColorInt
 fun Int.lighten(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int {
     val (red, green, blue) = intArrayOf(Color.red(this), Color.green(this), Color.blue(this))
-            .map { (it * (1f - factor) + 255f * factor).toInt() }
+        .map { (it * (1f - factor) + 255f * factor).toInt() }
     return Color.argb(Color.alpha(this), red, green, blue)
 }
 
 @ColorInt
 fun Int.darken(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int {
     val (red, green, blue) = intArrayOf(Color.red(this), Color.green(this), Color.blue(this))
-            .map { (it * (1f - factor)).toInt() }
+        .map { (it * (1f - factor)).toInt() }
     return Color.argb(Color.alpha(this), red, green, blue)
 }
 
 @ColorInt
-fun Int.colorToBackground(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int = if (isColorDark) darken(factor) else lighten(factor)
+fun Int.colorToBackground(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int =
+    if (isColorDark) darken(factor) else lighten(factor)
 
 @ColorInt
-fun Int.colorToForeground(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int = if (isColorDark) lighten(factor) else darken(factor)
+fun Int.colorToForeground(@FloatRange(from = 0.0, to = 1.0) factor: Float = 0.1f): Int =
+    if (isColorDark) lighten(factor) else darken(factor)
 
 @Throws(IllegalArgumentException::class)
 fun String.toColor(): Int {
@@ -132,11 +160,15 @@ fun String.toColor(): Int {
 //Get ColorStateList
 fun Context.colorStateList(@ColorInt color: Int): ColorStateList {
     val disabledColor = color.adjustAlpha(0.3f)
-    return ColorStateList(arrayOf(intArrayOf(android.R.attr.state_enabled, -android.R.attr.state_checked),
+    return ColorStateList(
+        arrayOf(
+            intArrayOf(android.R.attr.state_enabled, -android.R.attr.state_checked),
             intArrayOf(android.R.attr.state_enabled, android.R.attr.state_checked),
             intArrayOf(-android.R.attr.state_enabled, -android.R.attr.state_checked),
-            intArrayOf(-android.R.attr.state_enabled, android.R.attr.state_checked)),
-            intArrayOf(color.adjustAlpha(0.8f), color, disabledColor, disabledColor))
+            intArrayOf(-android.R.attr.state_enabled, android.R.attr.state_checked)
+        ),
+        intArrayOf(color.adjustAlpha(0.8f), color, disabledColor, disabledColor)
+    )
 }
 
 /*
@@ -203,14 +235,14 @@ fun ProgressBar.tint(@ColorInt color: Int, skipIndeterminate: Boolean = false) {
 
 fun Context.textColorStateList(@ColorInt color: Int): ColorStateList {
     val states = arrayOf(
-            intArrayOf(-android.R.attr.state_enabled),
-            intArrayOf(-android.R.attr.state_pressed, -android.R.attr.state_focused),
-            intArrayOf()
+        intArrayOf(-android.R.attr.state_enabled),
+        intArrayOf(-android.R.attr.state_pressed, -android.R.attr.state_focused),
+        intArrayOf()
     )
     val colors = intArrayOf(
-            resolveColor(R.attr.colorControlNormal),
-            resolveColor(R.attr.colorControlNormal),
-            color
+        resolveColor(R.attr.colorControlNormal),
+        resolveColor(R.attr.colorControlNormal),
+        color
     )
     return ColorStateList(states, colors)
 }
@@ -254,4 +286,4 @@ fun Toolbar.tint(@ColorInt color: Int, tintTitle: Boolean = true) {
         setSubtitleTextColor(color)
     }
     (0 until childCount).asSequence().forEach { (getChildAt(it) as? ImageButton)?.setColorFilter(color) }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/Const.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/Const.kt
index eb09093..9dca16c 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/Const.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/Const.kt
@@ -1,8 +1,22 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import androidx.customview.widget.ViewDragHelper
 
-
 /**
  * Created by Allan Wang on 2017-06-08.
  */
@@ -21,4 +35,4 @@ const val KAU_COLLAPSING = 1
 const val KAU_EXPANDING = 2
 const val KAU_EXPANDED = 3
 
-const val KAU_ELLIPSIS = '\u2026'
\ No newline at end of file
+const val KAU_ELLIPSIS = '\u2026'
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/ContextUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/ContextUtils.kt
index f6e9ac7..134126d 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/ContextUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/ContextUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 @file:Suppress("NOTHING_TO_INLINE")
 
 package ca.allanwang.kau.utils
@@ -11,17 +26,26 @@ import android.content.pm.PackageManager
 import android.graphics.drawable.Drawable
 import android.net.Uri
 import android.os.Bundle
-import androidx.annotation.*
-import androidx.core.content.ContextCompat
 import android.util.TypedValue
 import android.view.View
 import android.view.animation.AnimationUtils
 import android.widget.Toast
+import androidx.annotation.AnimRes
+import androidx.annotation.AttrRes
+import androidx.annotation.BoolRes
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.annotation.DimenRes
+import androidx.annotation.DrawableRes
+import androidx.annotation.IntegerRes
+import androidx.annotation.InterpolatorRes
+import androidx.annotation.PluralsRes
+import androidx.annotation.StringRes
+import androidx.core.content.ContextCompat
 import ca.allanwang.kau.R
 import ca.allanwang.kau.logging.KL
 import com.afollestad.materialdialogs.MaterialDialog
 
-
 /**
  * Created by Allan Wang on 2017-06-03.
  */
@@ -33,19 +57,22 @@ import com.afollestad.materialdialogs.MaterialDialog
  */
 @Suppress("DEPRECATION")
 inline fun <reified T : Activity> Context.startActivity(
-        clearStack: Boolean = false,
-        bundleBuilder: Bundle.() -> Unit = {},
-        intentBuilder: Intent.() -> Unit = {}
+    clearStack: Boolean = false,
+    bundleBuilder: Bundle.() -> Unit = {},
+    intentBuilder: Intent.() -> Unit = {}
 ) = startActivity(T::class.java, clearStack, bundleBuilder, intentBuilder)
 
-@Deprecated("Use reified generic instead of passing class",
-        ReplaceWith("startActivity<T>(clearStack, bundleBuilder, intentBuilder)"),
-        DeprecationLevel.WARNING)
+@Deprecated(
+    "Use reified generic instead of passing class",
+    ReplaceWith("startActivity<T>(clearStack, bundleBuilder, intentBuilder)"),
+    DeprecationLevel.WARNING
+)
 inline fun <T : Activity> Context.startActivity(
-        clazz: Class<T>,
-        clearStack: Boolean = false,
-        bundleBuilder: Bundle.() -> Unit = {},
-        intentBuilder: Intent.() -> Unit = {}) {
+    clazz: Class<T>,
+    clearStack: Boolean = false,
+    bundleBuilder: Bundle.() -> Unit = {},
+    intentBuilder: Intent.() -> Unit = {}
+) {
     val intent = Intent(this, clazz)
     if (clearStack) intent.addFlags(Intent.FLAG_ACTIVITY_CLEAR_TASK or Intent.FLAG_ACTIVITY_NEW_TASK)
     intent.intentBuilder()
@@ -55,7 +82,6 @@ inline fun <T : Activity> Context.startActivity(
     if (clearStack && this is Activity) finish()
 }
 
-
 fun Context.startPlayStoreLink(@StringRes packageIdRes: Int) = startPlayStoreLink(string(packageIdRes))
 
 fun Context.startPlayStoreLink(packageId: String) {
@@ -82,11 +108,14 @@ fun Context.startLink(vararg url: String?) {
 fun Context.startLink(@StringRes url: Int) = startLink(string(url))
 
 //Toast helpers
-inline fun View.toast(@StringRes id: Int, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) = context.toast(id, duration, log)
+inline fun View.toast(@StringRes id: Int, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) =
+    context.toast(id, duration, log)
 
-inline fun Context.toast(@StringRes id: Int, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) = toast(this.string(id), duration, log)
+inline fun Context.toast(@StringRes id: Int, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) =
+    toast(this.string(id), duration, log)
 
-inline fun View.toast(text: String, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) = context.toast(text, duration, log)
+inline fun View.toast(text: String, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) =
+    context.toast(text, duration, log)
 
 inline fun Context.toast(text: String, duration: Int = Toast.LENGTH_LONG, log: Boolean = false) {
     Toast.makeText(this, text, duration).show()
@@ -98,24 +127,33 @@ const val INVALID_ID = 0
 //Resource retrievers
 inline fun Context.string(@StringRes id: Int): String = getString(id)
 
-inline fun Context.string(@StringRes id: Int, fallback: String?): String? = if (id != INVALID_ID) string(id) else fallback
-inline fun Context.string(@StringRes id: Int, fallback: () -> String?): String? = if (id != INVALID_ID) string(id) else fallback()
+inline fun Context.string(@StringRes id: Int, fallback: String?): String? =
+    if (id != INVALID_ID) string(id) else fallback
+
+inline fun Context.string(@StringRes id: Int, fallback: () -> String?): String? =
+    if (id != INVALID_ID) string(id) else fallback()
+
 inline fun Context.color(@ColorRes id: Int): Int = ContextCompat.getColor(this, id)
 inline fun Context.boolean(@BoolRes id: Int): Boolean = resources.getBoolean(id)
 inline fun Context.integer(@IntegerRes id: Int): Int = resources.getInteger(id)
 inline fun Context.dimen(@DimenRes id: Int): Float = resources.getDimension(id)
 inline fun Context.dimenPixelSize(@DimenRes id: Int): Int = resources.getDimensionPixelSize(id)
 inline fun Context.drawable(@DrawableRes id: Int): Drawable = ContextCompat.getDrawable(this, id)
-        ?: throw KauException("Drawable with id $id not found")
+    ?: throw KauException("Drawable with id $id not found")
+
+inline fun Context.drawable(@DrawableRes id: Int, fallback: Drawable?): Drawable? =
+    if (id != INVALID_ID) drawable(id) else fallback
+
+inline fun Context.drawable(@DrawableRes id: Int, fallback: () -> Drawable?): Drawable? =
+    if (id != INVALID_ID) drawable(id) else fallback()
 
-inline fun Context.drawable(@DrawableRes id: Int, fallback: Drawable?): Drawable? = if (id != INVALID_ID) drawable(id) else fallback
-inline fun Context.drawable(@DrawableRes id: Int, fallback: () -> Drawable?): Drawable? = if (id != INVALID_ID) drawable(id) else fallback()
 inline fun Context.interpolator(@InterpolatorRes id: Int) = AnimationUtils.loadInterpolator(this, id)!!
 inline fun Context.animation(@AnimRes id: Int) = AnimationUtils.loadAnimation(this, id)!!
 /**
  * Returns plural form of res. The quantity is also passed to the formatter as an int
  */
-inline fun Context.plural(@PluralsRes id: Int, quantity: Number) = resources.getQuantityString(id, quantity.toInt(), quantity.toInt())!!
+inline fun Context.plural(@PluralsRes id: Int, quantity: Number) =
+    resources.getQuantityString(id, quantity.toInt(), quantity.toInt())!!
 
 //Attr retrievers
 fun Context.resolveColor(@AttrRes attr: Int, @ColorInt fallback: Int = 0): Int {
@@ -164,7 +202,8 @@ inline fun Context.materialDialog(action: MaterialDialog.Builder.() -> Unit): Ma
     return builder.show()
 }
 
-fun Context.getDip(value: Float): Float = TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, resources.displayMetrics)
+fun Context.getDip(value: Float): Float =
+    TypedValue.applyDimension(TypedValue.COMPLEX_UNIT_DIP, value, resources.displayMetrics)
 
 inline val Context.isRtl: Boolean
     get() = resources.configuration.layoutDirection == View.LAYOUT_DIRECTION_RTL
@@ -181,7 +220,10 @@ inline val Context.isNavBarOnBottom: Boolean
         return !canMove || dm.widthPixels < dm.heightPixels
     }
 
-fun Context.hasPermission(permissions: String) = !buildIsMarshmallowAndUp || ContextCompat.checkSelfPermission(this, permissions) == PackageManager.PERMISSION_GRANTED
+fun Context.hasPermission(permissions: String) = !buildIsMarshmallowAndUp || ContextCompat.checkSelfPermission(
+    this,
+    permissions
+) == PackageManager.PERMISSION_GRANTED
 
 fun Context.copyToClipboard(text: String?, label: String = "Copied Text", showToast: Boolean = true) {
     val clipboard = getSystemService(Context.CLIPBOARD_SERVICE) as ClipboardManager
@@ -207,4 +249,4 @@ fun Context.shareText(text: String?) {
  * As of now, it is only checked when tied to an activity
  */
 inline val Context.isFinishing: Boolean
-    get() = (this as? Activity)?.isFinishing ?: false
\ No newline at end of file
+    get() = (this as? Activity)?.isFinishing ?: false
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/DrawableUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/DrawableUtils.kt
index 59e684a..6950f2f 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/DrawableUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/DrawableUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.res.ColorStateList
@@ -17,4 +32,4 @@ fun Drawable.tint(state: ColorStateList): Drawable {
     val drawable = DrawableCompat.wrap(mutate())
     DrawableCompat.setTintList(drawable, state)
     return drawable
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/FileUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/FileUtils.kt
index bfbc009..1d27bfc 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/FileUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/FileUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import java.io.File
@@ -6,4 +21,5 @@ import java.io.InputStream
 /**
  * Created by Allan Wang on 2017-08-04.
  */
-fun File.copyFromInputStream(inputStream: InputStream) = inputStream.use { input -> outputStream().use { output -> input.copyTo(output) } }
\ No newline at end of file
+fun File.copyFromInputStream(inputStream: InputStream) =
+    inputStream.use { input -> outputStream().use { output -> input.copyTo(output) } }
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/FontUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/FontUtils.kt
index 1db7694..064d70b 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/FontUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/FontUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.Context
@@ -14,17 +29,17 @@ object FontUtils {
         synchronized(sTypefaceCache) {
             if (!sTypefaceCache.containsKey(font)) {
                 val tf = Typeface.createFromAsset(
-                        context.applicationContext.assets, "fonts/$font.ttf")
+                    context.applicationContext.assets, "fonts/$font.ttf"
+                )
                 sTypefaceCache.put(font, tf)
             }
             return sTypefaceCache.get(font)
-                    ?: throw IllegalArgumentException("Font error; typeface does not exist at assets/fonts$font.ttf")
+                ?: throw IllegalArgumentException("Font error; typeface does not exist at assets/fonts$font.ttf")
         }
     }
 
     fun getName(typeface: Typeface): String? = sTypefaceCache.entries.firstOrNull { it.value == typeface }?.key
-
 }
 
 fun Context.getFont(font: String) = FontUtils.get(this, font)
-fun Context.getFontName(typeface: Typeface) = FontUtils.getName(typeface)
\ No newline at end of file
+fun Context.getFontName(typeface: Typeface) = FontUtils.getName(typeface)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/FragmentUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/FragmentUtils.kt
index f99b342..1c97900 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/FragmentUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/FragmentUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import androidx.fragment.app.Fragment
@@ -9,4 +24,4 @@ import org.jetbrains.anko.bundleOf
 fun <T : Fragment> T.withArguments(vararg params: Pair<String, Any>): T {
     arguments = bundleOf(*params)
     return this
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/IIconUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/IIconUtils.kt
index 66c56f8..8b40352 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/IIconUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/IIconUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.Context
@@ -12,10 +27,15 @@ import com.mikepenz.iconics.typeface.IIcon
  * Created by Allan Wang on 2017-05-29.
  */
 @KauUtils
-fun IIcon.toDrawable(c: Context, sizeDp: Int = 24, @ColorInt color: Int = Color.WHITE, builder: IconicsDrawable.() -> Unit = {}): Drawable {
+fun IIcon.toDrawable(
+    c: Context,
+    sizeDp: Int = 24,
+    @ColorInt color: Int = Color.WHITE,
+    builder: IconicsDrawable.() -> Unit = {}
+): Drawable {
     val state = ColorStateList.valueOf(color)
     val icon = IconicsDrawable(c).icon(this).color(state)
     if (sizeDp > 0) icon.sizeDp(sizeDp)
     icon.builder()
     return icon
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/Kotterknife.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/Kotterknife.kt
index 3cbd93d..1c22f62 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/Kotterknife.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/Kotterknife.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 @file:Suppress("UNCHECKED_CAST", "DEPRECATION")
 
 package ca.allanwang.kau.utils
@@ -21,107 +36,76 @@ import android.app.Fragment
 import android.view.View
 import androidx.recyclerview.widget.RecyclerView
 import androidx.recyclerview.widget.RecyclerView.ViewHolder
-import java.util.*
+import java.util.Collections
+import java.util.WeakHashMap
 import kotlin.properties.ReadOnlyProperty
 import kotlin.reflect.KProperty
 import androidx.fragment.app.DialogFragment as SupportDialogFragment
 import androidx.fragment.app.Fragment as SupportFragment
 
-fun <V : View> View.bindView(id: Int)
-        : ReadOnlyProperty<View, V> = required(id, viewFinder)
+fun <V : View> View.bindView(id: Int): ReadOnlyProperty<View, V> = required(id, viewFinder)
 
-fun <V : View> Activity.bindView(id: Int)
-        : ReadOnlyProperty<Activity, V> = required(id, viewFinder)
+fun <V : View> Activity.bindView(id: Int): ReadOnlyProperty<Activity, V> = required(id, viewFinder)
 
-fun <V : View> Dialog.bindView(id: Int)
-        : ReadOnlyProperty<Dialog, V> = required(id, viewFinder)
+fun <V : View> Dialog.bindView(id: Int): ReadOnlyProperty<Dialog, V> = required(id, viewFinder)
 
-fun <V : View> DialogFragment.bindView(id: Int)
-        : ReadOnlyProperty<DialogFragment, V> = required(id, viewFinder)
+fun <V : View> DialogFragment.bindView(id: Int): ReadOnlyProperty<DialogFragment, V> = required(id, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindView(id: Int)
-        : ReadOnlyProperty<SupportDialogFragment, V> = required(id, viewFinder)
+fun <V : View> SupportDialogFragment.bindView(id: Int): ReadOnlyProperty<SupportDialogFragment, V> = required(id, viewFinder)
 
-fun <V : View> Fragment.bindView(id: Int)
-        : ReadOnlyProperty<Fragment, V> = required(id, viewFinder)
+fun <V : View> Fragment.bindView(id: Int): ReadOnlyProperty<Fragment, V> = required(id, viewFinder)
 
-fun <V : View> SupportFragment.bindView(id: Int)
-        : ReadOnlyProperty<SupportFragment, V> = required(id, viewFinder)
+fun <V : View> SupportFragment.bindView(id: Int): ReadOnlyProperty<SupportFragment, V> = required(id, viewFinder)
 
-fun <V : View> RecyclerView.ViewHolder.bindView(id: Int)
-        : ReadOnlyProperty<RecyclerView.ViewHolder, V> = required(id, viewFinder)
+fun <V : View> RecyclerView.ViewHolder.bindView(id: Int): ReadOnlyProperty<RecyclerView.ViewHolder, V> = required(id, viewFinder)
 
-fun <V : View> View.bindOptionalView(id: Int)
-        : ReadOnlyProperty<View, V?> = optional(id, viewFinder)
+fun <V : View> View.bindOptionalView(id: Int): ReadOnlyProperty<View, V?> = optional(id, viewFinder)
 
-fun <V : View> Activity.bindOptionalView(id: Int)
-        : ReadOnlyProperty<Activity, V?> = optional(id, viewFinder)
+fun <V : View> Activity.bindOptionalView(id: Int): ReadOnlyProperty<Activity, V?> = optional(id, viewFinder)
 
-fun <V : View> Dialog.bindOptionalView(id: Int)
-        : ReadOnlyProperty<Dialog, V?> = optional(id, viewFinder)
+fun <V : View> Dialog.bindOptionalView(id: Int): ReadOnlyProperty<Dialog, V?> = optional(id, viewFinder)
 
-fun <V : View> DialogFragment.bindOptionalView(id: Int)
-        : ReadOnlyProperty<DialogFragment, V?> = optional(id, viewFinder)
+fun <V : View> DialogFragment.bindOptionalView(id: Int): ReadOnlyProperty<DialogFragment, V?> = optional(id, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindOptionalView(id: Int)
-        : ReadOnlyProperty<SupportDialogFragment, V?> = optional(id, viewFinder)
+fun <V : View> SupportDialogFragment.bindOptionalView(id: Int): ReadOnlyProperty<SupportDialogFragment, V?> = optional(id, viewFinder)
 
-fun <V : View> Fragment.bindOptionalView(id: Int)
-        : ReadOnlyProperty<Fragment, V?> = optional(id, viewFinder)
+fun <V : View> Fragment.bindOptionalView(id: Int): ReadOnlyProperty<Fragment, V?> = optional(id, viewFinder)
 
-fun <V : View> SupportFragment.bindOptionalView(id: Int)
-        : ReadOnlyProperty<SupportFragment, V?> = optional(id, viewFinder)
+fun <V : View> SupportFragment.bindOptionalView(id: Int): ReadOnlyProperty<SupportFragment, V?> = optional(id, viewFinder)
 
-fun <V : View> RecyclerView.ViewHolder.bindOptionalView(id: Int)
-        : ReadOnlyProperty<RecyclerView.ViewHolder, V?> = optional(id, viewFinder)
+fun <V : View> RecyclerView.ViewHolder.bindOptionalView(id: Int): ReadOnlyProperty<RecyclerView.ViewHolder, V?> = optional(id, viewFinder)
 
-fun <V : View> View.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<View, List<V>> = required(ids, viewFinder)
+fun <V : View> View.bindViews(vararg ids: Int): ReadOnlyProperty<View, List<V>> = required(ids, viewFinder)
 
-fun <V : View> Activity.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<Activity, List<V>> = required(ids, viewFinder)
+fun <V : View> Activity.bindViews(vararg ids: Int): ReadOnlyProperty<Activity, List<V>> = required(ids, viewFinder)
 
-fun <V : View> Dialog.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<Dialog, List<V>> = required(ids, viewFinder)
+fun <V : View> Dialog.bindViews(vararg ids: Int): ReadOnlyProperty<Dialog, List<V>> = required(ids, viewFinder)
 
-fun <V : View> DialogFragment.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<DialogFragment, List<V>> = required(ids, viewFinder)
+fun <V : View> DialogFragment.bindViews(vararg ids: Int): ReadOnlyProperty<DialogFragment, List<V>> = required(ids, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<SupportDialogFragment, List<V>> = required(ids, viewFinder)
+fun <V : View> SupportDialogFragment.bindViews(vararg ids: Int): ReadOnlyProperty<SupportDialogFragment, List<V>> = required(ids, viewFinder)
 
-fun <V : View> Fragment.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<Fragment, List<V>> = required(ids, viewFinder)
+fun <V : View> Fragment.bindViews(vararg ids: Int): ReadOnlyProperty<Fragment, List<V>> = required(ids, viewFinder)
 
-fun <V : View> SupportFragment.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<SupportFragment, List<V>> = required(ids, viewFinder)
+fun <V : View> SupportFragment.bindViews(vararg ids: Int): ReadOnlyProperty<SupportFragment, List<V>> = required(ids, viewFinder)
 
-fun <V : View> ViewHolder.bindViews(vararg ids: Int)
-        : ReadOnlyProperty<ViewHolder, List<V>> = required(ids, viewFinder)
+fun <V : View> ViewHolder.bindViews(vararg ids: Int): ReadOnlyProperty<ViewHolder, List<V>> = required(ids, viewFinder)
 
-fun <V : View> View.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<View, List<V>> = optional(ids, viewFinder)
+fun <V : View> View.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<View, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> Activity.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<Activity, List<V>> = optional(ids, viewFinder)
+fun <V : View> Activity.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<Activity, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> Dialog.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<Dialog, List<V>> = optional(ids, viewFinder)
+fun <V : View> Dialog.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<Dialog, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> DialogFragment.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<DialogFragment, List<V>> = optional(ids, viewFinder)
+fun <V : View> DialogFragment.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<DialogFragment, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<SupportDialogFragment, List<V>> = optional(ids, viewFinder)
+fun <V : View> SupportDialogFragment.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<SupportDialogFragment, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> Fragment.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<Fragment, List<V>> = optional(ids, viewFinder)
+fun <V : View> Fragment.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<Fragment, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> SupportFragment.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<SupportFragment, List<V>> = optional(ids, viewFinder)
+fun <V : View> SupportFragment.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<SupportFragment, List<V>> = optional(ids, viewFinder)
 
-fun <V : View> ViewHolder.bindOptionalViews(vararg ids: Int)
-        : ReadOnlyProperty<ViewHolder, List<V>> = optional(ids, viewFinder)
+fun <V : View> ViewHolder.bindOptionalViews(vararg ids: Int): ReadOnlyProperty<ViewHolder, List<V>> = optional(ids, viewFinder)
 
 private inline val View.viewFinder: View.(Int) -> View?
     get() = { findViewById(it) }
@@ -141,7 +125,7 @@ private inline val ViewHolder.viewFinder: ViewHolder.(Int) -> View?
     get() = { itemView.findViewById(it) }
 
 private fun viewNotFound(id: Int, desc: KProperty<*>): Nothing =
-        throw IllegalStateException("View ID $id for '${desc.name}' not found.")
+    throw IllegalStateException("View ID $id for '${desc.name}' not found.")
 
 private fun <T, V : View> required(id: Int, finder: T.(Int) -> View?) = Lazy { t: T, desc ->
     (t.finder(id) as V?)?.apply { } ?: viewNotFound(id, desc)
@@ -155,19 +139,20 @@ private fun <T, V : View> required(ids: IntArray, finder: T.(Int) -> View?) = La
     }
 }
 
-private fun <T, V : View> optional(ids: IntArray, finder: T.(Int) -> View?) = Lazy { t: T, _ -> ids.map { t.finder(it) as V? }.filterNotNull() }
+private fun <T, V : View> optional(ids: IntArray, finder: T.(Int) -> View?) =
+    Lazy { t: T, _ -> ids.map { t.finder(it) as V? }.filterNotNull() }
 
 // Like Kotlin's lazy delegate but the initializer gets the target and metadata passed to it
 private open class Lazy<in T, out V>(private val initializer: (T, KProperty<*>) -> V) : ReadOnlyProperty<T, V> {
     protected object EMPTY
 
-protected var value: Any? = EMPTY
+    protected var value: Any? = EMPTY
 
-override fun getValue(thisRef: T, property: KProperty<*>): V {
+    override fun getValue(thisRef: T, property: KProperty<*>): V {
         if (value == EMPTY)
             value = initializer(thisRef, property)
 
-return value as V
+        return value as V
     }
 }
 
@@ -181,107 +166,76 @@ return value as V
  * Credits to <a href="https://github.com/MichaelRocks">MichaelRocks</a>
  */
 
-fun <V : View> View.bindViewResettable(id: Int)
-        : ReadOnlyProperty<View, V> = requiredResettable(id, viewFinder)
+fun <V : View> View.bindViewResettable(id: Int): ReadOnlyProperty<View, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> Activity.bindViewResettable(id: Int)
-        : ReadOnlyProperty<Activity, V> = requiredResettable(id, viewFinder)
+fun <V : View> Activity.bindViewResettable(id: Int): ReadOnlyProperty<Activity, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> Dialog.bindViewResettable(id: Int)
-        : ReadOnlyProperty<Dialog, V> = requiredResettable(id, viewFinder)
+fun <V : View> Dialog.bindViewResettable(id: Int): ReadOnlyProperty<Dialog, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> DialogFragment.bindViewResettable(id: Int)
-        : ReadOnlyProperty<DialogFragment, V> = requiredResettable(id, viewFinder)
+fun <V : View> DialogFragment.bindViewResettable(id: Int): ReadOnlyProperty<DialogFragment, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindViewResettable(id: Int)
-        : ReadOnlyProperty<SupportDialogFragment, V> = requiredResettable(id, viewFinder)
+fun <V : View> SupportDialogFragment.bindViewResettable(id: Int): ReadOnlyProperty<SupportDialogFragment, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> Fragment.bindViewResettable(id: Int)
-        : ReadOnlyProperty<Fragment, V> = requiredResettable(id, viewFinder)
+fun <V : View> Fragment.bindViewResettable(id: Int): ReadOnlyProperty<Fragment, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> SupportFragment.bindViewResettable(id: Int)
-        : ReadOnlyProperty<SupportFragment, V> = requiredResettable(id, viewFinder)
+fun <V : View> SupportFragment.bindViewResettable(id: Int): ReadOnlyProperty<SupportFragment, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> ViewHolder.bindViewResettable(id: Int)
-        : ReadOnlyProperty<ViewHolder, V> = requiredResettable(id, viewFinder)
+fun <V : View> ViewHolder.bindViewResettable(id: Int): ReadOnlyProperty<ViewHolder, V> = requiredResettable(id, viewFinder)
 
-fun <V : View> View.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<View, V?> = optionalResettable(id, viewFinder)
+fun <V : View> View.bindOptionalViewResettable(id: Int): ReadOnlyProperty<View, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> Activity.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<Activity, V?> = optionalResettable(id, viewFinder)
+fun <V : View> Activity.bindOptionalViewResettable(id: Int): ReadOnlyProperty<Activity, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> Dialog.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<Dialog, V?> = optionalResettable(id, viewFinder)
+fun <V : View> Dialog.bindOptionalViewResettable(id: Int): ReadOnlyProperty<Dialog, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> DialogFragment.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<DialogFragment, V?> = optionalResettable(id, viewFinder)
+fun <V : View> DialogFragment.bindOptionalViewResettable(id: Int): ReadOnlyProperty<DialogFragment, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<SupportDialogFragment, V?> = optionalResettable(id, viewFinder)
+fun <V : View> SupportDialogFragment.bindOptionalViewResettable(id: Int): ReadOnlyProperty<SupportDialogFragment, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> Fragment.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<Fragment, V?> = optionalResettable(id, viewFinder)
+fun <V : View> Fragment.bindOptionalViewResettable(id: Int): ReadOnlyProperty<Fragment, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> SupportFragment.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<SupportFragment, V?> = optionalResettable(id, viewFinder)
+fun <V : View> SupportFragment.bindOptionalViewResettable(id: Int): ReadOnlyProperty<SupportFragment, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> ViewHolder.bindOptionalViewResettable(id: Int)
-        : ReadOnlyProperty<ViewHolder, V?> = optionalResettable(id, viewFinder)
+fun <V : View> ViewHolder.bindOptionalViewResettable(id: Int): ReadOnlyProperty<ViewHolder, V?> = optionalResettable(id, viewFinder)
 
-fun <V : View> View.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<View, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> View.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<View, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> Activity.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Activity, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> Activity.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<Activity, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> Dialog.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Dialog, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> Dialog.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<Dialog, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> DialogFragment.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<DialogFragment, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> DialogFragment.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<DialogFragment, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<SupportDialogFragment, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> SupportDialogFragment.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<SupportDialogFragment, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> Fragment.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Fragment, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> Fragment.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<Fragment, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> SupportFragment.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<SupportFragment, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> SupportFragment.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<SupportFragment, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> ViewHolder.bindViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<ViewHolder, List<V>> = requiredResettable(ids, viewFinder)
+fun <V : View> ViewHolder.bindViewsResettable(vararg ids: Int): ReadOnlyProperty<ViewHolder, List<V>> = requiredResettable(ids, viewFinder)
 
-fun <V : View> View.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<View, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> View.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<View, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> Activity.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Activity, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> Activity.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<Activity, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> Dialog.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Dialog, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> Dialog.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<Dialog, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> DialogFragment.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<DialogFragment, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> DialogFragment.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<DialogFragment, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> SupportDialogFragment.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<SupportDialogFragment, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> SupportDialogFragment.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<SupportDialogFragment, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> Fragment.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<Fragment, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> Fragment.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<Fragment, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> SupportFragment.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<SupportFragment, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> SupportFragment.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<SupportFragment, List<V>> = optionalResettable(ids, viewFinder)
 
-fun <V : View> ViewHolder.bindOptionalViewsResettable(vararg ids: Int)
-        : ReadOnlyProperty<RecyclerView.ViewHolder, List<V>> = optionalResettable(ids, viewFinder)
+fun <V : View> ViewHolder.bindOptionalViewsResettable(vararg ids: Int): ReadOnlyProperty<RecyclerView.ViewHolder, List<V>> = optionalResettable(ids, viewFinder)
 
 private fun <T, V : View> requiredResettable(id: Int, finder: T.(Int) -> View?) = LazyResettable { t: T, desc ->
     (t.finder(id) as V?)?.apply { } ?: viewNotFound(id, desc)
 }
 
-private fun <T, V : View> optionalResettable(id: Int, finder: T.(Int) -> View?) = LazyResettable { t: T, _ -> t.finder(id) as V? }
+private fun <T, V : View> optionalResettable(id: Int, finder: T.(Int) -> View?) =
+    LazyResettable { t: T, _ -> t.finder(id) as V? }
 
 private fun <T, V : View> requiredResettable(ids: IntArray, finder: T.(Int) -> View?) = LazyResettable { t: T, desc ->
     ids.map {
@@ -289,7 +243,8 @@ private fun <T, V : View> requiredResettable(ids: IntArray, finder: T.(Int) -> V
     }
 }
 
-private fun <T, V : View> optionalResettable(ids: IntArray, finder: T.(Int) -> View?) = LazyResettable { t: T, _ -> ids.map { t.finder(it) as V? }.filterNotNull() }
+private fun <T, V : View> optionalResettable(ids: IntArray, finder: T.(Int) -> View?) =
+    LazyResettable { t: T, _ -> ids.map { t.finder(it) as V? }.filterNotNull() }
 
 //Like Kotterknife's lazy delegate but is resettable
 private class LazyResettable<in T, out V>(initializer: (T, KProperty<*>) -> V) : Lazy<T, V>(initializer) {
@@ -298,7 +253,7 @@ private class LazyResettable<in T, out V>(initializer: (T, KProperty<*>) -> V) :
         return super.getValue(thisRef, property)
     }
 
-fun reset() {
+    fun reset() {
         value = EMPTY
     }
 }
@@ -312,7 +267,8 @@ object Kotterknife {
 private object KotterknifeRegistry {
     private val lazyMap = WeakHashMap<Any, MutableCollection<LazyResettable<*, *>>>()
 
-fun register(target: Any, lazy: LazyResettable<*, *>) = lazyMap.getOrPut(target, { Collections.newSetFromMap(WeakHashMap()) }).add(lazy)
+    fun register(target: Any, lazy: LazyResettable<*, *>) =
+        lazyMap.getOrPut(target, { Collections.newSetFromMap(WeakHashMap()) }).add(lazy)
 
-fun reset(target: Any) = lazyMap[target]?.forEach(LazyResettable<*, *>::reset)
-}
\ No newline at end of file
+    fun reset(target: Any) = lazyMap[target]?.forEach(LazyResettable<*, *>::reset)
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/NetworkUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/NetworkUtils.kt
index 2271c16..260e90f 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/NetworkUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/NetworkUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.annotation.SuppressLint
@@ -29,4 +44,4 @@ inline val Context.isMobileDataConnected: Boolean
         val connectivityManager = getSystemService(Context.CONNECTIVITY_SERVICE) as ConnectivityManager
         val activeNetworkInfo = connectivityManager.activeNetworkInfo
         return (activeNetworkInfo?.type ?: -1) == ConnectivityManager.TYPE_MOBILE
-    }
\ No newline at end of file
+    }
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/NotificationUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/NotificationUtils.kt
index 016f3d2..126b133 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/NotificationUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/NotificationUtils.kt
@@ -1,10 +1,24 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.Context
 import androidx.core.app.NotificationManagerCompat
 
-
 /**
  * Created by Allan Wang on 2017-08-04.
  */
-fun Context.cancelNotification(notifId: Int) = NotificationManagerCompat.from(this).cancel(notifId)
\ No newline at end of file
+fun Context.cancelNotification(notifId: Int) = NotificationManagerCompat.from(this).cancel(notifId)
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/PackageUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/PackageUtils.kt
index 77750d3..4055847 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/PackageUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/PackageUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.ActivityNotFoundException
@@ -70,4 +85,4 @@ inline val Context.isFromGooglePlay: Boolean
     get() {
         val installer = installerPackageName
         return arrayOf(INSTALLER_GOOGLE_PLAY_FEEDBACK, INSTALLER_GOOGLE_PLAY_VENDING).any { it == installer }
-    }
\ No newline at end of file
+    }
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/RecyclerUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/RecyclerUtils.kt
index 1c336f9..11494b3 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/RecyclerUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/RecyclerUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.graphics.Rect
@@ -22,4 +37,4 @@ class MarginItemDecoration(sizeDp: Int, val edgeFlags: Int) : RecyclerView.ItemD
         if (edgeFlags and KAU_RIGHT > 0) outRect.right += sizePx
         if (edgeFlags and KAU_BOTTOM > 0) outRect.bottom += sizePx
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/TransitionUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/TransitionUtils.kt
index 1d12fd3..523a586 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/TransitionUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/TransitionUtils.kt
@@ -1,13 +1,28 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.os.Build
+import android.transition.Transition
+import android.view.ViewGroup
 import androidx.annotation.RequiresApi
 import androidx.annotation.TransitionRes
 import androidx.transition.AutoTransition
 import androidx.transition.TransitionInflater
 import androidx.transition.TransitionManager
-import android.transition.Transition
-import android.view.ViewGroup
 import androidx.transition.Transition as SupportTransition
 
 /**
@@ -29,7 +44,8 @@ fun Transition.addEndListener(onEnd: (transition: Transition) -> Unit) {
 }
 
 @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
-class SupportTransitionEndListener(val onEnd: (transition: SupportTransition) -> Unit) : SupportTransition.TransitionListener {
+class SupportTransitionEndListener(val onEnd: (transition: SupportTransition) -> Unit) :
+    SupportTransition.TransitionListener {
     override fun onTransitionEnd(transition: SupportTransition) = onEnd(transition)
     override fun onTransitionResume(transition: SupportTransition) {}
     override fun onTransitionPause(transition: SupportTransition) {}
@@ -57,4 +73,4 @@ fun ViewGroup.transitionDelayed(@TransitionRes id: Int, builder: androidx.transi
     val transition = TransitionInflater.from(context).inflateTransition(id)
     transition.builder()
     TransitionManager.beginDelayedTransition(this, transition)
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/Utils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/Utils.kt
index c8d5d2a..da4feb8 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/Utils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/Utils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.content.Context
@@ -13,7 +28,6 @@ import ca.allanwang.kau.R
 import java.math.RoundingMode
 import java.text.DecimalFormat
 
-
 /**
  * Created by Allan Wang on 2017-05-28.
  */
@@ -132,5 +146,5 @@ inline val kauIsMainThread: Boolean
 class KauException(message: String) : RuntimeException(message)
 
 fun String.withMaxLength(n: Int): String =
-        if (length <= n) this
-        else substring(0, n - 1) + KAU_ELLIPSIS
\ No newline at end of file
+    if (length <= n) this
+    else substring(0, n - 1) + KAU_ELLIPSIS
diff --git a/core/src/main/kotlin/ca/allanwang/kau/utils/ViewUtils.kt b/core/src/main/kotlin/ca/allanwang/kau/utils/ViewUtils.kt
index 956df48..186d125 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/utils/ViewUtils.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/utils/ViewUtils.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 @file:Suppress("NOTHING_TO_INLINE")
 
 package ca.allanwang.kau.utils
@@ -7,10 +22,6 @@ import android.annotation.SuppressLint
 import android.content.Context
 import android.graphics.Color
 import android.os.Build
-import androidx.annotation.ColorInt
-import androidx.annotation.ColorRes
-import androidx.annotation.RequiresApi
-import androidx.annotation.StringRes
 import android.view.LayoutInflater
 import android.view.MotionEvent
 import android.view.View
@@ -18,6 +29,10 @@ import android.view.ViewGroup
 import android.view.inputmethod.InputMethodManager
 import android.widget.EditText
 import android.widget.ImageView
+import androidx.annotation.ColorInt
+import androidx.annotation.ColorRes
+import androidx.annotation.RequiresApi
+import androidx.annotation.StringRes
 import androidx.recyclerview.widget.LinearLayoutManager
 import androidx.recyclerview.widget.RecyclerView
 import ca.allanwang.kau.ui.createSimpleRippleDrawable
@@ -27,7 +42,6 @@ import com.google.android.material.textfield.TextInputEditText
 import com.mikepenz.iconics.IconicsDrawable
 import com.mikepenz.iconics.typeface.IIcon
 
-
 /**
  * Created by Allan Wang on 2017-05-31.
  */
@@ -81,10 +95,16 @@ fun View.snackbar(text: String, duration: Int = Snackbar.LENGTH_LONG, builder: S
     return snackbar
 }
 
-fun View.snackbar(@StringRes textId: Int, duration: Int = Snackbar.LENGTH_LONG, builder: Snackbar.() -> Unit = {}) = snackbar(context.string(textId), duration, builder)
+fun View.snackbar(@StringRes textId: Int, duration: Int = Snackbar.LENGTH_LONG, builder: Snackbar.() -> Unit = {}) =
+    snackbar(context.string(textId), duration, builder)
 
 @KauUtils
-fun ImageView.setIcon(icon: IIcon?, sizeDp: Int = 24, @ColorInt color: Int = Color.WHITE, builder: IconicsDrawable.() -> Unit = {}) {
+fun ImageView.setIcon(
+    icon: IIcon?,
+    sizeDp: Int = 24,
+    @ColorInt color: Int = Color.WHITE,
+    builder: IconicsDrawable.() -> Unit = {}
+) {
     if (icon == null) return
     setImageDrawable(icon.toDrawable(context, sizeDp = sizeDp, color = color, builder = builder))
 }
@@ -98,7 +118,8 @@ fun FloatingActionButton.showIf(show: Boolean) = if (show) show() else hide()
 fun FloatingActionButton.hideIf(hide: Boolean) = if (hide) hide() else show()
 
 @KauUtils
-fun ViewGroup.inflate(layoutId: Int, attachToRoot: Boolean = false): View = LayoutInflater.from(context).inflate(layoutId, this, attachToRoot)
+fun ViewGroup.inflate(layoutId: Int, attachToRoot: Boolean = false): View =
+    LayoutInflater.from(context).inflate(layoutId, this, attachToRoot)
 
 /**
  * Set left margin to a value in px
@@ -150,10 +171,10 @@ fun View.setMargin(margin: Int) = setMargins(margin, KAU_ALL)
 private fun View.setMargins(margin: Int, flag: Int): Boolean {
     val p = (layoutParams as? ViewGroup.MarginLayoutParams) ?: return false
     p.setMargins(
-            if (flag and KAU_LEFT > 0) margin else p.leftMargin,
-            if (flag and KAU_TOP > 0) margin else p.topMargin,
-            if (flag and KAU_RIGHT > 0) margin else p.rightMargin,
-            if (flag and KAU_BOTTOM > 0) margin else p.bottomMargin
+        if (flag and KAU_LEFT > 0) margin else p.leftMargin,
+        if (flag and KAU_TOP > 0) margin else p.topMargin,
+        if (flag and KAU_RIGHT > 0) margin else p.rightMargin,
+        if (flag and KAU_BOTTOM > 0) margin else p.bottomMargin
     )
     return true
 }
@@ -206,26 +227,31 @@ fun View.setPadding(padding: Int) = setPadding(padding, KAU_ALL)
 @KauUtils
 private fun View.setPadding(padding: Int, flag: Int) {
     setPadding(
-            if (flag and KAU_LEFT > 0) padding else paddingLeft,
-            if (flag and KAU_TOP > 0) padding else paddingTop,
-            if (flag and KAU_RIGHT > 0) padding else paddingRight,
-            if (flag and KAU_BOTTOM > 0) padding else paddingBottom
+        if (flag and KAU_LEFT > 0) padding else paddingLeft,
+        if (flag and KAU_TOP > 0) padding else paddingTop,
+        if (flag and KAU_RIGHT > 0) padding else paddingRight,
+        if (flag and KAU_BOTTOM > 0) padding else paddingBottom
     )
 }
 
 @KauUtils
 fun View.hideKeyboard() {
     clearFocus()
-    (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).hideSoftInputFromWindow(windowToken, 0)
+    (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).hideSoftInputFromWindow(
+        windowToken,
+        0
+    )
 }
 
 @KauUtils
 fun View.showKeyboard() {
     requestFocus()
-    (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).showSoftInput(this, InputMethodManager.SHOW_IMPLICIT)
+    (context.getSystemService(Context.INPUT_METHOD_SERVICE) as InputMethodManager).showSoftInput(
+        this,
+        InputMethodManager.SHOW_IMPLICIT
+    )
 }
 
-
 @RequiresApi(Build.VERSION_CODES.LOLLIPOP)
 @KauUtils
 fun View.setRippleBackground(@ColorInt foregroundColor: Int, @ColorInt backgroundColor: Int) {
@@ -243,12 +269,14 @@ inline val TextInputEditText.value: String get() = text.toString().trim()
 /**
  * Generates a recycler view with match parent and a linearlayoutmanager, since it's so commonly used
  */
-fun Context.fullLinearRecycler(rvAdapter: RecyclerView.Adapter<*>? = null, configs: RecyclerView.() -> Unit = {}) = RecyclerView(this).apply {
-    layoutManager = LinearLayoutManager(this@fullLinearRecycler)
-    layoutParams = RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT, RecyclerView.LayoutParams.MATCH_PARENT)
-    if (rvAdapter != null) adapter = rvAdapter
-    configs()
-}
+fun Context.fullLinearRecycler(rvAdapter: RecyclerView.Adapter<*>? = null, configs: RecyclerView.() -> Unit = {}) =
+    RecyclerView(this).apply {
+        layoutManager = LinearLayoutManager(this@fullLinearRecycler)
+        layoutParams =
+            RecyclerView.LayoutParams(RecyclerView.LayoutParams.MATCH_PARENT, RecyclerView.LayoutParams.MATCH_PARENT)
+        if (rvAdapter != null) adapter = rvAdapter
+        configs()
+    }
 
 /**
  * Sets a linear layout manager along with an adapter
@@ -263,7 +291,11 @@ fun RecyclerView.withLinearAdapter(rvAdapter: RecyclerView.Adapter<*>) = apply {
  * If it is not shown, the action will be invoked directly and no further actions will be made
  * If it is already shown, scaling and alpha animations will be added to the action
  */
-inline fun <T : ImageView> T.fadeScaleTransition(duration: Long = 500L, minScale: Float = 0.7f, crossinline action: T.() -> Unit) {
+inline fun <T : ImageView> T.fadeScaleTransition(
+    duration: Long = 500L,
+    minScale: Float = 0.7f,
+    crossinline action: T.() -> Unit
+) {
     if (!isVisible) action()
     else {
         var transitioned = false
@@ -324,4 +356,4 @@ inline fun View.setOnSingleTapListener(crossinline onSingleTap: (v: View, event:
             else -> false
         }
     }
-}
\ No newline at end of file
+}
diff --git a/core/src/main/kotlin/ca/allanwang/kau/xml/Changelog.kt b/core/src/main/kotlin/ca/allanwang/kau/xml/Changelog.kt
index 3955a77..6a75aa9 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/xml/Changelog.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/xml/Changelog.kt
@@ -1,14 +1,29 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.xml
 
 import android.content.Context
 import android.content.res.XmlResourceParser
-import androidx.annotation.ColorInt
-import androidx.annotation.LayoutRes
-import androidx.annotation.XmlRes
 import android.view.LayoutInflater
 import android.view.View
 import android.view.ViewGroup
 import android.widget.TextView
+import androidx.annotation.ColorInt
+import androidx.annotation.LayoutRes
+import androidx.annotation.XmlRes
 import androidx.recyclerview.widget.RecyclerView
 import ca.allanwang.kau.R
 import ca.allanwang.kau.utils.materialDialog
@@ -18,7 +33,6 @@ import org.jetbrains.anko.doAsync
 import org.jetbrains.anko.uiThread
 import org.xmlpull.v1.XmlPullParser
 
-
 /**
  * Created by Allan Wang on 2017-05-28.
  *
@@ -42,10 +56,13 @@ fun Context.showChangelog(@XmlRes xmlRes: Int, @ColorInt textColor: Int? = null,
  * Internals of the changelog dialog
  * Contains an mainAdapter for each item, as well as the tags to parse
  */
-internal class ChangelogAdapter(val items: List<Pair<String, ChangelogType>>, @ColorInt val textColor: Int? = null) : RecyclerView.Adapter<ChangelogAdapter.ChangelogVH>() {
+internal class ChangelogAdapter(val items: List<Pair<String, ChangelogType>>, @ColorInt val textColor: Int? = null) :
+    RecyclerView.Adapter<ChangelogAdapter.ChangelogVH>() {
 
-    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ChangelogVH(LayoutInflater.from(parent.context)
-            .inflate(items[viewType].second.layout, parent, false))
+    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int) = ChangelogVH(
+        LayoutInflater.from(parent.context)
+            .inflate(items[viewType].second.layout, parent, false)
+    )
 
     override fun onBindViewHolder(holder: ChangelogVH, position: Int) {
         holder.text.text = items[position].first
@@ -98,4 +115,3 @@ internal enum class ChangelogType(val tag: String, val attr: String, @LayoutRes
         return true
     }
 }
-
diff --git a/core/src/main/kotlin/ca/allanwang/kau/xml/FAQ.kt b/core/src/main/kotlin/ca/allanwang/kau/xml/FAQ.kt
index bbe9425..cb57216 100644
--- a/core/src/main/kotlin/ca/allanwang/kau/xml/FAQ.kt
+++ b/core/src/main/kotlin/ca/allanwang/kau/xml/FAQ.kt
@@ -1,10 +1,25 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.xml
 
 import android.content.Context
 import android.content.res.XmlResourceParser
-import androidx.annotation.XmlRes
 import android.text.Html
 import android.text.Spanned
+import androidx.annotation.XmlRes
 import ca.allanwang.kau.utils.use
 import org.jetbrains.anko.doAsync
 import org.jetbrains.anko.uiThread
@@ -20,12 +35,13 @@ import org.xmlpull.v1.XmlPullParser
  */
 @Suppress("DEPRECATION")
 fun Context.kauParseFaq(
-        @XmlRes xmlRes: Int,
-        /**
-         * If \n is used, it will automatically be converted to </br>
-         */
-        parseNewLine: Boolean = true,
-        callback: (items: List<FaqItem>) -> Unit) {
+    @XmlRes xmlRes: Int,
+    /**
+     * If \n is used, it will automatically be converted to </br>
+     */
+    parseNewLine: Boolean = true,
+    callback: (items: List<FaqItem>) -> Unit
+) {
     doAsync {
         val items = mutableListOf<FaqItem>()
         resources.getXml(xmlRes).use { parser: XmlResourceParser ->
@@ -46,10 +62,14 @@ fun Context.kauParseFaq(
                             flag = -1
                         }
                         1 -> {
-                            items.add(FaqItem(items.size + 1,
+                            items.add(
+                                FaqItem(
+                                    items.size + 1,
                                     question
-                                            ?: throw IllegalArgumentException("KAU FAQ answer found without a question"),
-                                    Html.fromHtml(parser.text.replace("\n", if (parseNewLine) "<br/>" else ""))))
+                                        ?: throw IllegalArgumentException("KAU FAQ answer found without a question"),
+                                    Html.fromHtml(parser.text.replace("\n", if (parseNewLine) "<br/>" else ""))
+                                )
+                            )
                             question = null
                             flag = -1
                         }
@@ -62,4 +82,4 @@ fun Context.kauParseFaq(
     }
 }
 
-data class FaqItem(val number: Int, val question: Spanned, val answer: Spanned)
\ No newline at end of file
+data class FaqItem(val number: Int, val question: Spanned, val answer: Spanned)
diff --git a/core/src/test/kotlin/ca/allanwang/kau/kotlin/DebounceTest.kt b/core/src/test/kotlin/ca/allanwang/kau/kotlin/DebounceTest.kt
index 8ccdab3..c406901 100644
--- a/core/src/test/kotlin/ca/allanwang/kau/kotlin/DebounceTest.kt
+++ b/core/src/test/kotlin/ca/allanwang/kau/kotlin/DebounceTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import org.junit.Test
@@ -48,5 +63,4 @@ class DebounceTest {
         Thread.sleep(30)
         assertEquals(10, i)
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/test/kotlin/ca/allanwang/kau/kotlin/LazyResettableTest.kt b/core/src/test/kotlin/ca/allanwang/kau/kotlin/LazyResettableTest.kt
index 2025422..eaaaacb 100644
--- a/core/src/test/kotlin/ca/allanwang/kau/kotlin/LazyResettableTest.kt
+++ b/core/src/test/kotlin/ca/allanwang/kau/kotlin/LazyResettableTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import org.junit.Before
@@ -33,5 +48,4 @@ class LazyResettableTest {
         assertEquals(t1, t2, "Lazy resettable not returning same value after second call")
         assertNotEquals(t1, t3, "Lazy resettable not invalidated by registry")
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/test/kotlin/ca/allanwang/kau/kotlin/StreamsTest.kt b/core/src/test/kotlin/ca/allanwang/kau/kotlin/StreamsTest.kt
index 1c40f57..4dc4a34 100644
--- a/core/src/test/kotlin/ca/allanwang/kau/kotlin/StreamsTest.kt
+++ b/core/src/test/kotlin/ca/allanwang/kau/kotlin/StreamsTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import org.junit.Test
@@ -38,5 +53,4 @@ class StreamsTest {
         items.kauRemoveIf { it == thePotato } //removal by equality
         assertEquals(result.size - 1, items.size, "Invalid list removal based on equality")
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/test/kotlin/ca/allanwang/kau/kotlin/ZipTest.kt b/core/src/test/kotlin/ca/allanwang/kau/kotlin/ZipTest.kt
index 7eeffaf..1fbc38f 100644
--- a/core/src/test/kotlin/ca/allanwang/kau/kotlin/ZipTest.kt
+++ b/core/src/test/kotlin/ca/allanwang/kau/kotlin/ZipTest.kt
@@ -1,8 +1,23 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.kotlin
 
 import org.jetbrains.anko.doAsync
 import org.junit.Test
-import java.util.*
+import java.util.Random
 import java.util.concurrent.CountDownLatch
 import java.util.concurrent.TimeUnit
 import kotlin.test.assertTrue
@@ -40,7 +55,6 @@ class ZipTest {
             assertTrue((0..10).toList().toTypedArray().contentEquals(results), "Basic zip results do not match")
             assertTrue(finish - start < 1000L, "Basic zip does not seem to be running asynchronously")
             latch.countDown()
-
         }
         latch.await(1100, TimeUnit.MILLISECONDS)
     }
@@ -66,5 +80,4 @@ class ZipTest {
         }
         latch.await(1100, TimeUnit.MILLISECONDS)
     }
-
-}
\ No newline at end of file
+}
diff --git a/core/src/test/kotlin/ca/allanwang/kau/utils/UtilsTest.kt b/core/src/test/kotlin/ca/allanwang/kau/utils/UtilsTest.kt
index ce2b757..1cce9ae 100644
--- a/core/src/test/kotlin/ca/allanwang/kau/utils/UtilsTest.kt
+++ b/core/src/test/kotlin/ca/allanwang/kau/utils/UtilsTest.kt
@@ -1,3 +1,18 @@
+/*
+ * Copyright 2018 Allan Wang
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ *     http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
 package ca.allanwang.kau.utils
 
 import android.graphics.Color
@@ -22,4 +37,4 @@ class UtilsTest {
         assertEquals("22.466", 22.465920439.round(3))
         assertEquals("22", 22f.round(3))
     }
-}
\ No newline at end of file
+}