I wrote NestedWebView with Kotlin and fix some codes.

[ByunghooLimCn]

package input.your.package.name

/*

• Copyright (C) 2015 takahirom
• 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. */

import android.annotation.SuppressLint import android.content.Context import android.support.v4.view.NestedScrollingChild import android.support.v4.view.NestedScrollingChildHelper import android.support.v4.view.ViewCompat import android.util.AttributeSet import android.view.MotionEvent import android.view.MotionEvent.* import android.webkit.WebView

open class NestedWebView(context: Context, attrs: AttributeSet? = null, defStyleAttr: Int = android.R.attr.webViewStyle) : WebView(context, attrs, defStyleAttr), NestedScrollingChild { private val mScrollOffset = IntArray(2) private val mScrollConsumed = IntArray(2) private val mChildHelper = NestedScrollingChildHelper(rootView) private var mLastY: Float = 0F private var mNestedOffsetY: Float = 0F

init {
    isNestedScrollingEnabled = true
}

@SuppressLint("ClickableViewAccessibility")
override fun onTouchEvent(ev: MotionEvent): Boolean {
    val event = obtain(ev)
    var returnValue = false

    event.offsetLocation(0f, mNestedOffsetY)

    when (ev.action) {
        ACTION_DOWN -> {
            returnValue = super.onTouchEvent(event)
            mLastY = event.y
            // start NestedScroll
            startNestedScroll(ViewCompat.SCROLL_AXIS_VERTICAL)
        }
        ACTION_MOVE -> {
            var deltaY = mLastY - event.y
            // NestedPreScroll
            if (dispatchNestedPreScroll(0, deltaY.toInt(), mScrollConsumed, mScrollOffset)) {
                deltaY -= mScrollConsumed[1]
                mLastY = event.y - mScrollOffset[1]
                event.offsetLocation(0f, (-mScrollOffset[1]).toFloat())
                mNestedOffsetY += mScrollOffset[1]
            }

            returnValue = super.onTouchEvent(event)

            // NestedScroll
            if (dispatchNestedScroll(0, mScrollOffset[1], 0, deltaY.toInt(), mScrollOffset)) {
                event.offsetLocation(0f, mScrollOffset[1].toFloat())
                mNestedOffsetY += mScrollOffset[1]
                mLastY -= mScrollOffset[1]
            }
        }
        ACTION_UP, ACTION_CANCEL -> {
            mNestedOffsetY = 0F
            returnValue = super.onTouchEvent(event)
            // end NestedScroll
            stopNestedScroll()
        }
    }
    return returnValue
}

// Nested Scroll implements
override fun setNestedScrollingEnabled(enabled: Boolean) {
    mChildHelper.isNestedScrollingEnabled = enabled
}

override fun stopNestedScroll() {
    mChildHelper.stopNestedScroll()
}

override fun isNestedScrollingEnabled() = mChildHelper.isNestedScrollingEnabled
override fun startNestedScroll(axes: Int) = mChildHelper.startNestedScroll(axes)
override fun hasNestedScrollingParent() = mChildHelper.hasNestedScrollingParent()
override fun dispatchNestedPreScroll(dx: Int, dy: Int, consumed: IntArray?, offsetInWindow: IntArray?) = mChildHelper.dispatchNestedPreScroll(dx, dy, consumed, offsetInWindow)
override fun dispatchNestedFling(velocityX: Float, velocityY: Float, consumed: Boolean) = mChildHelper.dispatchNestedFling(velocityX, velocityY, consumed)
override fun dispatchNestedPreFling(velocityX: Float, velocityY: Float) = mChildHelper.dispatchNestedPreFling(velocityX, velocityY)
override fun dispatchNestedScroll(dxConsumed: Int, dyConsumed: Int, dxUnconsumed: Int, dyUnconsumed: Int,
                                  offsetInWindow: IntArray?) = mChildHelper.dispatchNestedScroll(dxConsumed, dyConsumed, dxUnconsumed, dyUnconsumed, offsetInWindow)

}