Kotlin version

photoview/Compat.kt

@@ -0,0 +1,37 @@
+/*
+ Copyright 2011, 2012 Chris Banes.
+
+ 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.
+ */
+package com.github.chrisbanes.photoview
+
+import android.annotation.TargetApi
+import android.os.Build.VERSION
+import android.os.Build.VERSION_CODES
+import android.view.View
+
+internal object Compat {
+    private const val SIXTY_FPS_INTERVAL = 1000 / 60
+    fun postOnAnimation(view: View, runnable: Runnable) {
+        if (VERSION.SDK_INT >= VERSION_CODES.JELLY_BEAN) {
+            postOnAnimationJellyBean(view, runnable)
+        } else {
+            view.postDelayed(runnable, SIXTY_FPS_INTERVAL.toLong())
+        }
+    }
+
+    @TargetApi(16)
+    private fun postOnAnimationJellyBean(view: View, runnable: Runnable) {
+        view.postOnAnimation(runnable)
+    }
+}

photoview/CustomGestureDetector.kt

@@ -0,0 +1,186 @@
+/*
+ Copyright 2011, 2012 Chris Banes.
+ <p/>
+ 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
+ <p/>
+ http://www.apache.org/licenses/LICENSE-2.0
+ <p/>
+ 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.
+ */
+package com.github.chrisbanes.photoview
+
+import android.content.Context
+import android.view.MotionEvent
+import android.view.ScaleGestureDetector
+import android.view.ScaleGestureDetector.OnScaleGestureListener
+import android.view.VelocityTracker
+import android.view.ViewConfiguration
+
+/**
+ * Does a whole lot of gesture detecting.
+ */
+internal class CustomGestureDetector() {
+    private var mActivePointerId = INVALID_POINTER_ID
+    private var mActivePointerIndex = 0
+    private var mDetector: ScaleGestureDetector? = null
+    private var mVelocityTracker: VelocityTracker? = null
+    var isDragging = false
+        private set
+    private var mLastTouchX = 0f
+    private var mLastTouchY = 0f
+    private var mTouchSlop: Float = 0.0f
+    private var mMinimumVelocity: Float = 0.0f
+    private lateinit var mListener: OnGestureListener
+    private fun getActiveX(ev: MotionEvent): Float {
+        return try {
+            ev.getX(mActivePointerIndex)
+        } catch (e: Exception) {
+            ev.x
+        }
+    }
+
+    private fun getActiveY(ev: MotionEvent): Float {
+        return try {
+            ev.getY(mActivePointerIndex)
+        } catch (e: Exception) {
+            ev.y
+        }
+    }
+
+    val isScaling: Boolean
+        get() = mDetector!!.isInProgress
+
+    fun onTouchEvent(ev: MotionEvent): Boolean {
+        return try {
+            mDetector!!.onTouchEvent(ev)
+            processTouchEvent(ev)
+        } catch (e: IllegalArgumentException) {
+            // Fix for support lib bug, happening when onDestroy is called
+            true
+        }
+    }
+
+    private fun processTouchEvent(ev: MotionEvent): Boolean {
+        val action = ev.action
+        when (action and MotionEvent.ACTION_MASK) {
+            MotionEvent.ACTION_DOWN -> {
+                mActivePointerId = ev.getPointerId(0)
+                mVelocityTracker = VelocityTracker.obtain()
+                if (null != mVelocityTracker) {
+                    mVelocityTracker!!.addMovement(ev)
+                }
+                mLastTouchX = getActiveX(ev)
+                mLastTouchY = getActiveY(ev)
+                isDragging = false
+            }
+            MotionEvent.ACTION_MOVE -> {
+                val x = getActiveX(ev)
+                val y = getActiveY(ev)
+                val dx = x - mLastTouchX
+                val dy = y - mLastTouchY
+                if (!isDragging) {
+                    // Use Pythagoras to see if drag length is larger than
+                    // touch slop
+                    isDragging = Math.sqrt(dx * dx + (dy * dy).toDouble()) >= mTouchSlop
+                }
+                if (isDragging) {
+                    mListener.onDrag(dx, dy)
+                    mLastTouchX = x
+                    mLastTouchY = y
+                    if (null != mVelocityTracker) {
+                        mVelocityTracker!!.addMovement(ev)
+                    }
+                }
+            }
+            MotionEvent.ACTION_CANCEL -> {
+                mActivePointerId = INVALID_POINTER_ID
+                // Recycle Velocity Tracker
+                if (null != mVelocityTracker) {
+                    mVelocityTracker!!.recycle()
+                    mVelocityTracker = null
+                }
+            }
+            MotionEvent.ACTION_UP -> {
+                mActivePointerId = INVALID_POINTER_ID
+                if (isDragging) {
+                    if (null != mVelocityTracker) {
+                        mLastTouchX = getActiveX(ev)
+                        mLastTouchY = getActiveY(ev)
+
+                        // Compute velocity within the last 1000ms
+                        mVelocityTracker!!.addMovement(ev)
+                        mVelocityTracker!!.computeCurrentVelocity(1000)
+                        val vX = mVelocityTracker!!.xVelocity
+                        val vY = mVelocityTracker!!
+                                .yVelocity
+
+                        // If the velocity is greater than minVelocity, call
+                        // listener
+                        if (Math.max(Math.abs(vX), Math.abs(vY)) >= mMinimumVelocity) {
+                            mListener.onFling(mLastTouchX, mLastTouchY, -vX,
+                                    -vY)
+                        }
+                    }
+                }
+
+                // Recycle Velocity Tracker
+                if (null != mVelocityTracker) {
+                    mVelocityTracker!!.recycle()
+                    mVelocityTracker = null
+                }
+            }
+            MotionEvent.ACTION_POINTER_UP -> {
+                val pointerIndex = Util.getPointerIndex(ev.action)
+                val pointerId = ev.getPointerId(pointerIndex)
+                if (pointerId == mActivePointerId) {
+                    // This was our active pointer going up. Choose a new
+                    // active pointer and adjust accordingly.
+                    val newPointerIndex = if (pointerIndex == 0) 1 else 0
+                    mActivePointerId = ev.getPointerId(newPointerIndex)
+                    mLastTouchX = ev.getX(newPointerIndex)
+                    mLastTouchY = ev.getY(newPointerIndex)
+                }
+            }
+        }
+        mActivePointerIndex = ev
+                .findPointerIndex(if (mActivePointerId != INVALID_POINTER_ID) mActivePointerId else 0)
+        return true
+    }
+
+    companion object {
+        private const val INVALID_POINTER_ID = -1
+    }
+
+    constructor(context: Context?, listener: OnGestureListener) : this() {
+        val configuration = ViewConfiguration.get(context)
+        mMinimumVelocity = configuration.scaledMinimumFlingVelocity.toFloat()
+        mTouchSlop = configuration.scaledTouchSlop.toFloat()
+        mListener = listener
+        val mScaleListener: OnScaleGestureListener = object : OnScaleGestureListener {
+            override fun onScale(detector: ScaleGestureDetector): Boolean {
+                val scaleFactor = detector.scaleFactor
+                if (java.lang.Float.isNaN(scaleFactor) || java.lang.Float.isInfinite(scaleFactor)) return false
+                if (scaleFactor >= 0) {
+                    mListener.onScale(scaleFactor,
+                            detector.focusX, detector.focusY)
+                }
+                return true
+            }
+
+            override fun onScaleBegin(detector: ScaleGestureDetector): Boolean {
+                return true
+            }
+
+            override fun onScaleEnd(detector: ScaleGestureDetector) {
+                // NO-OP
+            }
+        }
+        mDetector = ScaleGestureDetector(context, mScaleListener)
+    }
+}

photoview/OnGestureListener.kt

@@ -0,0 +1,24 @@
+/*
+ Copyright 2011, 2012 Chris Banes.
+
+ 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.
+ */
+package com.github.chrisbanes.photoview
+
+internal interface OnGestureListener {
+    fun onDrag(dx: Float, dy: Float)
+    fun onFling(startX: Float, startY: Float, velocityX: Float,
+                velocityY: Float)
+
+    fun onScale(scaleFactor: Float, focusX: Float, focusY: Float)
+}

photoview/OnMatrixChangedListener.kt

@@ -0,0 +1,17 @@
+package com.github.chrisbanes.photoview
+
+import android.graphics.RectF
+
+/**
+ * Interface definition for a callback to be invoked when the internal Matrix has changed for
+ * this View.
+ */
+interface OnMatrixChangedListener {
+    /**
+     * Callback for when the Matrix displaying the Drawable has changed. This could be because
+     * the View's bounds have changed, or the user has zoomed.
+     *
+     * @param rect - Rectangle displaying the Drawable's new bounds.
+     */
+    fun onMatrixChanged(rect: RectF)
+}

photoview/OnOutsidePhotoTapListener.kt

@@ -0,0 +1,13 @@
+package com.github.chrisbanes.photoview
+
+import android.widget.ImageView
+
+/**
+ * Callback when the user tapped outside of the photo
+ */
+interface OnOutsidePhotoTapListener {
+    /**
+     * The outside of the photo has been tapped
+     */
+    fun onOutsidePhotoTap(imageView: ImageView?)
+}

photoview/OnPhotoTapListener.kt

@@ -0,0 +1,21 @@
+package com.github.chrisbanes.photoview
+
+import android.widget.ImageView
+
+/**
+ * A callback to be invoked when the Photo is tapped with a single
+ * tap.
+ */
+interface OnPhotoTapListener {
+    /**
+     * A callback to receive where the user taps on a photo. You will only receive a callback if
+     * the user taps on the actual photo, tapping on 'whitespace' will be ignored.
+     *
+     * @param view ImageView the user tapped.
+     * @param x    where the user tapped from the of the Drawable, as percentage of the
+     * Drawable width.
+     * @param y    where the user tapped from the top of the Drawable, as percentage of the
+     * Drawable height.
+     */
+    fun onPhotoTap(view: ImageView?, x: Float, y: Float)
+}

photoview/OnScaleChangedListener.kt

@@ -0,0 +1,15 @@
+package com.github.chrisbanes.photoview
+
+/**
+ * Interface definition for callback to be invoked when attached ImageView scale changes
+ */
+interface OnScaleChangedListener {
+    /**
+     * Callback for when the scale changes
+     *
+     * @param scaleFactor the scale factor (less than 1 for zoom out, greater than 1 for zoom in)
+     * @param focusX      focal point X position
+     * @param focusY      focal point Y position
+     */
+    fun onScaleChange(scaleFactor: Float, focusX: Float, focusY: Float)
+}

photoview/OnSingleFlingListener.kt

@@ -0,0 +1,20 @@
+package com.github.chrisbanes.photoview
+
+import android.view.MotionEvent
+
+/**
+ * A callback to be invoked when the ImageView is flung with a single
+ * touch
+ */
+interface OnSingleFlingListener {
+    /**
+     * A callback to receive where the user flings on a ImageView. You will receive a callback if
+     * the user flings anywhere on the view.
+     *
+     * @param e1        MotionEvent the user first touch.
+     * @param e2        MotionEvent the user last touch.
+     * @param velocityX distance of user's horizontal fling.
+     * @param velocityY distance of user's vertical fling.
+     */
+    fun onFling(e1: MotionEvent?, e2: MotionEvent?, velocityX: Float, velocityY: Float): Boolean
+}

photoview/OnViewDragListener.kt

@@ -0,0 +1,15 @@
+package com.github.chrisbanes.photoview
+
+/**
+ * Interface definition for a callback to be invoked when the photo is experiencing a drag event
+ */
+interface OnViewDragListener {
+    /**
+     * Callback for when the photo is experiencing a drag event. This cannot be invoked when the
+     * user is scaling.
+     *
+     * @param dx The change of the coordinates in the x-direction
+     * @param dy The change of the coordinates in the y-direction
+     */
+    fun onDrag(dx: Float, dy: Float)
+}

photoview/OnViewTapListener.kt

@@ -0,0 +1,15 @@
+package com.github.chrisbanes.photoview
+
+import android.view.View
+
+interface OnViewTapListener {
+    /**
+     * A callback to receive where the user taps on a ImageView. You will receive a callback if
+     * the user taps anywhere on the view, tapping on 'whitespace' will not be ignored.
+     *
+     * @param view - View the user tapped.
+     * @param x    - where the user tapped from the left of the View.
+     * @param y    - where the user tapped from the top of the View.
+     */
+    fun onViewTap(view: View?, x: Float, y: Float)
+}