widget/helper/ItemTouchHelperTest.java

/*
 * Copyright (C) 2015 The Android Open Source Project
 *
 * 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 android.support.v7.widget.helper;

import android.app.Instrumentation;
import android.os.Debug;
import android.os.SystemClock;
import android.support.v4.view.ViewCompat;
import android.support.v7.widget.BaseRecyclerViewInstrumentationTest;
import android.support.v7.widget.RecyclerView;
import android.support.v7.widget.WrappedRecyclerView;
import android.test.InstrumentationTestCase;
import android.view.Gravity;
import android.view.MotionEvent;
import android.view.View;
import android.view.ViewConfiguration;
import android.view.ViewGroup;

import java.util.ArrayList;
import java.util.List;

import static android.support.v7.widget.helper.ItemTouchHelper.*;

public class ItemTouchHelperTest extends BaseRecyclerViewInstrumentationTest {

    TestAdapter mAdapter;

    TestLayoutManager mLayoutManager;

    private LoggingCalback mCalback;

    private LoggingItemTouchHelper mItemTouchHelper;

    private WrappedRecyclerView mWrappedRecyclerView;

    private Boolean mSetupRTL;

    public ItemTouchHelperTest() {
        super(false);
    }

    private RecyclerView setup(int dragDirs, int swipeDirs) throws Throwable {
        mWrappedRecyclerView = inflateWrappedRV();
        mAdapter = new TestAdapter(10);
        mLayoutManager = new TestLayoutManager() {
            @Override
            public void onLayoutChildren(RecyclerView.Recycler recycler, RecyclerView.State state) {
                detachAndScrapAttachedViews(recycler);
                layoutRange(recycler, 0, Math.min(5, state.getItemCount()));
                layoutLatch.countDown();
            }

            @Override
            public boolean canScrollHorizontally() {
                return false;
            }

            @Override
            public boolean supportsPredictiveItemAnimations() {
                return false;
            }
        };
        mWrappedRecyclerView.setFakeRTL(mSetupRTL);
        mWrappedRecyclerView.setAdapter(mAdapter);
        mWrappedRecyclerView.setLayoutManager(mLayoutManager);
        mCalback = new LoggingCalback(dragDirs, swipeDirs);
        mItemTouchHelper = new LoggingItemTouchHelper(mCalback);
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                mItemTouchHelper.attachToRecyclerView(mWrappedRecyclerView);
            }
        });

        return mWrappedRecyclerView;
    }

    public void testSwipeLeft() throws Throwable {
        basicSwipeTest(LEFT, LEFT | RIGHT, -getActivity().getWindow().getDecorView().getWidth());
    }

    public void testSwipeRight() throws Throwable {
        basicSwipeTest(RIGHT, LEFT | RIGHT, getActivity().getWindow().getDecorView().getWidth());
    }

    public void testSwipeStart() throws Throwable {
        basicSwipeTest(START, START | END, -getActivity().getWindow().getDecorView().getWidth());
    }

    public void testSwipeEnd() throws Throwable {
        basicSwipeTest(END, START | END, getActivity().getWindow().getDecorView().getWidth());
    }

    public void testSwipeStartInRTL() throws Throwable {
        mSetupRTL = true;
        basicSwipeTest(START, START | END, getActivity().getWindow().getDecorView().getWidth());
    }

    public void testSwipeEndInRTL() throws Throwable {
        mSetupRTL = true;
        basicSwipeTest(END, START | END, -getActivity().getWindow().getDecorView().getWidth());
    }

    private void setLayoutDirection(final View view, final int layoutDir) throws Throwable {
        runTestOnUiThread(new Runnable() {
            @Override
            public void run() {
                ViewCompat.setLayoutDirection(view, layoutDir);
            }
        });
    }

    public void basicSwipeTest(int dir, int swipeDirs, int targetX) throws Throwable {
        final RecyclerView recyclerView = setup(0, swipeDirs);
        mLayoutManager.expectLayouts(1);
        setRecyclerView(recyclerView);
        mLayoutManager.waitForLayout(1);

        final RecyclerView.ViewHolder target = mRecyclerView
                .findViewHolderForAdapterPosition(1);
        TouchUtils.dragViewToX(this, target.itemView, Gravity.CENTER, targetX);
        Thread.sleep(100); //wait for animation end
        final SwipeRecord swipe = mCalback.getSwipe(target);
        assertNotNull(swipe);
        assertEquals(dir, swipe.dir);
        assertEquals(1, mItemTouchHelper.mRecoverAnimations.size());
        assertEquals(1, mItemTouchHelper.mPendingCleanup.size());
        // get rid of the view
        mLayoutManager.expectLayouts(1);
        mAdapter.deleteAndNotify(1, 1);
        mLayoutManager.waitForLayout(1);
        waitForAnimations();
        assertEquals(0, mItemTouchHelper.mRecoverAnimations.size());
        assertEquals(0, mItemTouchHelper.mPendingCleanup.size());
        assertTrue(mCalback.isCleared(target));
    }

    private void waitForAnimations() throws InterruptedException {
        while (mRecyclerView.getItemAnimator().isRunning()) {
            Thread.sleep(100);
        }
    }

    private static class LoggingCalback extends SimpleCallback {

        private List<MoveRecord> mMoveRecordList = new ArrayList<MoveRecord>();

        private List<SwipeRecord> mSwipeRecords = new ArrayList<SwipeRecord>();

        private List<RecyclerView.ViewHolder> mCleared = new ArrayList<RecyclerView.ViewHolder>();

        public LoggingCalback(int dragDirs, int swipeDirs) {
            super(dragDirs, swipeDirs);
        }

        @Override
        public boolean onMove(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder,
                RecyclerView.ViewHolder target) {
            mMoveRecordList.add(new MoveRecord(viewHolder, target));
            return true;
        }

        @Override
        public void onSwiped(RecyclerView.ViewHolder viewHolder, int direction) {
            mSwipeRecords.add(new SwipeRecord(viewHolder, direction));
        }

        public MoveRecord getMove(RecyclerView.ViewHolder vh) {
            for (MoveRecord move : mMoveRecordList) {
                if (move.from == vh) {
                    return move;
                }
            }
            return null;
        }

        @Override
        public void clearView(RecyclerView recyclerView, RecyclerView.ViewHolder viewHolder) {
            super.clearView(recyclerView, viewHolder);
            mCleared.add(viewHolder);
        }

        public SwipeRecord getSwipe(RecyclerView.ViewHolder vh) {
            for (SwipeRecord swipe : mSwipeRecords) {
                if (swipe.viewHolder == vh) {
                    return swipe;
                }
            }
            return null;
        }

        public boolean isCleared(RecyclerView.ViewHolder vh) {
            return mCleared.contains(vh);
        }
    }

    private static class LoggingItemTouchHelper extends ItemTouchHelper {

        public LoggingItemTouchHelper(Callback callback) {
            super(callback);
        }
    }

    private static class SwipeRecord {

        RecyclerView.ViewHolder viewHolder;

        int dir;

        public SwipeRecord(RecyclerView.ViewHolder viewHolder, int dir) {
            this.viewHolder = viewHolder;
            this.dir = dir;
        }
    }

    private static class MoveRecord {

        final int fromPos, toPos;

        RecyclerView.ViewHolder from, to;

        public MoveRecord(RecyclerView.ViewHolder from,
                RecyclerView.ViewHolder to) {
            this.from = from;
            this.to = to;
            fromPos = from.getAdapterPosition();
            toPos = to.getAdapterPosition();
        }
    }


    /**
     * RecyclerView specific TouchUtils.
     */
    static class TouchUtils {

        /**
         * Simulate touching the center of a view and releasing quickly (before the tap timeout).
         *
         * @param test The test case that is being run
         * @param v    The view that should be clicked
         */
        public static void tapView(InstrumentationTestCase test, RecyclerView recyclerView,
                View v) {
            int[] xy = new int[2];
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            final float x = xy[0] + (viewWidth / 2.0f);
            float y = xy[1] + (viewHeight / 2.0f);

            long downTime = SystemClock.uptimeMillis();
            long eventTime = SystemClock.uptimeMillis();

            MotionEvent event = MotionEvent.obtain(downTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y, 0);
            Instrumentation inst = test.getInstrumentation();
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            final int touchSlop = ViewConfiguration.get(v.getContext()).getScaledTouchSlop();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE,
                    x + (touchSlop / 2.0f), y + (touchSlop / 2.0f), 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();
        }

        /**
         * Simulate touching the center of a view and cancelling (so no onClick should
         * fire, etc).
         *
         * @param test The test case that is being run
         * @param v    The view that should be clicked
         */
        public static void touchAndCancelView(InstrumentationTestCase test, View v) {
            int[] xy = new int[2];
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            final float x = xy[0] + (viewWidth / 2.0f);
            float y = xy[1] + (viewHeight / 2.0f);

            Instrumentation inst = test.getInstrumentation();

            long downTime = SystemClock.uptimeMillis();
            long eventTime = SystemClock.uptimeMillis();

            MotionEvent event = MotionEvent.obtain(downTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            final int touchSlop = ViewConfiguration.get(v.getContext()).getScaledTouchSlop();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_CANCEL,
                    x + (touchSlop / 2.0f), y + (touchSlop / 2.0f), 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

        }

        /**
         * Simulate touching the center of a view and releasing.
         *
         * @param test The test case that is being run
         * @param v    The view that should be clicked
         */
        public static void clickView(InstrumentationTestCase test, View v) {
            int[] xy = new int[2];
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            final float x = xy[0] + (viewWidth / 2.0f);
            float y = xy[1] + (viewHeight / 2.0f);

            Instrumentation inst = test.getInstrumentation();

            long downTime = SystemClock.uptimeMillis();
            long eventTime = SystemClock.uptimeMillis();

            MotionEvent event = MotionEvent.obtain(downTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            final int touchSlop = ViewConfiguration.get(v.getContext()).getScaledTouchSlop();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE,
                    x + (touchSlop / 2.0f), y + (touchSlop / 2.0f), 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            try {
                Thread.sleep(1000);
            } catch (InterruptedException e) {
                e.printStackTrace();
            }
        }

        /**
         * Simulate touching the center of a view, holding until it is a long press, and then
         * releasing.
         *
         * @param test The test case that is being run
         * @param v    The view that should be clicked
         */
        public static void longClickView(InstrumentationTestCase test, View v) {
            int[] xy = new int[2];
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            final float x = xy[0] + (viewWidth / 2.0f);
            float y = xy[1] + (viewHeight / 2.0f);

            Instrumentation inst = test.getInstrumentation();

            long downTime = SystemClock.uptimeMillis();
            long eventTime = SystemClock.uptimeMillis();

            MotionEvent event = MotionEvent.obtain(downTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            eventTime = SystemClock.uptimeMillis();
            final int touchSlop = ViewConfiguration.get(v.getContext()).getScaledTouchSlop();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE,
                    x + touchSlop / 2, y + touchSlop / 2, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();

            try {
                Thread.sleep((long) (ViewConfiguration.getLongPressTimeout() * 1.5f));
            } catch (InterruptedException e) {
                e.printStackTrace();
            }

            eventTime = SystemClock.uptimeMillis();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();
        }

        /**
         * Simulate touching the center of a view and dragging to the top of the screen.
         *
         * @param test The test case that is being run
         * @param v    The view that should be dragged
         */
        public static void dragViewToTop(InstrumentationTestCase test, View v) {
            dragViewToTop(test, v, 4);
        }

        /**
         * Simulate touching the center of a view and dragging to the top of the screen.
         *
         * @param test      The test case that is being run
         * @param v         The view that should be dragged
         * @param stepCount How many move steps to include in the drag
         */
        public static void dragViewToTop(InstrumentationTestCase test, View v, int stepCount) {
            int[] xy = new int[2];
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            final float x = xy[0] + (viewWidth / 2.0f);
            float fromY = xy[1] + (viewHeight / 2.0f);
            float toY = 0;

            drag(test, x, x, fromY, toY, stepCount);
        }

        /**
         * Get the location of a view. Use the gravity param to specify which part of the view to
         * return.
         *
         * @param v       View to find
         * @param gravity A combination of (TOP, CENTER_VERTICAL, BOTTOM) and (LEFT,
         *                CENTER_HORIZONTAL,
         *                RIGHT)
         * @param xy      Result
         */
        private static void getStartLocation(View v, int gravity, int[] xy) {
            v.getLocationOnScreen(xy);

            final int viewWidth = v.getWidth();
            final int viewHeight = v.getHeight();

            switch (gravity & Gravity.VERTICAL_GRAVITY_MASK) {
                case Gravity.TOP:
                    break;
                case Gravity.CENTER_VERTICAL:
                    xy[1] += viewHeight / 2;
                    break;
                case Gravity.BOTTOM:
                    xy[1] += viewHeight - 1;
                    break;
                default:
                    // Same as top -- do nothing
            }

            switch (gravity & Gravity.HORIZONTAL_GRAVITY_MASK) {
                case Gravity.LEFT:
                    break;
                case Gravity.CENTER_HORIZONTAL:
                    xy[0] += viewWidth / 2;
                    break;
                case Gravity.RIGHT:
                    xy[0] += viewWidth - 1;
                    break;
                default:
                    // Same as left -- do nothing
            }
        }

        /**
         * Simulate touching a view and dragging it to a specified location.
         *
         * @param test    The test case that is being run
         * @param v       The view that should be dragged
         * @param gravity Which part of the view to use for the initial down event. A combination
         *                of
         *                (TOP, CENTER_VERTICAL, BOTTOM) and (LEFT, CENTER_HORIZONTAL, RIGHT)
         * @param toX     Final location of the view after dragging
         * @param toY     Final location of the view after dragging
         * @return distance in pixels covered by the drag
         */
        public static int dragViewTo(InstrumentationTestCase test, View v, int gravity, int toX,
                int toY) {
            int[] xy = new int[2];

            getStartLocation(v, gravity, xy);

            final int fromX = xy[0];
            final int fromY = xy[1];

            int deltaX = fromX - toX;
            int deltaY = fromY - toY;

            int distance = (int) Math.sqrt(deltaX * deltaX + deltaY * deltaY);
            drag(test, fromX, toX, fromY, toY, distance);

            return distance;
        }

        /**
         * Simulate touching a view and dragging it to a specified location. Only moves
         * horizontally.
         *
         * @param test    The test case that is being run
         * @param v       The view that should be dragged
         * @param gravity Which part of the view to use for the initial down event. A combination
         *                of
         *                (TOP, CENTER_VERTICAL, BOTTOM) and (LEFT, CENTER_HORIZONTAL, RIGHT)
         * @param toX     Final location of the view after dragging
         * @return distance in pixels covered by the drag
         */
        public static int dragViewToX(InstrumentationTestCase test, View v, int gravity, int toX) {
            int[] xy = new int[2];

            getStartLocation(v, gravity, xy);

            final int fromX = xy[0];
            final int fromY = xy[1];

            int deltaX = fromX - toX;

            drag(test, fromX, toX, fromY, fromY, Math.max(10, Math.abs(deltaX) / 10));

            return deltaX;
        }

        /**
         * Simulate touching a view and dragging it to a specified location. Only moves vertically.
         *
         * @param test    The test case that is being run
         * @param v       The view that should be dragged
         * @param gravity Which part of the view to use for the initial down event. A combination
         *                of
         *                (TOP, CENTER_VERTICAL, BOTTOM) and (LEFT, CENTER_HORIZONTAL, RIGHT)
         * @param toY     Final location of the view after dragging
         * @return distance in pixels covered by the drag
         */
        public static int dragViewToY(InstrumentationTestCase test, View v, int gravity, int toY) {
            int[] xy = new int[2];

            getStartLocation(v, gravity, xy);

            final int fromX = xy[0];
            final int fromY = xy[1];

            int deltaY = fromY - toY;

            drag(test, fromX, fromX, fromY, toY, deltaY);

            return deltaY;
        }


        /**
         * Simulate touching a specific location and dragging to a new location.
         *
         * @param test      The test case that is being run
         * @param fromX     X coordinate of the initial touch, in screen coordinates
         * @param toX       Xcoordinate of the drag destination, in screen coordinates
         * @param fromY     X coordinate of the initial touch, in screen coordinates
         * @param toY       Y coordinate of the drag destination, in screen coordinates
         * @param stepCount How many move steps to include in the drag
         */
        public static void drag(InstrumentationTestCase test, float fromX, float toX, float fromY,
                float toY, int stepCount) {
            Instrumentation inst = test.getInstrumentation();

            long downTime = SystemClock.uptimeMillis();
            long eventTime = SystemClock.uptimeMillis();

            float y = fromY;
            float x = fromX;

            float yStep = (toY - fromY) / stepCount;
            float xStep = (toX - fromX) / stepCount;

            MotionEvent event = MotionEvent.obtain(downTime, eventTime,
                    MotionEvent.ACTION_DOWN, x, y, 0);
            inst.sendPointerSync(event);
            for (int i = 0; i < stepCount; ++i) {
                y += yStep;
                x += xStep;
                eventTime = SystemClock.uptimeMillis();
                event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_MOVE, x, y, 0);
                inst.sendPointerSync(event);
            }

            eventTime = SystemClock.uptimeMillis();
            event = MotionEvent.obtain(downTime, eventTime, MotionEvent.ACTION_UP, x, y, 0);
            inst.sendPointerSync(event);
            inst.waitForIdleSync();
        }
    }

}