Kotlin to Java Conversion: GestureDetector.SimpleOnGestureListener Implementation

private GestureDetector.SimpleOnGestureListener mGestureListener = new GestureDetector.SimpleOnGestureListener() {
    @Override
    public boolean onDown(MotionEvent e) {
        goToNearestOrigin();
        return true;
    }

    @Override
    public boolean onScroll(MotionEvent e1, MotionEvent e2, float distanceX, float distanceY) {
        // Check if view is zoomed.
        if (mIsZooming)
            return true;

        switch (mCurrentScrollDirection) {
            case NONE:
                // Allow scrolling only in one direction.
                mCurrentScrollDirection = Math.abs(distanceX) > Math.abs(distanceY) ?
                        (distanceX > 0 ? Direction.LEFT : Direction.RIGHT) : Direction.VERTICAL;
                break;
            case LEFT:
                // Change direction if there was enough change.
                if (Math.abs(distanceX) > Math.abs(distanceY) && distanceX < -mScaledTouchSlop) {
                    mCurrentScrollDirection = Direction.RIGHT;
                }
                break;
            case RIGHT:
                // Change direction if there was enough change.
                if (Math.abs(distanceX) > Math.abs(distanceY) && distanceX > mScaledTouchSlop) {
                    mCurrentScrollDirection = Direction.LEFT;
                }
                break;
            default:
                break;
        }

        // Calculate the new origin after scroll.
        switch (mCurrentScrollDirection) {
            case LEFT:
            case RIGHT:
                float minX = xMinLimit;
                float maxX = xMaxLimit;

                mDistanceDone = e2.getX() < 0 ? e2.getX() - e1.getX() : e1.getX() - e2.getX();

                if (mCurrentOrigin.x - distanceX * xScrollingSpeed > maxX)
                    mCurrentOrigin.x = maxX;
                else if (mCurrentOrigin.x - distanceX * xScrollingSpeed < minX)
                    mCurrentOrigin.x = minX;
                else
                    mCurrentOrigin.x -= distanceX * xScrollingSpeed;

                ViewCompat.postInvalidateOnAnimation(WeekView.this);
                break;
            case VERTICAL:
                float minY = yMinLimit;
                float maxY = yMaxLimit;
                if (mCurrentOrigin.y - distanceY > maxY)
                    mCurrentOrigin.y = maxY;
                else if (mCurrentOrigin.y - distanceY < minY)
                    mCurrentOrigin.y = minY;
                else
                    mCurrentOrigin.y -= distanceY;
                ViewCompat.postInvalidateOnAnimation(WeekView.this);
                break;
            default:
                break;
        }
        return true;
    }

    @Override
    public boolean onFling(MotionEvent e1, MotionEvent e2, float velocityX, float velocityY) {
        if (mIsZooming)
            return true;

        if ((mCurrentFlingDirection == Direction.LEFT && !isHorizontalFlingEnabled) ||
                (mCurrentFlingDirection == Direction.RIGHT && !isHorizontalFlingEnabled) ||
                (mCurrentFlingDirection == Direction.VERTICAL && !isVerticalFlingEnabled)) {
            return true;
        }

        mScroller.forceFinished(true);

        mCurrentFlingDirection = mCurrentScrollDirection;
        switch (mCurrentFlingDirection) {
            case LEFT:
            case RIGHT:
                if (!isScrollNumberOfVisibleDays) {
                    mScroller.fling((int) mCurrentOrigin.x, (int) mCurrentOrigin.y, (int) (velocityX * xScrollingSpeed), 0, (int) xMinLimit, (int) xMaxLimit, (int) yMinLimit, (int) yMaxLimit);
                }
                break;
            case VERTICAL:
                mScroller.fling((int) mCurrentOrigin.x, (int) mCurrentOrigin.y, 0, (int) velocityY, (int) xMinLimit, (int) xMaxLimit, (int) yMinLimit, (int) yMaxLimit);
                break;
            default:
                break;
        }

        ViewCompat.postInvalidateOnAnimation(WeekView.this);
        return true;
    }

    @Override
    public boolean onSingleTapConfirmed(MotionEvent e) {
        // If the tap was on an event then trigger the callback.
        if (eventRects != null && eventClickListener != null) {
            for (EventRect eventRect : eventRects) {
                if (newEventIdentifier != eventRect.event.id && eventRect.rectF != null && e.getX() > eventRect.rectF.left && e.getX() < eventRect.rectF.right && e.getY() > eventRect.rectF.top && e.getY() < eventRect.rectF.bottom) {
                    eventClickListener.onEventClick(eventRect.originalEvent, eventRect.rectF);
                    playSoundEffect(SoundEffectConstants.CLICK);
                    return super.onSingleTapConfirmed(e);
                }
            }
        }
        float xOffset = xStartPixel;
        float x = e.getX() - xOffset;
        float y = e.getY() - mCurrentOrigin.y;
        // If the tap was on add new Event space, then trigger the callback
        if (addEventClickListener != null && mNewEventRect != null && mNewEventRect.rectF != null &&
                mNewEventRect.rectF.contains(x, y)) {
            addEventClickListener.onAddEventClicked(mNewEventRect.event.startTime, mNewEventRect.event.endTime);
            return super.onSingleTapConfirmed(e);
        }
        // If the tap was on an empty space, then trigger the callback.
        if ((emptyViewClickListener != null || addEventClickListener != null) && e.getX() > mHeaderColumnWidth && e.getY() > headerHeight + weekDaysHeaderRowTotalPadding + spaceBelowAllDayEvents) {
            Calendar selectedTime = getTimeFromPoint(e.getX(), e.getY());
            if (selectedTime != null) {
                ArrayList<WeekViewEvent> tempEvents = new ArrayList<>(mEvents);
                if (mNewEventRect != null) {
                    tempEvents.remove(mNewEventRect.event);
                    mNewEventRect = null;
                }
                playSoundEffect(SoundEffectConstants.CLICK);
                if (emptyViewClickListener != null)
                    emptyViewClickListener.onEmptyViewClicked((Calendar) selectedTime.clone());
                if (addEventClickListener != null) {
                    //round selectedTime to resolution
                    selectedTime.add(Calendar.MINUTE, -(newEventLengthInMinutes / 2));
                    //Fix selected time if before the minimum hour
                    if (selectedTime.get(Calendar.HOUR_OF_DAY) < mMinTime) {
                        selectedTime.se