Как декларативно описать коллапсирующий тулбар

class TopInfoBehavior(
        context: Context?,
        attrs: AttributeSet?
) : BehaviorByRules(context, attrs) {

    override fun calcAppbarHeight(child: View): Int = with(child) {
        return (height + pixels(R.dimen.toolbar_height)).toInt()
    }

    override fun View.provideAppbar(): AppBarLayout = ablAppbar
    override fun View.provideCollapsingToolbar(): CollapsingToolbarLayout
            = ctlToolbar

    override fun View.setUpViews(): List<RuledView> = listOf(
        RuledView(
                viewGroupTopDetails,
                BRuleYOffset(
                    min = pixels(R.dimen.zero),
                    max = pixels(R.dimen.toolbar_height)
                )
        ),
        RuledView(
                textViewTopDetails,
                BRuleAlpha(min = 0.6f, max = 1f)
                    .workInRange(from = appearedUntil, to = 1f),
                BRuleXOffset(
                    min = 0f, max = pixels(R.dimen.big_margin),
                    interpolator =
                    ReverseInterpolator(AccelerateInterpolator())
                ),
                BRuleYOffset(
                    min = pixels(R.dimen.zero), max = pixels(R.dimen.pad),
                    interpolator = ReverseInterpolator(LinearInterpolator())
                ),
                BRuleAppear(0.1f),
                BRuleScale(min = 0.8f, max = 1f)
        ),
        RuledView(
                textViewPainIsTheArse,
                BRuleAppear(isAppearedUntil = GONE_VIEW_THRESHOLD)
        ),
        RuledView(
                textViewCollapsedTop,
                BRuleAppear(0.1f, true)
        ),
        RuledView(
                textViewTop,
                BRuleAppear(isAppearedUntil = GONE_VIEW_THRESHOLD)
        ),
        buildRuleForIcon(ivTop, LinearInterpolator()),
        buildRuleForIcon(ivTop2, AccelerateInterpolator(0.7f)),
        buildRuleForIcon(ivTop3, AccelerateInterpolator())
    )

    private fun View.buildRuleForIcon(
            view: ImageView,
            interpolator: Interpolator
    ) = RuledView(
        view,
        BRuleYOffset(
                min = -(ivTop3.y - tvCollapsedTop.y),
                max = 0f,
                interpolator = DecelerateInterpolator(1.5f)
        ),
        BRuleXOffset(
                min = 0f,
                max = tvCollapsedTop.width.toFloat() + pixels(R.dimen.huge_margin),
                interpolator = ReverseInterpolator(interpolator)
        )
    )

    companion object {
        const val GONE_VIEW_THRESHOLD = 0.8f
    }
}

<android.support.design.widget.CoordinatorLayout>

    <android.support.design.widget.AppBarLayout
        android:layout_height="wrap_content">

        <android.support.design.widget.CollapsingToolbarLayout
            app:layout_scrollFlags="scroll|exitUntilCollapsed">

            <android.support.v7.widget.Toolbar
                android:layout_height="@dimen/toolbar_height"
                app:layout_collapseMode="pin"/>

        </android.support.design.widget.CollapsingToolbarLayout>

    </android.support.design.widget.AppBarLayout>

    <!--весь тулбар здесь-->
    <RelativeLayout 
        android:translationZ="5dp"
        app:layout_behavior="TopInfoBehavior"/>

    <android.support.v4.widget.NestedScrollView
        app:layout_behavior="@string/appbar_scrolling_view_behavior">
    </android.support.v4.widget.NestedScrollView>

    <android.support.design.widget.FloatingActionButton
        app:layout_anchor="@id/nesteScroll"
        app:layout_anchorGravity="right"/>

</android.support.design.widget.CoordinatorLayout>

/**
 * [min], [max] — values in range [0, 1]
 */
class BRuleAlpha(
        override val min: Float,
        override val max: Float,
        override val interpolator: Interpolator = LinearInterpolator()
) : BaseBehaviorRule() {
    override fun perform(offset: Float, details: InitialViewDetails, view: View) {
        view.alpha = offset
    }
}

/**
 * Affine transform value form one range into another
 */
fun normalize(
        oldValue: Float,
        newMin: Float, newMax: Float,
        oldMin: Float = 0f, oldMax: Float = 1f
): Float = newMin + ((oldValue - oldMin) * (newMax - newMin)) / (oldMax - oldMin)

abstract class BehaviorByRules(
        context: Context?,
        attrs: AttributeSet?
) : CoordinatorLayout.Behavior<View>(context, attrs) {

    private var views: List<RuledView> = emptyList()
    private var lastChildHeight = -1
    private var needToUpdateHeight: Boolean = true

    override fun layoutDependsOn(
            parent: CoordinatorLayout,
            child: View,
            dependency: View
    ): Boolean {
        return dependency is AppBarLayout
    }

    override fun onDependentViewChanged(
            parent: CoordinatorLayout,
            child: View,
            dependency: View
    ): Boolean {
        firstInit(child, dependency)
        val progress = calcProgress(parent)
        views.forEach { performRules(offsetView = it, percent = progress) }
        return true
    }

    override fun onMeasureChild(
            parent: CoordinatorLayout, child: View, parentWidthMeasureSpec: Int,
            widthUsed: Int, parentHeightMeasureSpec: Int, heightUsed: Int
    ): Boolean {

        val canUpdateHeight = canUpdateHeight(calcProgress(parent))
        if (canUpdateHeight) {
            parent.post {
                val newChildHeight = child.height
                if (newChildHeight != lastChildHeight) {
                    lastChildHeight = newChildHeight
                    setUpAppbarHeight(child, parent)
                }
            }
        } else {
            needToUpdateHeight = true
        }
        return super.onMeasureChild(
                parent, child, parentWidthMeasureSpec,
                widthUsed, parentHeightMeasureSpec, heightUsed
        )
    }

    /**
     * If you use fitsSystemWindows=true in your coordinator layout,
     * you will have to include statusBar height in the appbarHeight
     */
    protected abstract fun calcAppbarHeight(child: View): Int
    protected abstract fun View.setUpViews(): List<RuledView>
    protected abstract fun View.provideAppbar(): AppBarLayout
    protected abstract fun View.provideCollapsingToolbar(): CollapsingToolbarLayout

    /**
     * You man not want to update height, if height depends on views, that are currently invisible
     */
    protected open fun canUpdateHeight(progress: Float): Boolean = true

    private fun calcProgress(parent: CoordinatorLayout): Float {
        val appBar = parent.provideAppbar()
        val scrollRange = appBar.totalScrollRange.toFloat()
        val scrollY = Math.abs(appBar.y)
        val scroll = 1 - scrollY / scrollRange
        return when {
            scroll.isNaN() -> 1f
            else -> scroll
        }
    }

    private fun setUpAppbarHeight(child: View, parent: ViewGroup) {
        parent.provideCollapsingToolbar().setHeight(calcAppbarHeight(child))
    }

    private fun firstInit(child: View, dependency: View) {
        if (needToUpdateHeight) {
            setUpAppbarHeight(child, dependency as ViewGroup)
            needToUpdateHeight = false
        }

        if (views.isEmpty()) {
            views = child.setUpViews()
        }
    }

    private fun performRules(offsetView: RuledView, percent: Float) {
        val view = offsetView.view
        val details = offsetView.details
        offsetView.rules.forEach { rule ->
            rule.manage(percent, details, view)
        }
    }
}