| // Copyright 2010-2014, Google Inc. |
| // All rights reserved. |
| // |
| // Redistribution and use in source and binary forms, with or without |
| // modification, are permitted provided that the following conditions are |
| // met: |
| // |
| // * Redistributions of source code must retain the above copyright |
| // notice, this list of conditions and the following disclaimer. |
| // * Redistributions in binary form must reproduce the above |
| // copyright notice, this list of conditions and the following disclaimer |
| // in the documentation and/or other materials provided with the |
| // distribution. |
| // * Neither the name of Google Inc. nor the names of its |
| // contributors may be used to endorse or promote products derived from |
| // this software without specific prior written permission. |
| // |
| // THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS |
| // "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT |
| // LIMITED TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR |
| // A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT |
| // OWNER OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, |
| // SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT |
| // LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, |
| // DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY |
| // THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT |
| // (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE |
| // OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. |
| |
| package org.mozc.android.inputmethod.japanese.keyboard; |
| |
| import org.mozc.android.inputmethod.japanese.keyboard.BackgroundDrawableFactory.DrawableType; |
| import org.mozc.android.inputmethod.japanese.keyboard.Key.Stick; |
| import org.mozc.android.inputmethod.japanese.keyboard.KeyState.MetaState; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchAction; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchEvent; |
| import com.google.common.base.Optional; |
| |
| import android.test.suitebuilder.annotation.SmallTest; |
| |
| import junit.framework.TestCase; |
| |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| |
| /** |
| */ |
| public class KeyEventContextTest extends TestCase { |
| |
| private PopUp defaultPopUp; |
| private PopUp leftPopUp; |
| private KeyEntity defaultEntity; |
| private KeyEntity leftFlickEntity; |
| private KeyEntity modifiedCenterEntity; |
| private KeyEntity modifiedLeftEntity; |
| private KeyState defaultState; |
| private KeyState modifiedState; |
| private Key modifiableKey; |
| private Key longpressableKeyWithTimeoutTrigger; |
| private Key longpressableKeyWithoutTimeoutTrigger; |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| defaultPopUp = new PopUp(0, 0, 0, 0, 0, 0, 0); |
| leftPopUp = new PopUp(0, 0, 0, 0, 0, 0, 0); |
| |
| defaultEntity = new KeyEntity( |
| 1, 'a', 'A', true, 0, Optional.<String>absent(), false, Optional.of(defaultPopUp), |
| 0, 0, 0, 0); |
| leftFlickEntity = new KeyEntity( |
| 2, 'b', 'B', true, 0, Optional.<String>absent(), false, Optional.of(leftPopUp), 0, 0, 0, 0); |
| modifiedCenterEntity = createKeyEntity(3, 'c', 'C'); |
| modifiedLeftEntity = createKeyEntity(4, 'd', 'D'); |
| |
| KeyEntity longpressableEntityWithTimeoutTrigger = new KeyEntity( |
| 5, 'e', 'E', true, 0, Optional.<String>absent(), false, Optional.of(defaultPopUp), |
| 0, 0, 0, 0); |
| KeyEntity longpressableEntityWithoutTimeoutTrigger = new KeyEntity( |
| 6, 'f', 'F', false, 0, Optional.<String>absent(), false, Optional.of(defaultPopUp), |
| 0, 0, 0, 0); |
| |
| defaultState = new KeyState( |
| "", Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), Collections.<MetaState>emptySet(), |
| Arrays.asList(new Flick(Flick.Direction.CENTER, defaultEntity), |
| new Flick(Flick.Direction.LEFT, leftFlickEntity))); |
| modifiedState = new KeyState( |
| "", EnumSet.of(MetaState.CAPS_LOCK), Collections.<MetaState>emptySet(), |
| EnumSet.of(MetaState.CAPS_LOCK), |
| Arrays.asList(new Flick(Flick.Direction.CENTER, modifiedCenterEntity), |
| new Flick(Flick.Direction.LEFT, modifiedLeftEntity))); |
| |
| modifiableKey = new Key(0, 0, 16, 16, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Arrays.asList(defaultState, modifiedState)); |
| longpressableKeyWithTimeoutTrigger = new Key(0, 0, 16, 16, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList( |
| new KeyState("", Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), Collections.<MetaState>emptySet(), |
| Collections.singletonList( |
| new Flick(Flick.Direction.CENTER, |
| longpressableEntityWithTimeoutTrigger))))); |
| longpressableKeyWithoutTimeoutTrigger = new Key(0, 0, 16, 16, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList( |
| new KeyState("", Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), Collections.<MetaState>emptySet(), |
| Collections.singletonList( |
| new Flick(Flick.Direction.CENTER, |
| longpressableEntityWithoutTimeoutTrigger))))); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| defaultPopUp = null; |
| leftPopUp = null; |
| defaultEntity = null; |
| leftFlickEntity = null; |
| modifiedCenterEntity = null; |
| modifiedLeftEntity = null; |
| defaultState = null; |
| modifiedState = null; |
| modifiableKey = null; |
| |
| super.tearDown(); |
| } |
| |
| private static KeyEntity createKeyEntity(int sourceId, int keyCode, int longPressKeyCode) { |
| return new KeyEntity( |
| sourceId, keyCode, longPressKeyCode, true, 0, |
| Optional.<String>absent(), false, Optional.<PopUp>absent(), 0, 0, 0, 0); |
| } |
| |
| @SmallTest |
| public void testIsContained() { |
| Key key = new Key( |
| 0, 0, 30, 50, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, Collections.<KeyState>emptyList()); |
| assertTrue(KeyEventContext.isContained(15, 25, key)); |
| assertTrue(KeyEventContext.isContained(10, 5, key)); |
| assertTrue(KeyEventContext.isContained(29, 45, key)); |
| assertFalse(KeyEventContext.isContained(31, 25, key)); |
| assertFalse(KeyEventContext.isContained(-1, 45, key)); |
| assertFalse(KeyEventContext.isContained(15, -20, key)); |
| assertFalse(KeyEventContext.isContained(5, 60, key)); |
| } |
| |
| @SmallTest |
| public void testIsFlickable() { |
| // If the key doesn't return KeyState, isFlickable should return false. |
| assertFalse(KeyEventContext.isFlickable( |
| new Key(0, 0, 30, 50, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, Collections.<KeyState>emptyList()), |
| Collections.<MetaState>emptySet())); |
| |
| // If the key doesn't have flick related data other than CENTER, it is not flickable. |
| KeyEntity dummyKeyEntity = createKeyEntity(1, 'a', KeyEntity.INVALID_KEY_CODE); |
| Flick center = new Flick(Flick.Direction.CENTER, dummyKeyEntity); |
| assertFalse(KeyEventContext.isFlickable( |
| new Key(0, 0, 30, 50, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList( |
| new KeyState("", |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.singletonList(center)))), |
| Collections.<MetaState>emptySet())); |
| |
| // If the key has flick related data other than CENTER, it is flickable. |
| Flick left = new Flick(Flick.Direction.LEFT, dummyKeyEntity); |
| assertTrue(KeyEventContext.isFlickable( |
| new Key(0, 0, 30, 50, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList( |
| new KeyState("", |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Arrays.asList(center, left)))), |
| Collections.<MetaState>emptySet())); |
| } |
| |
| @SmallTest |
| public void testGetKeyEntity() { |
| assertSame(defaultEntity, |
| KeyEventContext.getKeyEntity( |
| modifiableKey, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.CENTER)).get()); |
| assertSame(leftFlickEntity, |
| KeyEventContext.getKeyEntity( |
| modifiableKey, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.LEFT)).get()); |
| assertSame(modifiedCenterEntity, |
| KeyEventContext.getKeyEntity( |
| modifiableKey, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.CENTER)).get()); |
| assertSame(modifiedLeftEntity, |
| KeyEventContext.getKeyEntity( |
| modifiableKey, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.LEFT)).get()); |
| |
| // If a key entity for the flick direction is not specified, |
| // Optional.absent() should be returned. |
| assertFalse(KeyEventContext.getKeyEntity( |
| modifiableKey, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.RIGHT)).isPresent()); |
| assertFalse(KeyEventContext.getKeyEntity( |
| modifiableKey, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.RIGHT)).isPresent()); |
| |
| Key unmodifiableKey = new Key(0, 0, 0, 0, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(defaultState)); |
| |
| // If a key doesn't have modified state, default state should be used as its fall back. |
| assertSame(defaultEntity, |
| KeyEventContext.getKeyEntity( |
| unmodifiableKey, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.CENTER)).get()); |
| assertSame(leftFlickEntity, |
| KeyEventContext.getKeyEntity( |
| unmodifiableKey, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.LEFT)).get()); |
| assertSame(defaultEntity, |
| KeyEventContext.getKeyEntity( |
| unmodifiableKey, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.CENTER)).get()); |
| assertSame(leftFlickEntity, |
| KeyEventContext.getKeyEntity( |
| unmodifiableKey, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.LEFT)).get()); |
| |
| // If both state is not specified, Optional.absent() should be returned. |
| Key spacer = new Key(0, 0, 0, 0, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.<KeyState>emptyList()); |
| assertFalse(KeyEventContext.getKeyEntity(spacer, Collections.<MetaState>emptySet(), |
| Optional.of(Flick.Direction.CENTER)).isPresent()); |
| assertFalse(KeyEventContext.getKeyEntity(spacer, EnumSet.of(MetaState.CAPS_LOCK), |
| Optional.of(Flick.Direction.CENTER)).isPresent()); |
| } |
| |
| @SmallTest |
| public void testGetKeyCode() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(modifiableKey, 0, 0, 0, 100, 100, 1, Collections.<MetaState>emptySet()); |
| assertEquals('a', keyEventContext.getKeyCode()); |
| keyEventContext.flickDirection = Flick.Direction.LEFT; |
| assertEquals('b', keyEventContext.getKeyCode()); |
| keyEventContext.flickDirection = Flick.Direction.RIGHT; |
| assertEquals(KeyEntity.INVALID_KEY_CODE, keyEventContext.getKeyCode()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| keyEventContext.flickDirection = Flick.Direction.CENTER; |
| assertEquals(KeyEntity.INVALID_KEY_CODE, keyEventContext.getKeyCode()); |
| } |
| |
| @SmallTest |
| public void testGetKeyCodeForLongPressWithTimeoutTrigger() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(longpressableKeyWithTimeoutTrigger, 0, 0, 0, 100, 100, 1, |
| Collections.<MetaState>emptySet()); |
| keyEventContext.pastLongPressSentTimeout = false; |
| assertEquals('e', keyEventContext.getKeyCode()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| assertEquals(KeyEntity.INVALID_KEY_CODE, keyEventContext.getKeyCode()); |
| } |
| |
| @SmallTest |
| public void testGetKeyCodeForLongPressWithoutTimeoutTrigger() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(longpressableKeyWithoutTimeoutTrigger, 0, 0, 0, 100, 100, 1, |
| Collections.<MetaState>emptySet()); |
| keyEventContext.pastLongPressSentTimeout = false; |
| assertEquals('f', keyEventContext.getKeyCode()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| assertEquals('F', keyEventContext.getKeyCode()); |
| } |
| |
| @SmallTest |
| public void testGetLongPressKeyCode() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(modifiableKey, 0, 0, 0, 100, 100, 1, |
| Collections.<MetaState>emptySet()); |
| assertEquals('A', keyEventContext.getLongPressKeyCode()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| assertEquals(KeyEntity.INVALID_KEY_CODE, keyEventContext.getLongPressKeyCode()); |
| } |
| |
| @SmallTest |
| public void testGetPressedKeyCode() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(modifiableKey, 0, 0, 0, 100, 100, 1, |
| Collections.<MetaState>emptySet()); |
| assertEquals('a', keyEventContext.getPressedKeyCode()); |
| keyEventContext.flickDirection = Flick.Direction.LEFT; |
| assertEquals('a', keyEventContext.getPressedKeyCode()); |
| keyEventContext.flickDirection = Flick.Direction.RIGHT; |
| assertEquals('a', keyEventContext.getPressedKeyCode()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| keyEventContext.flickDirection = Flick.Direction.CENTER; |
| assertEquals('a', keyEventContext.getPressedKeyCode()); |
| } |
| |
| @SmallTest |
| public void testGetNextMetaState() { |
| KeyState onUnmodified = new KeyState( |
| "", |
| Collections.<MetaState>emptySet(), |
| EnumSet.of(MetaState.SHIFT), |
| Collections.<MetaState>emptySet(), |
| Collections.singletonList(new Flick(Flick.Direction.CENTER, defaultEntity))); |
| KeyState onShift = new KeyState( |
| "", |
| EnumSet.of(MetaState.SHIFT), |
| EnumSet.of(MetaState.CAPS_LOCK), |
| EnumSet.of(MetaState.SHIFT), |
| Collections.singletonList(new Flick(Flick.Direction.CENTER, defaultEntity))); |
| KeyState onCapsLock = new KeyState( |
| "", |
| EnumSet.of(MetaState.CAPS_LOCK), |
| Collections.<MetaState>emptySet(), |
| EnumSet.of(MetaState.CAPS_LOCK), |
| Collections.singletonList(new Flick(Flick.Direction.CENTER, defaultEntity))); |
| Key capsLockKey = new Key(0, 0, 10, 10, 0, 0, false, true, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Arrays.asList(onUnmodified, onShift, onCapsLock)); |
| assertEquals( |
| EnumSet.of(MetaState.SHIFT), |
| new KeyEventContext(capsLockKey, 0, 0, 0, 100, 100, 1, Collections.<MetaState>emptySet()) |
| .getNextMetaStates(Collections.<MetaState>emptySet())); |
| assertEquals( |
| EnumSet.of(MetaState.CAPS_LOCK), |
| new KeyEventContext(capsLockKey, 0, 0, 0, 100, 100, 1, EnumSet.of(MetaState.SHIFT)) |
| .getNextMetaStates(EnumSet.of(MetaState.SHIFT))); |
| assertEquals( |
| Collections.<MetaState>emptySet(), |
| new KeyEventContext(capsLockKey, 0, 0, 0, 100, 100, 1, EnumSet.of(MetaState.CAPS_LOCK)) |
| .getNextMetaStates(EnumSet.of(MetaState.CAPS_LOCK))); |
| } |
| |
| @SmallTest |
| public void testIsMetaStateToggleEvent() { |
| Key key = new Key(0, 0, 30, 50, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.<KeyState>emptyList()); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(key, 0, 0, 0, 100, 100, 1, Collections.<MetaState>emptySet()); |
| assertFalse(keyEventContext.isMetaStateToggleEvent()); |
| Key modifierKey = new Key(0, 0, 30, 50, 0, 0, false, true, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.<KeyState>emptyList()); |
| KeyEventContext modifierKeyEventContext = |
| new KeyEventContext(modifierKey, 0, 0, 0, 100, 100, 1, Collections.<MetaState>emptySet()); |
| assertTrue(modifierKeyEventContext.isMetaStateToggleEvent()); |
| modifierKeyEventContext.pastLongPressSentTimeout = true; |
| assertFalse(modifierKeyEventContext.isMetaStateToggleEvent()); |
| modifierKeyEventContext.pastLongPressSentTimeout = false; |
| modifierKeyEventContext.flickDirection = Flick.Direction.LEFT; |
| assertFalse(modifierKeyEventContext.isMetaStateToggleEvent()); |
| } |
| |
| @SmallTest |
| public void testGetCurrentPopUp() { |
| KeyEventContext keyEventContext = |
| new KeyEventContext(modifiableKey, 0, 0, 0, 100, 100, 1, |
| Collections.<MetaState>emptySet()); |
| assertSame(defaultPopUp, keyEventContext.getCurrentPopUp().get()); |
| keyEventContext.flickDirection = Flick.Direction.LEFT; |
| assertSame(leftPopUp, keyEventContext.getCurrentPopUp().get()); |
| keyEventContext.flickDirection = Flick.Direction.RIGHT; |
| assertFalse(keyEventContext.getCurrentPopUp().isPresent()); |
| keyEventContext.pastLongPressSentTimeout = true; |
| keyEventContext.flickDirection = Flick.Direction.CENTER; |
| assertFalse(keyEventContext.getCurrentPopUp().isPresent()); |
| } |
| |
| @SmallTest |
| public void testUpdate() { |
| KeyEntity centerEntity = createKeyEntity(1, 'a', 'A'); |
| KeyEntity leftEntity = createKeyEntity(2, 'b', 'B'); |
| KeyEntity upEntity = createKeyEntity(3, 'c', 'C'); |
| KeyEntity rightEntity = createKeyEntity(4, 'd', 'D'); |
| KeyEntity downEntity = createKeyEntity(5, 'e', 'E'); |
| |
| KeyState keyState = new KeyState( |
| "", |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Arrays.asList(new Flick(Flick.Direction.CENTER, centerEntity), |
| new Flick(Flick.Direction.LEFT, leftEntity), |
| new Flick(Flick.Direction.UP, upEntity), |
| new Flick(Flick.Direction.RIGHT, rightEntity), |
| new Flick(Flick.Direction.DOWN, downEntity))); |
| |
| Key key = new Key(0, 0, 16, 16, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(keyState)); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(key, 0, 8, 8, 64, 64, 50, Collections.<MetaState>emptySet()); |
| |
| assertEquals(Flick.Direction.CENTER, keyEventContext.flickDirection); |
| assertEquals( |
| TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke( |
| KeyEventContext.createTouchPosition(TouchAction.TOUCH_DOWN, 8, 8, 64, 64, 0)) |
| .build(), |
| keyEventContext.getTouchEvent().get()); |
| |
| class TestData { |
| final int x; |
| final int y; |
| final long timestamp; |
| final boolean pastLongPressSentTimeout; |
| final boolean expectedUpdateResult; |
| final Flick.Direction expectedDirection; |
| final int expectedSourceId; |
| final boolean expectedPastLongPressSentTimeout; |
| |
| TestData(int x, int y, long timestamp, boolean pastLongPressSentTimeout, |
| boolean expectedUpdateResult, Flick.Direction expectedDirection, |
| int expectedSourceId, boolean expectedPastLongPressSentTimeout) { |
| this.x = x; |
| this.y = y; |
| this.timestamp = timestamp; |
| this.pastLongPressSentTimeout = pastLongPressSentTimeout; |
| this.expectedUpdateResult = expectedUpdateResult; |
| this.expectedDirection = expectedDirection; |
| this.expectedSourceId = expectedSourceId; |
| this.expectedPastLongPressSentTimeout = expectedPastLongPressSentTimeout; |
| } |
| } |
| |
| TestData[] testDataList = { |
| // Center |
| new TestData(4, 4, 10, false, false, Flick.Direction.CENTER, 1, false), |
| |
| // Up |
| new TestData(8, -16, 20, false, true, Flick.Direction.UP, 3, false), |
| new TestData(8, -32, 30, false, false, Flick.Direction.UP, 3, false), |
| |
| // Left |
| new TestData(-16, 8, 40, false, true, Flick.Direction.LEFT, 2, false), |
| new TestData(-32, 8, 50, false, false, Flick.Direction.LEFT, 2, false), |
| |
| // Down |
| new TestData(8, 32, 60, true, true, Flick.Direction.DOWN, 5, false), |
| new TestData(8, 48, 70, true, false, Flick.Direction.DOWN, 5, true), |
| |
| // Right |
| new TestData(32, 8, 80, true, true, Flick.Direction.RIGHT, 4, false), |
| new TestData(48, 8, 90, true, false, Flick.Direction.RIGHT, 4, true), |
| |
| // Back to center |
| new TestData(8, 8, 100, true, true, Flick.Direction.CENTER, 1, false), |
| new TestData(4, 4, 110, true, false, Flick.Direction.CENTER, 1, true), |
| }; |
| |
| for (TestData testData : testDataList) { |
| keyEventContext.pastLongPressSentTimeout = testData.pastLongPressSentTimeout; |
| assertEquals(testData.expectedUpdateResult, |
| keyEventContext.update(testData.x, testData.y, |
| TouchAction.TOUCH_MOVE, testData.timestamp)); |
| assertEquals(testData.expectedDirection, keyEventContext.flickDirection); |
| assertEquals(testData.expectedPastLongPressSentTimeout, |
| keyEventContext.pastLongPressSentTimeout); |
| assertEquals( |
| TouchEvent.newBuilder() |
| .setSourceId(testData.expectedSourceId) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 8, 8, 64, 64, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_MOVE, testData.x, testData.y, 64, 64, testData.timestamp)) |
| .build(), |
| keyEventContext.getTouchEvent().get()); |
| } |
| |
| // Release the key. |
| assertFalse(keyEventContext.update(4, 4, TouchAction.TOUCH_UP, 120)); |
| |
| TouchEvent expectedEvent = TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition(TouchAction.TOUCH_DOWN, 8, 8, 64, 64, 0)) |
| .addStroke(KeyEventContext.createTouchPosition(TouchAction.TOUCH_UP, 4, 4, 64, 64, 120)) |
| .build(); |
| assertEquals(expectedEvent, keyEventContext.getTouchEvent().get()); |
| } |
| |
| @SmallTest |
| public void testUpdateNonFlickable() { |
| KeyEntity keyEntity = createKeyEntity(256, 'a', 'A'); |
| KeyState keyState = new KeyState( |
| "", |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.singletonList(new Flick(Flick.Direction.CENTER, keyEntity))); |
| Key key = new Key(0, 0, 10, 10, 0, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(keyState)); |
| |
| // For unflickable keys, moving inside the key's region is NOT a flick action |
| // regardless of the flick's threshold. |
| KeyEventContext keyEventContext = |
| new KeyEventContext(key, 0, 5, 5, 100, 100, 9, Collections.<MetaState>emptySet()); |
| assertFalse(keyEventContext.update(5, 5, TouchAction.TOUCH_DOWN, 0)); |
| |
| assertEquals(Flick.Direction.CENTER, keyEventContext.flickDirection); |
| assertFalse(keyEventContext.update(3, 3, TouchAction.TOUCH_MOVE, 10)); |
| assertEquals(Flick.Direction.CENTER, keyEventContext.flickDirection); |
| assertFalse(keyEventContext.update(3, 8, TouchAction.TOUCH_MOVE, 20)); |
| assertEquals(Flick.Direction.CENTER, keyEventContext.flickDirection); |
| assertFalse(keyEventContext.update(3, 8, TouchAction.TOUCH_MOVE, 30)); |
| assertEquals(Flick.Direction.CENTER, keyEventContext.flickDirection); |
| |
| // If the moving point exits from the key's region, it is recognized as a flick action |
| // (cancellation a for non-flickable key). |
| assertTrue(keyEventContext.update(-10, 5, TouchAction.TOUCH_MOVE, 40)); |
| assertEquals(Flick.Direction.LEFT, keyEventContext.flickDirection); |
| |
| assertFalse(keyEventContext.getTouchEvent().isPresent()); |
| } |
| } |
