大尺寸图片加载问题

val mDecoder = BitmapRegionDecoder.newInstance(...)
val mBitmap = mDecoder.decodeRegion(mRect, mOptions)
canvas.drawBitmap(mBitmap, 0F, 0F, null)

interface OnMoveGestureListener {
    fun onMoveBegin(detector: MoveGestureDetector): Boolean

    fun onMove(detector: MoveGestureDetector): Boolean

    fun onMoveEnd(detector: MoveGestureDetector)

    open class Simple : OnMoveGestureListener {
        override fun onMoveBegin(detector: MoveGestureDetector) = true

        override fun onMove(detector: MoveGestureDetector) = false

        override fun onMoveEnd(detector: MoveGestureDetector) {}
    }
}

abstract class BaseGestureDetector(
    context: Context
) {
    protected var mGestureInPregress = false

    protected var mPreMotionEvent: MotionEvent? = null
    protected var mCurrentMotionEvent: MotionEvent? = null

    public fun onTouchEvent(event: MotionEvent): Boolean {
        if (!mGestureInPregress) {
            handleStartProgressEvent(event)
        } else {
            handleInProgressEvent(event)
        }

        return true
    }

    protected abstract fun handleInProgressEvent(event: MotionEvent)

    protected abstract fun handleStartProgressEvent(event: MotionEvent)

    protected abstract fun updateStateByEvent(event: MotionEvent)

    protected fun resetState() {
        mPreMotionEvent?.let {
            it.recycle()
            mPreMotionEvent = null
        }
        mCurrentMotionEvent?.let {
            it.recycle()
            mCurrentMotionEvent = null
        }

        mGestureInPregress = false
    }
}

class MoveGestureDetector(
    context: Context,
    private var mListener: OnMoveGestureListener? = null
) : BaseGestureDetector(context) {

    private var mPrePointer: PointF? = null
    private var mCurrentPointer: PointF? = null

    private val mExternalPointer = PointF()

    override fun handleInProgressEvent(event: MotionEvent) {
        val action = event.action and MotionEvent.ACTION_MASK
        when (action) {
            MotionEvent.ACTION_CANCEL,
            MotionEvent.ACTION_UP -> {
                mListener?.onMoveEnd(this)
                resetState()
            }

            MotionEvent.ACTION_MOVE -> {
                updateStateByEvent(event)
                val update = mListener?.onMove(this)

                if (update == true) {
                    mPreMotionEvent?.recycle()
                    mPreMotionEvent = MotionEvent.obtain(event)
                }
            }
        }
    }

    override fun handleStartProgressEvent(event: MotionEvent) {
        val action = event.action and MotionEvent.ACTION_MASK
        when (action) {
            MotionEvent.ACTION_DOWN -> {
                resetState()
                mPreMotionEvent = MotionEvent.obtain(event)
                updateStateByEvent(event)
            }

            MotionEvent.ACTION_MOVE -> {
                mGestureInPregress = mListener?.onMoveBegin(this) == true
            }
        }
    }

    override fun updateStateByEvent(event: MotionEvent) {
        mPreMotionEvent?.let {
            mPrePointer = calcFocalPointer(it)
            mCurrentPointer = calcFocalPointer(event)

            val skip = it.pointerCount != event.pointerCount
            if (skip) {
                mExternalPointer.x = 0F
                mExternalPointer.y = 0F
            } else {
                mExternalPointer.x = mCurrentPointer!!.x - mPrePointer!!.x
                mExternalPointer.y = mCurrentPointer!!.y - mPrePointer!!.y
            }
        }
    }

    fun getMoveX() = mExternalPointer.x

    fun getMoveY() = mExternalPointer.y

    private fun calcFocalPointer(event: MotionEvent): PointF {
        val count = event.pointerCount

        var x = 0F
        var y = 0F

        for (i in 0 until count) {
            x += event.getX(i)
            y += event.getY(i)
        }

        x /= count
        y /= count

        return PointF(x, y)
    }
}

class LargeImageView(
    context: Context,
    attributeSet: AttributeSet? = null
) : ImageView(context, attributeSet) {

    private var mDecoder: BitmapRegionDecoder? = null
    private val mOptions by lazy {
        BitmapFactory.Options().apply {
            inPreferredConfig = Bitmap.Config.RGB_565
        }
    }
    private val mRect by lazy { Rect() }

    private var mImageWidth = 0
    private var mImageHeight = 0

    private val mDetector: MoveGestureDetector by lazy {
        MoveGestureDetector(
            context,
            object : OnMoveGestureListener.Simple() {
                override fun onMove(detector: MoveGestureDetector): Boolean {
                    val moveX = detector.getMoveX().toInt()
                    val moveY = detector.getMoveY().toInt()

                    if (mImageWidth > width) {
                        mRect.offset(-moveX, 0)
                        checkWidth()
                        invalidate()
                    }
                    if (mImageHeight > height) {
                        mRect.offset(0, -moveY)
                        checkHeight()
                        invalidate()
                    }

                    return true
                }
            })
    }

    fun setInputStream(`is`: InputStream) {
        try {
            mDecoder = BitmapRegionDecoder.newInstance(`is`, false)

            BitmapFactory.Options().run {
                inJustDecodeBounds = true
                BitmapFactory.decodeStream(`is`, null, this)

                mImageWidth = this.outWidth
                mImageHeight = this.outHeight
            }

            requestLayout()
            invalidate()
        } catch (ex: Exception) {
            ex.printStackTrace()
        } finally {
            `is`.close()
        }
    }

    override fun onTouchEvent(event: MotionEvent): Boolean {
        mDetector.onTouchEvent(event)
        return true
    }

    override fun onDraw(canvas: Canvas) {
        mDecoder?.decodeRegion(mRect, mOptions)?.run {
                canvas.drawBitmap(this, 0F, 0F, null)
        }
    }

    override fun onMeasure(widthMeasureSpec: Int, heightMeasureSpec: Int) {
        super.onMeasure(widthMeasureSpec, heightMeasureSpec)

        val width = measuredWidth
        val height = measuredHeight

        mRect.run {
            this.left = (mImageWidth - width) shr 1
            this.top = (mImageHeight - height) shr 1
            this.right = this.left + width
            this.bottom = this.top + height
        }
    }

    private fun checkWidth() {
        if (mRect.right > mImageWidth) {
            mRect.right = mImageWidth
            mRect.left = mImageWidth - width
        }
        if (mRect.left < 0) {
            mRect.left = 0
            mRect.right = width
        }
    }

    private fun checkHeight() {
        if (mRect.bottom > mImageHeight) {
            mRect.bottom = mImageHeight
            mRect.top = mImageHeight - height
        }
        if (mRect.top < 0) {
            mRect.top = 0
            mRect.bottom = height
        }
    }
}

class BigImgActivity : ActivityBase() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_big_img)

        val `is` = assets.open("image.jpg")
        iv_bigimg.setInputStream(`is`)
    }
}