KotlinSample

View

import android.arch.lifecycle.ViewModelProvider
import android.arch.lifecycle.ViewModelProviders
import android.content.Context
import android.content.Intent
import android.databinding.DataBindingUtil
import android.graphics.Color
import android.os.Bundle
import android.view.View
import com.popalay.cardme.R
import com.popalay.cardme.databinding.ActivityHolderDetailsBinding
import com.popalay.cardme.presentation.base.SlidingActivity
import com.popalay.cardme.utils.ShareUtils
import com.popalay.cardme.utils.recycler.decoration.SpacingItemDecoration
import io.reactivex.rxkotlin.addTo
import javax.inject.Inject

class HolderDetailsActivity : SlidingActivity() {

    @Inject lateinit var factory: ViewModelProvider.Factory

    private lateinit var b: ActivityHolderDetailsBinding
    private lateinit var viewModelFacade: HolderDetailsViewModelFacade

    private var isExpanded: Boolean = false

    companion object {

        const val KEY_HOLDER_DETAILS = "KEY_HOLDER_DETAILS"

        fun getIntent(context: Context, id: String): Intent {
            val intent = Intent(context, HolderDetailsActivity::class.java)
            intent.putExtra(KEY_HOLDER_DETAILS, id)
            return intent
        }

    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        b = DataBindingUtil.setContentView<ActivityHolderDetailsBinding>(this, R.layout.activity_holder_details)
        ViewModelProviders.of(this, factory).get(HolderDetailsViewModel::class.java).let {
            b.vm = it
            viewModelFacade = it
        }
        initUI()
    }

    override fun getRootView(): View = b.root

    override fun canSlideDown() = isExpanded && b.listDebts.scrollY == 0

    private fun initUI() {
        setSupportActionBar(b.toolbar)
        b.collapsingToolbar.isTitleEnabled = false
        b.toolbar.setNavigationOnClickListener { onBackPressed() }

        viewModelFacade.doOnShareCard()
                .subscribe {
                    ShareUtils.shareText(this, R.string.share_card, it)
                }.addTo(disposables)

        b.listCards.addItemDecoration(SpacingItemDecoration.Builder(this)
                .onSides(true)
                .betweenItems(true)
                .build())

        b.toolbar.navigationIcon?.alpha = 255
        b.appBar.addOnOffsetChangedListener { appBarLayout, verticalOffset ->
            isExpanded = verticalOffset == 0
            if (appBarLayout.totalScrollRange == 0) {
                return@addOnOffsetChangedListener
            }
            val alpha = Math.min(-verticalOffset, 255)
            b.toolbar.setTitleTextColor(Color.argb(alpha, 255, 255, 255))
            b.toolbar.navigationIcon?.alpha = alpha
        }

    }

}

ViewModel

import android.databinding.ObservableBoolean
import com.jakewharton.rxrelay2.PublishRelay
import com.popalay.cardme.business.cards.CardInteractor
import com.popalay.cardme.business.debts.DebtsInteractor
import com.popalay.cardme.business.holders.HolderInteractor
import com.popalay.cardme.business.settings.SettingsInteractor
import com.popalay.cardme.data.models.Card
import com.popalay.cardme.data.models.Debt
import com.popalay.cardme.presentation.base.BaseViewModel
import com.popalay.cardme.utils.extensions.applyThrottling
import com.popalay.cardme.utils.extensions.setTo
import com.popalay.cardme.utils.recycler.DiffObservableList
import com.stepango.rxdatabindings.ObservableString
import com.stepango.rxdatabindings.setTo
import io.reactivex.Observable
import io.reactivex.android.schedulers.AndroidSchedulers
import io.reactivex.rxkotlin.addTo
import io.reactivex.rxkotlin.subscribeBy
import javax.inject.Inject
import javax.inject.Named

class HolderDetailsViewModel @Inject constructor(
        @Named(HolderDetailsActivity.KEY_HOLDER_DETAILS) holderId: String,
        cardInteractor: CardInteractor,
        holderInteractor: HolderInteractor,
        debtsInteractor: DebtsInteractor,
        settingsInteractor: SettingsInteractor
) : BaseViewModel(), HolderDetailsViewModelFacade {

    val debts = DiffObservableList<Debt>()
    val cards = DiffObservableList<Card>()
    val holderName = ObservableString()
    val showImage = ObservableBoolean()

    val cardClickPublisher: PublishRelay<Card> = PublishRelay.create<Card>()

    init {
        cardInteractor.getCardsByHolder(holderId)
                .observeOn(AndroidSchedulers.mainThread())
                .setTo(cards)
                .subscribeBy()
                .addTo(disposables)

        debtsInteractor.getDebtsByHolder(holderId)
                .observeOn(AndroidSchedulers.mainThread())
                .setTo(debts)
                .subscribeBy()
                .addTo(disposables)

        holderInteractor.getHolderName(holderId)
                .observeOn(AndroidSchedulers.mainThread())
                .setTo(holderName)
                .subscribeBy()
                .addTo(disposables)

        settingsInteractor.listenShowCardsBackground()
                .observeOn(AndroidSchedulers.mainThread())
                .setTo(showImage)
                .subscribeBy()
                .addTo(disposables)
    }

    override fun doOnShareCard(): Observable<String> = cardClickPublisher
            .applyThrottling()
            .map { it.number }

}

ViewModelFactory

import android.arch.lifecycle.ViewModel
import android.arch.lifecycle.ViewModelProvider
import javax.inject.Inject
import javax.inject.Provider

class ViewModelFactory @Inject constructor(
        private val creators: Map<Class<out ViewModel>, @JvmSuppressWildcards Provider<ViewModel>>
) : ViewModelProvider.Factory {

    @Suppress("UNCHECKED_CAST")
    override fun <T : ViewModel> create(modelClass: Class<T>): T {
        var creator: Provider<out ViewModel>? = creators[modelClass]
        creator ?: creators.keys.filter(modelClass::isAssignableFrom).firstOrNull()?.apply { creator = creators[this] }
        creator ?: throw IllegalArgumentException("unknown model class " + modelClass)

        try {
            return creator?.get() as T
        } catch (e: Exception) {
            throw RuntimeException(e)
        }
    }
}