Remove Observables from Views

commit 6bb74ca5201cba2fc5de2db349bb7627c028b617
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Sun May 27 15:15:27 2018 -0400

    Fix crash when tapping on selected contact

commit f5a45e2a600a8d373160dcb0273bab232e6cc0c5
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Sun May 27 15:10:44 2018 -0400

    Add missing attributes for dialog themes

commit 2188adbe5948b9b71f816dad5fb115829ba57e30
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Sun May 27 14:59:39 2018 -0400

    Refresh settings activity when theme changed

commit a9541019c566a3a6e41e64ea8136f7fd50a6d364
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Sun May 27 14:56:33 2018 -0400

    Don't use themed attributes in widget

commit 4823a3034848efac624eb82856f692c7f9e775a5
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Sun May 27 14:29:00 2018 -0400

    Refresh adapter in conversation info when theme changed

commit 7ea5837b99c2b6eac547dad383515ee7b79ff6e4
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Fri May 25 18:27:08 2018 -0400

    Bundle theme colors into data class

commit 6a832fdde98622c5a252aca0cac3150a6eb0f554
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Fri May 25 17:16:21 2018 -0400

    Update conversation UI when theme changed

commit ef6948e80ed8734a7fefbec1b00f1b32e8209072
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Fri May 25 16:15:39 2018 -0400

    Fix avatar not respecting theme

commit 4ea21b6a9963f91d3b9cdaf0ba4749a6f24e8a74
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Fri May 25 15:52:40 2018 -0400

    Fix checkmark color in theme picker

commit 270a9d3037439f165a110c7d7dcaf7dd84dad29f
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Fri May 25 13:39:12 2018 -0400

    Update views in MainActivity when theme changed

commit cdc1187ccaee800e4305da5fab5d22220d04440f
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Thu May 24 23:36:17 2018 -0400

    Remove unnecessary programmatic creation of drawer item background

commit bc6fbfa75c66bb81db9591617f8c1de4c0f2746f
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Thu May 24 23:28:44 2018 -0400

    Temporarily disable RxJava2Debug

commit eae422be0bab8cedb3cb5ddf5f4ae61368ab5d1e
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Thu May 24 21:16:46 2018 -0400

    Remove observable usage inside of custom views

commit 2e65d55b9b283e74fb395d4828eb310395b4902b
Author: Moez Bhatti <moez.bhatti@gmail.com>
Date:   Thu May 24 02:27:26 2018 -0400

    Migrate ripple and text size to no longer use observables
This commit is contained in:
Moez Bhatti
2018-05-27 15:49:02 -04:00
parent e94296a5a4
commit 472a36ec3b
82 changed files with 752 additions and 1253 deletions
+41 -223
View File
@@ -18,15 +18,11 @@
*/
package common.util
import android.annotation.SuppressLint
import android.content.Context
import android.graphics.Color
import android.os.Build
import android.support.annotation.ColorRes
import android.view.View
import com.moez.QKSMS.R
import common.util.extensions.getColorCompat
import io.reactivex.Observable
import io.reactivex.rxkotlin.Observables
import util.Preferences
import javax.inject.Inject
import javax.inject.Singleton
@@ -34,6 +30,13 @@ import javax.inject.Singleton
@Singleton
class Colors @Inject constructor(private val context: Context, private val prefs: Preferences) {
data class Theme(val theme: Int, private val colors: Colors) {
val highlight by lazy { colors.highlightColorForTheme(theme) }
val textPrimary by lazy { colors.textPrimaryOnThemeForColor(theme) }
val textSecondary by lazy { colors.textSecondaryOnThemeForColor(theme) }
val textTertiary by lazy { colors.textTertiaryOnThemeForColor(theme) }
}
val materialColors = listOf(
listOf(0xffffebee, 0xffffcdd2, 0xffef9a9a, 0xffe57373, 0xffef5350, 0xfff44336, 0xffe53935, 0xffd32f2f, 0xffc62828, 0xffb71c1c),
listOf(0xffFCE4EC, 0xffF8BBD0, 0xffF48FB1, 0xffF06292, 0xffEC407A, 0xffE91E63, 0xffD81B60, 0xffC2185B, 0xffAD1457, 0xff880E4F),
@@ -59,228 +62,43 @@ class Colors @Inject constructor(private val context: Context, private val prefs
private val minimumContrastRatio = 2
// Cache these values so they don't need to be recalculated
private val primaryTextLuminance = measureLuminance(getColor(R.color.textPrimaryDark))
private val secondaryTextLuminance = measureLuminance(getColor(R.color.textSecondaryDark))
private val tertiaryTextLuminance = measureLuminance(getColor(R.color.textTertiaryDark))
private val primaryTextLuminance = measureLuminance(context.getColorCompat(R.color.textPrimaryDark))
private val secondaryTextLuminance = measureLuminance(context.getColorCompat(R.color.textSecondaryDark))
private val tertiaryTextLuminance = measureLuminance(context.getColorCompat(R.color.textTertiaryDark))
val theme = themeForConversation()
fun theme(threadId: Long = 0): Theme = Theme(prefs.theme(threadId).get(), this)
val appThemeResources = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.style.AppThemeBlack
night && !black -> R.style.AppThemeDark
else -> R.style.AppThemeLight
}
})
val appDialogThemeResources = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.style.AppThemeBlackDialog
night && !black -> R.style.AppThemeDarkDialog
else -> R.style.AppThemeLightDialog
}
})
val popupThemeResource = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.style.PopupThemeBlack
night && !black -> R.style.PopupThemeDark
else -> R.style.PopupThemeLight
}
})
/**
* Returns the flags to be used for the system bars. This is used for tinting the icons
* according to the colour of the system bars (light or dark)
*
* If night mode, or no dark icons supported, use light icons
*
* If night mode and only dark status icons supported, use dark status icons
*
* If night mode and all dark icons supported, use all dark icons
*/
@SuppressLint("InlinedApi")
val systemBarIcons: Observable<Int> = prefs.night.asObservable()
.map { night ->
when {
night || Build.VERSION.SDK_INT < Build.VERSION_CODES.M -> 0
Build.VERSION.SDK_INT < Build.VERSION_CODES.O -> View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR
else -> View.SYSTEM_UI_FLAG_LIGHT_STATUS_BAR or View.SYSTEM_UI_FLAG_LIGHT_NAVIGATION_BAR
}
}
.distinctUntilChanged()
val statusBar: Observable<Int> = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.color.black
night && !black -> R.color.statusBarDark
Build.VERSION.SDK_INT < Build.VERSION_CODES.M -> R.color.black
else -> R.color.statusBarLight
}
})
.map { res -> getColor(res) }
.distinctUntilChanged()
val navigationBar: Observable<Int> = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.color.black
night && !black -> R.color.backgroundDark
Build.VERSION.SDK_INT < Build.VERSION_CODES.O -> R.color.black
else -> R.color.white
}
})
.map { res -> getColor(res) }
.distinctUntilChanged()
val toolbarColor: Observable<Int> = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.color.black
night && !black -> R.color.toolbarDark
else -> R.color.toolbarLight
}
})
.map { res -> getColor(res) }
.distinctUntilChanged()
val background: Observable<Int> = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.color.black
night && !black -> R.color.backgroundDark
else -> R.color.white
}
})
.map { res -> getColor(res) }
.distinctUntilChanged()
val ripple: Observable<Int> = prefs.night.asObservable()
.map { night ->
when (night) {
true -> R.drawable.ripple_dark
false -> R.drawable.ripple
}
}
.distinctUntilChanged()
val field: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.fieldDark else R.color.fieldLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val composeBackground: Observable<Int> = Observables.combineLatest(prefs.night.asObservable(), prefs.black.asObservable(),
{ night, black ->
when {
night && black -> R.color.black
night && !black -> R.color.backgroundDark
else -> R.color.backgroundLight
}
})
.map { res -> getColor(res) }
.distinctUntilChanged()
val separator: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.separatorDark else R.color.separatorLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textPrimary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textPrimaryDark else R.color.textPrimary }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textSecondary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textSecondaryDark else R.color.textSecondary }
.map { res -> getColor(res) }
.distinctUntilChanged()
val textTertiary: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.textTertiaryDark else R.color.textTertiary }
.map { res -> getColor(res) }
.distinctUntilChanged()
val highlightColor: Observable<Int> = theme
.map { theme -> FloatArray(3).apply { Color.colorToHSV(theme, this) } }
.map { hsv -> hsv.apply { set(2, 0.75f) } } // 75% value
.map { hsv -> Color.HSVToColor(85, hsv) } // 33% alpha
val textPrimaryOnTheme = textPrimaryOnThemeForConversation()
val textSecondaryOnTheme = textSecondaryOnThemeForConversation()
val textTertiaryOnTheme = textTertiaryOnThemeForConversation()
val bubble: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.bubbleDark else R.color.bubbleLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchThumbEnabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchThumbEnabledDark else R.color.switchThumbEnabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchThumbDisabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchThumbDisabledDark else R.color.switchThumbDisabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchTrackEnabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchTrackEnabledDark else R.color.switchTrackEnabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
val switchTrackDisabled: Observable<Int> = prefs.night.asObservable()
.map { night -> if (night) R.color.switchTrackDisabledDark else R.color.switchTrackDisabledLight }
.map { res -> getColor(res) }
.distinctUntilChanged()
fun themeForConversation(threadId: Long = 0): Observable<Int> = prefs.theme(threadId)
.asObservable()
.distinctUntilChanged()
fun textPrimaryOnThemeForConversation(threadId: Long = 0): Observable<Int> = themeForConversation(threadId)
.switchMap { color -> textPrimaryOnThemeForColor(color) }
fun textPrimaryOnThemeForColor(color: Int): Observable<Int> = Observable.just(color)
.map { theme -> measureLuminance(theme) }
.map { themeLuminance -> primaryTextLuminance / themeLuminance }
.map { contrastRatio -> contrastRatio < minimumContrastRatio }
.map { contrastRatio -> if (contrastRatio) R.color.textPrimary else R.color.textPrimaryDark }
.map { res -> getColor(res) }
.distinctUntilChanged()
fun textSecondaryOnThemeForConversation(threadId: Long = 0): Observable<Int> = themeForConversation(threadId)
.switchMap { color -> textSecondaryOnThemeForColor(color) }
fun textSecondaryOnThemeForColor(color: Int): Observable<Int> = Observable.just(color)
.map { theme -> measureLuminance(theme) }
.map { themeLuminance -> secondaryTextLuminance / themeLuminance }
.map { contrastRatio -> contrastRatio < minimumContrastRatio }
.map { contrastRatio -> if (contrastRatio) R.color.textSecondary else R.color.textSecondaryDark }
.map { res -> getColor(res) }
.distinctUntilChanged()
fun textTertiaryOnThemeForConversation(threadId: Long = 0): Observable<Int> = themeForConversation(threadId)
.switchMap { color -> textTertiaryOnThemeForColor(color) }
fun textTertiaryOnThemeForColor(color: Int): Observable<Int> = Observable.just(color)
.map { theme -> measureLuminance(theme) }
.map { themeLuminance -> tertiaryTextLuminance / themeLuminance }
.map { contrastRatio -> contrastRatio < minimumContrastRatio }
.map { contrastRatio -> if (contrastRatio) R.color.textTertiary else R.color.textTertiaryDark }
.map { res -> getColor(res) }
.distinctUntilChanged()
private fun getColor(@ColorRes res: Int): Int {
return context.resources.getColor(res)
fun themeObservable(threadId: Long = 0): Observable<Theme> {
return prefs.theme(threadId).asObservable()
.map { color -> Theme(color, this) }
}
fun highlightColorForTheme(theme: Int): Int = FloatArray(3)
.apply { Color.colorToHSV(theme, this) }
.let { hsv -> hsv.apply { set(2, 0.75f) } } // 75% value
.let { hsv -> Color.HSVToColor(85, hsv) } // 33% alpha
fun textPrimaryOnThemeForColor(color: Int): Int = color
.let { theme -> measureLuminance(theme) }
.let { themeLuminance -> primaryTextLuminance / themeLuminance }
.let { contrastRatio -> contrastRatio < minimumContrastRatio }
.let { contrastRatio -> if (contrastRatio) R.color.textPrimary else R.color.textPrimaryDark }
.let { res -> context.getColorCompat(res) }
fun textSecondaryOnThemeForColor(color: Int): Int = color
.let { theme -> measureLuminance(theme) }
.let { themeLuminance -> secondaryTextLuminance / themeLuminance }
.let { contrastRatio -> contrastRatio < minimumContrastRatio }
.let { contrastRatio -> if (contrastRatio) R.color.textSecondary else R.color.textSecondaryDark }
.let { res -> context.getColorCompat(res) }
fun textTertiaryOnThemeForColor(color: Int): Int = color
.let { theme -> measureLuminance(theme) }
.let { themeLuminance -> tertiaryTextLuminance / themeLuminance }
.let { contrastRatio -> contrastRatio < minimumContrastRatio }
.let { contrastRatio -> if (contrastRatio) R.color.textTertiary else R.color.textTertiaryDark }
.let { res -> context.getColorCompat(res) }
/**
* Measures the luminance value of a color to be able to measure the contrast ratio between two materialColors
* Based on https://stackoverflow.com/a/9733420
@@ -22,28 +22,15 @@ import android.content.Context
import android.graphics.Typeface
import android.support.v4.content.res.ResourcesCompat
import com.moez.QKSMS.R
import io.reactivex.Observable
import io.reactivex.subjects.BehaviorSubject
import io.reactivex.subjects.Subject
import timber.log.Timber
import util.Preferences
import util.extensions.Optional
import javax.inject.Inject
import javax.inject.Singleton
@Singleton
class FontProvider @Inject constructor(context: Context, prefs: Preferences) {
class FontProvider @Inject constructor(context: Context) {
val typeface: Observable<Optional<Typeface>> = prefs.systemFont.asObservable()
.distinctUntilChanged()
.switchMap { systemFont ->
when (systemFont) {
true -> Observable.just(Optional(null))
false -> lato
}
}
private val lato: Observable<Optional<Typeface>> = BehaviorSubject.create()
private var lato: Typeface? = null
private val pendingCallbacks = ArrayList<(Typeface) -> Unit>()
init {
ResourcesCompat.getFont(context, R.font.lato, object : ResourcesCompat.FontCallback() {
@@ -52,10 +39,16 @@ class FontProvider @Inject constructor(context: Context, prefs: Preferences) {
}
override fun onFontRetrieved(typeface: Typeface) {
val subject = lato as Subject<Optional<Typeface>>
subject.onNext(Optional(typeface))
lato = typeface
pendingCallbacks.forEach { lato?.run(it) }
pendingCallbacks.clear()
}
}, null)
}
fun getLato(callback: (Typeface) -> Unit) {
lato?.run(callback) ?: pendingCallbacks.add(callback)
}
}
@@ -110,7 +110,7 @@ class NotificationManagerImpl @Inject constructor(
val notification = NotificationCompat.Builder(context, getChannelIdForNotification(threadId))
.setCategory(NotificationCompat.CATEGORY_MESSAGE)
.setColor(colors.themeForConversation(threadId).blockingFirst())
.setColor(colors.theme(threadId).theme)
.setPriority(NotificationCompat.PRIORITY_MAX)
.setSmallIcon(R.drawable.ic_notification)
.setNumber(messages.size)
@@ -207,7 +207,7 @@ class NotificationManagerImpl @Inject constructor(
val notification = NotificationCompat.Builder(context, getChannelIdForNotification(threadId))
.setContentTitle(context.getString(R.string.notification_message_failed_title))
.setContentText(context.getString(R.string.notification_message_failed_text, conversation.getTitle()))
.setColor(colors.themeForConversation(threadId).blockingFirst())
.setColor(colors.theme(threadId).theme)
.setPriority(NotificationManagerCompat.IMPORTANCE_MAX)
.setSmallIcon(R.drawable.ic_notification_failed)
.setAutoCancel(true)
@@ -0,0 +1,160 @@
/*
* Copyright (C) 2017 Moez Bhatti <moez.bhatti@gmail.com>
*
* This file is part of QKSMS.
*
* QKSMS is free software: you can redistribute it and/or modify
* it under the terms of the GNU General Public License as published by
* the Free Software Foundation, either version 3 of the License, or
* (at your option) any later version.
*
* QKSMS is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
* GNU General Public License for more details.
*
* You should have received a copy of the GNU General Public License
* along with QKSMS. If not, see <http://www.gnu.org/licenses/>.
*/
package common.util
import android.graphics.Typeface
import android.util.AttributeSet
import android.widget.TextView
import com.moez.QKSMS.R
import common.util.extensions.getColorCompat
import common.util.extensions.resolveThemeColor
import common.widget.QkEditText
import common.widget.QkTextView
import util.Preferences
import javax.inject.Inject
class TextViewStyler @Inject constructor(
private val prefs: Preferences,
private val colors: Colors,
private val fontProvider: FontProvider
) {
companion object {
const val COLOR_PRIMARY = 0
const val COLOR_SECONDARY = 1
const val COLOR_TERTIARY = 2
const val COLOR_PRIMARY_ON_THEME = 3
const val COLOR_SECONDARY_ON_THEME = 4
const val COLOR_TERTIARY_ON_THEME = 5
const val COLOR_THEME = 6
const val SIZE_PRIMARY = 0
const val SIZE_SECONDARY = 1
const val SIZE_TERTIARY = 2
const val SIZE_TOOLBAR = 3
}
fun applyAttributes(textView: TextView, attrs: AttributeSet?) {
textView.run {
when (this) {
is QkTextView -> context.obtainStyledAttributes(attrs, R.styleable.QkTextView)?.run {
val colorAttr = getInt(R.styleable.QkTextView_textColor, -1)
val textSizeAttr = getInt(R.styleable.QkTextView_textSize, -1)
applyAttributes(textView, colorAttr, textSizeAttr)
recycle()
}
is QkEditText -> context.obtainStyledAttributes(attrs, R.styleable.QkEditText)?.run {
val colorAttr = getInt(R.styleable.QkEditText_textColor, -1)
val textSizeAttr = getInt(R.styleable.QkEditText_textSize, -1)
applyAttributes(textView, colorAttr, textSizeAttr)
recycle()
}
}
if (!prefs.systemFont.get()) {
fontProvider.getLato { lato ->
setTypeface(lato, typeface?.style ?: Typeface.NORMAL)
}
}
}
}
private fun applyAttributes(textView: TextView, colorAttr: Int, textSizeAttr: Int) {
textView.run {
if (isInEditMode) {
setTextColor(context.getColorCompat(when (colorAttr) {
COLOR_PRIMARY -> R.color.textPrimary
COLOR_SECONDARY -> R.color.textSecondary
COLOR_TERTIARY -> R.color.textTertiary
COLOR_PRIMARY_ON_THEME -> R.color.textPrimaryDark
COLOR_SECONDARY_ON_THEME -> R.color.textSecondaryDark
COLOR_TERTIARY_ON_THEME -> R.color.textTertiaryDark
COLOR_THEME -> R.color.tools_theme
else -> R.color.textPrimary
}))
textSize = when (textSizeAttr) {
SIZE_PRIMARY -> 16f
SIZE_SECONDARY -> 14f
SIZE_TERTIARY -> 12f
SIZE_TOOLBAR -> 20f
else -> textSize
}
} else {
setTextColor(when (colorAttr) {
COLOR_PRIMARY -> context.resolveThemeColor(android.R.attr.textColorPrimary)
COLOR_SECONDARY -> context.resolveThemeColor(android.R.attr.textColorSecondary)
COLOR_TERTIARY -> context.resolveThemeColor(android.R.attr.textColorTertiary)
COLOR_PRIMARY_ON_THEME -> colors.theme().textPrimary
COLOR_SECONDARY_ON_THEME -> colors.theme().textSecondary
COLOR_TERTIARY_ON_THEME -> colors.theme().textTertiary
COLOR_THEME -> colors.theme().theme
else -> currentTextColor
})
setTextSize(textView, textSizeAttr)
}
}
}
/**
* @see SIZE_PRIMARY
* @see SIZE_SECONDARY
* @see SIZE_TERTIARY
* @see SIZE_TOOLBAR
*/
fun setTextSize(textView: TextView, textSizeAttr: Int) {
val textSizePref = prefs.textSize.get()
when (textSizeAttr) {
SIZE_PRIMARY -> textView.textSize = when (textSizePref) {
Preferences.TEXT_SIZE_SMALL -> 14f
Preferences.TEXT_SIZE_NORMAL -> 16f
Preferences.TEXT_SIZE_LARGE -> 18f
Preferences.TEXT_SIZE_LARGER -> 20f
else -> 16f
}
SIZE_SECONDARY -> textView.textSize = when (textSizePref) {
Preferences.TEXT_SIZE_SMALL -> 12f
Preferences.TEXT_SIZE_NORMAL -> 14f
Preferences.TEXT_SIZE_LARGE -> 16f
Preferences.TEXT_SIZE_LARGER -> 18f
else -> 14f
}
SIZE_TERTIARY -> textView.textSize = when (textSizePref) {
Preferences.TEXT_SIZE_SMALL -> 10f
Preferences.TEXT_SIZE_NORMAL -> 12f
Preferences.TEXT_SIZE_LARGE -> 14f
Preferences.TEXT_SIZE_LARGER -> 16f
else -> 12f
}
SIZE_TOOLBAR -> textView.textSize = when (textSizePref) {
Preferences.TEXT_SIZE_SMALL -> 18f
Preferences.TEXT_SIZE_NORMAL -> 20f
Preferences.TEXT_SIZE_LARGE -> 22f
Preferences.TEXT_SIZE_LARGER -> 26f
else -> 20f
}
}
}
}
@@ -22,6 +22,7 @@ import android.app.Activity
import android.content.Context
import android.support.annotation.StringRes
import android.support.v4.content.ContextCompat
import android.util.TypedValue
import android.view.inputmethod.InputMethodManager
import android.widget.Toast
@@ -29,6 +30,23 @@ fun Context.getColorCompat(colorRes: Int): Int {
return ContextCompat.getColor(this, colorRes)
}
/**
* Tries to resolve a resource id from the current theme, based on the [attributeId]
*/
fun Context.resolveThemeAttribute(attributeId: Int, default: Int = 0): Int {
val outValue = TypedValue()
val wasResolved = theme.resolveAttribute(attributeId, outValue, true)
return if (wasResolved) outValue.resourceId else default
}
fun Context.resolveThemeColor(attributeId: Int, default: Int = 0): Int {
val outValue = TypedValue()
val wasResolved = theme.resolveAttribute(attributeId, outValue, true)
return if (wasResolved) getColorCompat(outValue.resourceId) else default
}
fun Context.makeToast(@StringRes res: Int, duration: Int = Toast.LENGTH_SHORT) {
Toast.makeText(this, res, duration).show()
}
@@ -22,6 +22,7 @@ import android.content.Context
import android.content.res.ColorStateList
import android.graphics.PorterDuff
import android.os.Build
import android.support.v7.widget.RecyclerView
import android.view.MotionEvent
import android.view.View
import android.view.inputmethod.InputMethodManager
@@ -94,3 +95,15 @@ fun View.forwardTouches(parent: View) {
}
}
fun RecyclerView.scrapViews() {
val adapter = adapter
val layoutManager = layoutManager
this.adapter = null
this.layoutManager = null
this.adapter = adapter
this.layoutManager = layoutManager
adapter?.notifyDataSetChanged()
}