/*
 * Copyright (C) 2020 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 com.android.car.rotary;

import static org.testng.Assert.assertEquals;
import static org.testng.Assert.fail;
import static org.testng.AssertJUnit.assertFalse;
import static org.testng.AssertJUnit.assertTrue;

import android.graphics.Rect;
import android.view.View;

import androidx.test.ext.junit.runners.AndroidJUnit4;

import org.junit.Test;
import org.junit.runner.RunWith;

/** Most of the tests are copied from {@link android.view.FocusFinderTest}. */
@RunWith(AndroidJUnit4.class)
public class FocusFinderTest {

    @Test
    public void testPartiallyInDirection() {
        final Rect src = new Rect(100, 100, 200, 200);

        assertIsPartiallyInDirection(View.FOCUS_LEFT, src,
                new Rect(199, 50, 300, 60));
        assertIsPartiallyInDirection(View.FOCUS_RIGHT, src,
                new Rect(0, 50, 101, 60));
        assertIsPartiallyInDirection(View.FOCUS_UP, src,
                new Rect(50, 199, 60, 300));
        assertIsPartiallyInDirection(View.FOCUS_DOWN, src,
                new Rect(50, 0, 60, 101));
    }

    @Test
    public void testInDirection() {
        final Rect src = new Rect(100, 100, 200, 200);

        // Strictly in the given direction.
        assertIsInDirection(View.FOCUS_LEFT, src, new Rect(99, 100, 200, 200));
        assertIsInDirection(View.FOCUS_RIGHT, src, new Rect(100, 99, 201, 200));
        assertIsInDirection(View.FOCUS_UP, src, new Rect(101, 99, 199, 200));
        assertIsInDirection(View.FOCUS_DOWN, src, new Rect(99, 100, 201, 201));

        // Loosely in the given direction.
        assertIsInDirection(View.FOCUS_LEFT, src, new Rect(0, 0, 50, 50));
        assertIsInDirection(View.FOCUS_RIGHT, src, new Rect(250, 50, 300, 150));
        assertIsInDirection(View.FOCUS_UP, src, new Rect(250, 50, 300, 150));
        assertIsInDirection(View.FOCUS_DOWN, src, new Rect(50, 150, 150, 250));
    }

    @Test
    public void testNotInDirection() {
        final Rect src = new Rect(100, 100, 200, 200);

        // None of destRect is in the given direction of srcRect.
        assertIsNotInDirection(View.FOCUS_LEFT, src, new Rect(100, 300, 150, 400));
        assertIsNotInDirection(View.FOCUS_RIGHT, src, new Rect(150, 300, 200, 400));
        assertIsNotInDirection(View.FOCUS_UP, src, new Rect(300, 100, 400, 150));
        assertIsNotInDirection(View.FOCUS_DOWN, src, new Rect(300, 150, 400, 200));

        // destRect is strictly in other direction of srcRect.
        assertIsNotInDirection(View.FOCUS_LEFT, src, new Rect(0, 0, 200, 50));
        assertIsNotInDirection(View.FOCUS_RIGHT, src, new Rect(100, 300, 300, 400));
        assertIsNotInDirection(View.FOCUS_UP, src, new Rect(50, 0, 150, 200));
        assertIsNotInDirection(View.FOCUS_DOWN, src, new Rect(50, 100, 150, 300));
    }

    @Test
    public void testBelowNotCandidateForDirectionUp() {
        assertIsNotCandidate(View.FOCUS_UP,
                new Rect(0, 30, 10, 40),   // src  (left, top, right, bottom)
                new Rect(0, 50, 10, 60));  // dest (left, top, right, bottom)
    }

    @Test
    public void testAboveShareEdgeEdgeOkForDirectionUp() {
        final Rect src = new Rect(0, 30, 10, 40);

        final Rect dest = new Rect(src);
        dest.offset(0, -src.height());
        assertEquals(src.top, dest.bottom);

        assertDirectionIsCandidate(View.FOCUS_UP, src, dest);
    }

    @Test
    public void testCompletelyContainedNotCandidate() {
        assertIsNotCandidate(
                View.FOCUS_DOWN,
                //       L  T   R   B
                new Rect(0, 0, 50, 50),
                new Rect(0, 1, 50, 49));
    }

    @Test
    public void testContainedWithCommonBottomNotCandidate() {
        assertIsNotCandidate(
                View.FOCUS_DOWN,
                //       L  T   R   B
                new Rect(0, 0, 50, 50),
                new Rect(0, 1, 50, 50));
    }

    @Test
    public void testOverlappingIsCandidateWhenBothEdgesAreInDirection() {
        assertDirectionIsCandidate(
                View.FOCUS_DOWN,
                //       L  T   R   B
                new Rect(0, 0, 50, 50),
                new Rect(0, 1, 50, 51));
    }

    @Test
    public void testTopEdgeOfDestAtOrAboveTopOfSrcNotCandidateForDown() {
        assertIsNotCandidate(
                View.FOCUS_DOWN,
                //       L  T   R   B
                new Rect(0, 0, 50, 50),
                new Rect(0, 0, 50, 51));

        assertIsNotCandidate(
                View.FOCUS_DOWN,
                //       L  T   R   B
                new Rect(0, 0, 50, 50),
                new Rect(0, -1, 50, 51));
    }

    @Test
    public void testSameRectBeamsOverlap() {
        final Rect rect = new Rect(0, 0, 20, 20);

        assertBeamsOverlap(View.FOCUS_LEFT, rect, rect);
        assertBeamsOverlap(View.FOCUS_RIGHT, rect, rect);
        assertBeamsOverlap(View.FOCUS_UP, rect, rect);
        assertBeamsOverlap(View.FOCUS_DOWN, rect, rect);
    }

    @Test
    public void testOverlapBeamsRightLeftUpToEdge() {
        final Rect rect1 = new Rect(0, 0, 20, 20);
        final Rect rect2 = new Rect(rect1);

        // Just below bottom edge.
        rect2.offset(0, rect1.height() - 1);
        assertBeamsOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsOverlap(View.FOCUS_RIGHT, rect1, rect2);

        // At edge.
        rect2.offset(0, 1);
        assertBeamsDontOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_RIGHT, rect1, rect2);

        // Just beyond.
        rect2.offset(0, 1);
        assertBeamsDontOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_RIGHT, rect1, rect2);

        // Just below top edge.
        rect2.set(rect1);
        rect2.offset(0, -(rect1.height() - 1));
        assertBeamsOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsOverlap(View.FOCUS_RIGHT, rect1, rect2);

        // At top edge.
        rect2.offset(0, -1);
        assertBeamsDontOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_RIGHT, rect1, rect2);

        // Just beyond top edge.
        rect2.offset(0, -1);
        assertBeamsDontOverlap(View.FOCUS_LEFT, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_RIGHT, rect1, rect2);
    }

    @Test
    public void testOverlapBeamsUpDownUpToEdge() {
        final Rect rect1 = new Rect(0, 0, 20, 20);
        final Rect rect2 = new Rect(rect1);

        // Just short of right edge.
        rect2.offset(rect1.width() - 1, 0);
        assertBeamsOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsOverlap(View.FOCUS_DOWN, rect1, rect2);

        // At edge.
        rect2.offset(1, 0);
        assertBeamsDontOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_DOWN, rect1, rect2);

        // Just beyond.
        rect2.offset(1, 0);
        assertBeamsDontOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_DOWN, rect1, rect2);

        // Just short of left edge.
        rect2.set(rect1);
        rect2.offset(-(rect1.width() - 1), 0);
        assertBeamsOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsOverlap(View.FOCUS_DOWN, rect1, rect2);

        // At edge.
        rect2.offset(-1, 0);
        assertBeamsDontOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_DOWN, rect1, rect2);

        // Just beyond edge.
        rect2.offset(-1, 0);
        assertBeamsDontOverlap(View.FOCUS_UP, rect1, rect2);
        assertBeamsDontOverlap(View.FOCUS_DOWN, rect1, rect2);
    }

    @Test
    public void testDirectlyAboveTrumpsAboveLeft() {
        Rect src = new Rect(0, 50, 20, 70);  // src (left, top, right, bottom)

        Rect directlyAbove = new Rect(src);
        directlyAbove.offset(0, -(1 + src.height()));

        Rect aboveLeft = new Rect(src);
        aboveLeft.offset(-(1 + src.width()), -(1 + src.height()));

        assertBetterCandidate(View.FOCUS_UP, src, directlyAbove, aboveLeft);
    }

    @Test
    public void testAboveInBeamTrumpsSlightlyCloserOutOfBeam() {
        Rect src = new Rect(0, 50, 20, 70);  // src (left, top, right, bottom)

        Rect directlyAbove = new Rect(src);
        directlyAbove.offset(0, -(1 + src.height()));

        Rect aboveLeft = new Rect(src);
        aboveLeft.offset(-(1 + src.width()), -(1 + src.height()));

        // Offset directly above a little further up.
        directlyAbove.offset(0, -5);
        assertBetterCandidate(View.FOCUS_UP, src, directlyAbove, aboveLeft);
    }

    @Test
    public void testOutOfBeamBeatsInBeamUp() {

        Rect src = new Rect(0, 0, 50, 50); // (left, top, right, bottom)

        Rect aboveLeftOfBeam = new Rect(src);
        aboveLeftOfBeam.offset(-(src.width() + 1), -src.height());
        assertBeamsDontOverlap(View.FOCUS_UP, src, aboveLeftOfBeam);

        Rect aboveInBeam = new Rect(src);
        aboveInBeam.offset(0, -src.height());
        assertBeamsOverlap(View.FOCUS_UP, src, aboveInBeam);

        // In beam wins.
        assertBetterCandidate(View.FOCUS_UP, src, aboveInBeam, aboveLeftOfBeam);

        // Still wins while aboveInBeam's bottom edge is < out of beams' top.
        aboveInBeam.offset(0, -(aboveLeftOfBeam.height() - 1));
        assertTrue("aboveInBeam.bottom > aboveLeftOfBeam.top",
                aboveInBeam.bottom > aboveLeftOfBeam.top);
        assertBetterCandidate(View.FOCUS_UP, src, aboveInBeam, aboveLeftOfBeam);

        // Cross the threshold: the out of beam prevails.
        aboveInBeam.offset(0, -1);
        assertEquals(aboveInBeam.bottom, aboveLeftOfBeam.top);
        assertBetterCandidate(View.FOCUS_UP, src, aboveLeftOfBeam, aboveInBeam);
    }

    /** A non-candidate is not excluded when searching for a better candidate. */
    @Test
    public void testNonCandidateCanBeBetterCandidate() {
        Rect src = new Rect(0, 0, 50, 50); // (left, top, right, bottom)

        Rect nonCandidate = new Rect(src);
        nonCandidate.offset(src.width() + 1, 0);

        assertIsNotCandidate(View.FOCUS_LEFT, src, nonCandidate);

        Rect candidate = new Rect(src);
        candidate.offset(-(4 * src.width()), 0);
        assertDirectionIsCandidate(View.FOCUS_LEFT, src, candidate);

        assertBetterCandidate(View.FOCUS_LEFT, src, nonCandidate, candidate);
    }

    /** Grabbed from {@link android.widget.focus.VerticalFocusSearchTest#testSearchFromMidLeft()} */
    @Test
    public void testVerticalFocusSearchScenario() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 109, 153, 169),    // src
                new Rect(166, 169, 319, 229),  // expected better
                new Rect(0, 229, 320, 289));   // expected worse

        // Failing test 4/10/2008, the values were tweaked somehow in functional test.
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 91, 153, 133),     // src
                new Rect(166, 133, 319, 175),  // expected better
                new Rect(0, 175, 320, 217));   // expected worse

    }

    /**
     * Example: going down from a thin button all the way to the left of a screen where, just below,
     * is a very wide button, and just below that, is an equally skinny button all the way to the
     * left. We want to make sure any minor axis factor doesn't override the fact that the one below
     * in vertical beam should be next focus.
     */
    @Test
    public void testBeamsOverlapMajorAxisCloserMinorAxisFurther() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L   T    R    B
                new Rect(0, 0, 100, 100),    // src
                new Rect(0, 100, 480, 200),  // expected better
                new Rect(0, 200, 100, 300)); // expected worse
    }

    /** Real scenario grabbed from song playback screen. */
    @Test
    public void testMusicPlaybackScenario() {
        assertBetterCandidate(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(227, 185, 312, 231),   // src
                new Rect(195, 386, 266, 438),   // expected better
                new Rect(124, 386, 195, 438));  // expected worse
    }

    /** More generalized version of {@link #testMusicPlaybackScenario()} */
    @Test
    public void testOutOfBeamOverlapBeatsOutOfBeamFurtherOnMajorAxis() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 0, 50, 50),      // src
                new Rect(60, 40, 110, 90),   // expected better
                new Rect(60, 70, 110, 120)); // expected worse
    }

    /**
     * Make sure that going down prefers views that are actually down (and not those next to but
     * still a candidate because they are overlapping on the major axis)
     */
    @Test
    public void testInBeamTrumpsOutOfBeamOverlapping() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 0, 50, 50),    // src
                new Rect(0, 60, 50, 110),  // expected better
                new Rect(51, 1, 101, 51)); // expected worse
    }

    @Test
    public void testOverlappingBeatsNonOverlapping() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 0, 50, 50),    // src
                new Rect(0, 40, 50, 90),   // expected better
                new Rect(0, 75, 50, 125)); // expected worse
    }

    @Test
    public void testEditContactScenarioLeftFromDiscardChangesGoesToSaveContactInLandscape() {
        assertBetterCandidate(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(357, 258, 478, 318),  // src
                new Rect(2, 258, 100, 318),    // better
                new Rect(106, 120, 424, 184)); // worse
    }

    /**
     * A dial pad with 9 squares arranged in a grid, no padding, so the edges are equal. See {@link
     * android.widget.focus.LinearLayoutGrid}.
     */
    @Test
    public void testGridWithTouchingEdges() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(106, 49, 212, 192),  // src
                new Rect(106, 192, 212, 335), // better
                new Rect(0, 192, 106, 335));  // worse

        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(106, 49, 212, 192),   // src
                new Rect(106, 192, 212, 335),  // better
                new Rect(212, 192, 318, 335)); // worse
    }

    @Test
    public void testSearchFromEmptyRect() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L   T    R    B
                new Rect(0, 0, 0, 0),       // src
                new Rect(0, 0, 320, 45),    // better
                new Rect(0, 45, 320, 545)); // worse
    }

    /**
     * Reproduce b/1124559, drilling down to actual bug (majorAxisDistance was wrong for direction
     * left).
     */
    @Test
    public void testGmailReplyButtonsScenario() {
        assertBetterCandidate(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(223, 380, 312, 417),  // src
                new Rect(102, 380, 210, 417),  // better
                new Rect(111, 443, 206, 480)); // worse

        assertBeamBeats(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(223, 380, 312, 417),  // src
                new Rect(102, 380, 210, 417),  // better
                new Rect(111, 443, 206, 480)); // worse

        assertBeamsOverlap(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(223, 380, 312, 417),
                new Rect(102, 380, 210, 417));

        assertBeamsDontOverlap(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(223, 380, 312, 417),
                new Rect(111, 443, 206, 480));

        assertTrue(
                "major axis distance less than major axis distance to far edge",
                FocusFinder.majorAxisDistance(View.FOCUS_LEFT,
                        //       L    T    R    B
                        new Rect(223, 380, 312, 417),
                        new Rect(102, 380, 210, 417)) <
                        FocusFinder.majorAxisDistanceToFarEdge(View.FOCUS_LEFT,
                                //       L    T    R    B
                                new Rect(223, 380, 312, 417),
                                new Rect(111, 443, 206, 480)));
    }

    @Test
    public void testGmailScenarioBug1203288() {
        assertBetterCandidate(View.FOCUS_DOWN,
                //       L    T    R    B
                new Rect(0, 2, 480, 82),     // src
                new Rect(344, 87, 475, 124), // better
                new Rect(0, 130, 480, 203)); // worse
    }

    @Test
    public void testHomeShortcutScenarioBug1295354() {
        assertBetterCandidate(View.FOCUS_RIGHT,
                //       L    T    R    B
                new Rect(3, 338, 77, 413),    // src
                new Rect(163, 338, 237, 413), // better
                new Rect(83, 38, 157, 113));  // worse
    }

    @Test
    public void testBeamAlwaysBeatsHoriz() {
        assertBetterCandidate(View.FOCUS_RIGHT,
                //       L    T    R    B
                new Rect(0, 0, 50, 50),       // src
                new Rect(150, 0, 200, 50),    // better(way further, but in beam)
                new Rect(60, 51, 110, 101));  // worse, even though it's closer

        assertBetterCandidate(View.FOCUS_LEFT,
                //       L    T    R    B
                new Rect(150, 0, 200, 50),    // src
                new Rect(0, 0, 50, 50),       // better (way further, but in beam)
                new Rect(49, 99, 149, 101));  // worse, even though it's closer
    }

    @Test
    public void testIsCandidateOverlappingEdgeFromEmptyRect() {
        assertDirectionIsCandidate(View.FOCUS_DOWN,
                //       L   T    R    B
                new Rect(0, 0, 0, 0),    // src
                new Rect(0, 0, 20, 1));  // candidate

        assertDirectionIsCandidate(View.FOCUS_UP,
                //       L   T    R    B
                new Rect(0, 0, 0, 0),    // src
                new Rect(0, -1, 20, 0)); // candidate

        assertDirectionIsCandidate(View.FOCUS_LEFT,
                //       L   T    R    B
                new Rect(0, 0, 0, 0),    // src
                new Rect(-1, 0, 0, 20)); // candidate

        assertDirectionIsCandidate(View.FOCUS_RIGHT,
                //       L   T    R    B
                new Rect(0, 0, 0, 0),    // src
                new Rect(0, 0, 1, 20));  // candidate
    }

    private void assertIsPartiallyInDirection(int direction, Rect src, Rect dest) {
        String directionStr = validateAndGetStringFor(direction);
        final String assertMsg = String.format(
                "expected %s is at least partially in direction %s of %s ",
                dest, directionStr, src);
        assertTrue(assertMsg, FocusFinder.isPartiallyInDirection(src, dest, direction));
    }

    private void assertIsInDirection(int direction, Rect src, Rect dest) {
        String directionStr = validateAndGetStringFor(direction);
        final String assertMsg = String.format("expected part of %s is in direction %s of %s ",
                dest, directionStr, src);
        assertTrue(assertMsg, FocusFinder.isInDirection(src, dest, direction));
    }

    private void assertIsNotInDirection(int direction, Rect src, Rect dest) {
        String directionStr = validateAndGetStringFor(direction);
        final String assertMsg = String.format("expected no part of %s is in direction %s of %s ",
                dest, directionStr, src);
        assertFalse(assertMsg, FocusFinder.isInDirection(src, dest, direction));
    }

    private void assertBeamsOverlap(int direction, Rect rect1, Rect rect2) {
        String directionStr = validateAndGetStringFor(direction);
        String assertMsg = String.format(
                "Expected beams to overlap in direction %s for rectangles %s and %s",
                directionStr, rect1, rect2);
        assertTrue(assertMsg, FocusFinder.beamsOverlap(direction, rect1, rect2));
    }

    private void assertBeamsDontOverlap(int direction, Rect rect1, Rect rect2) {
        String directionStr = validateAndGetStringFor(direction);
        String assertMsg = String.format(
                "Expected beams not to overlap in direction %s for rectangles %s and %s",
                directionStr, rect1, rect2);
        assertFalse(assertMsg, FocusFinder.beamsOverlap(direction, rect1, rect2));
    }

    /**
     * Assert that particular rect is a better focus search candidate from a source rect than
     * another.
     *
     * @param direction      The direction of focus search
     * @param srcRect        The src rectangle
     * @param expectedBetter The candidate that should be better
     * @param expectedWorse  The candidate that should be worse
     */
    private void assertBetterCandidate(int direction, Rect srcRect, Rect expectedBetter,
            Rect expectedWorse) {
        String directionStr = validateAndGetStringFor(direction);
        String assertMsg = String.format(
                "expected %s to be a better focus search candidate than %s when searching from %s"
                        + " in direction %s",
                expectedBetter, expectedWorse, srcRect, directionStr);

        assertTrue(assertMsg,
                FocusFinder.isBetterCandidate(direction, srcRect, expectedBetter, expectedWorse));

        assertMsg = String.format(
                "expected %s to not be a better focus search candidate than %s when searching "
                        + "from %s in direction %s",
                expectedWorse, expectedBetter, srcRect, directionStr);

        assertFalse(assertMsg,
                FocusFinder.isBetterCandidate(direction, srcRect, expectedWorse, expectedBetter));
    }

    private void assertIsNotCandidate(int direction, Rect src, Rect dest) {
        String directionStr = validateAndGetStringFor(direction);
        final String assertMsg = String.format(
                "expected going from %s to %s in direction %s to be an invalid focus search "
                        + "candidate",
                src, dest, directionStr);
        assertFalse(assertMsg, FocusFinder.isCandidate(src, dest, direction));
    }

    private void assertBeamBeats(int direction, Rect srcRect, Rect rect1, Rect rect2) {
        String directionStr = validateAndGetStringFor(direction);
        String assertMsg = String.format(
                "expecting %s to beam beat %s w.r.t %s in direction %s",
                rect1, rect2, srcRect, directionStr);
        assertTrue(assertMsg, FocusFinder.beamBeats(direction, srcRect, rect1, rect2));
    }

    private void assertDirectionIsCandidate(int direction, Rect src, Rect dest) {
        String directionStr = validateAndGetStringFor(direction);
        final String assertMsg = String.format(
                "expected going from %s to %s in direction %s to be a valid focus search candidate",
                src, dest, directionStr);
        assertTrue(assertMsg, FocusFinder.isCandidate(src, dest, direction));
    }

    private String validateAndGetStringFor(int direction) {
        String directionStr = "??";
        switch (direction) {
            case View.FOCUS_UP:
                directionStr = "FOCUS_UP";
                break;
            case View.FOCUS_DOWN:
                directionStr = "FOCUS_DOWN";
                break;
            case View.FOCUS_LEFT:
                directionStr = "FOCUS_LEFT";
                break;
            case View.FOCUS_RIGHT:
                directionStr = "FOCUS_RIGHT";
                break;
            default:
                fail("passed in unknown direction!");
        }
        return directionStr;
    }
}