| // 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 static org.easymock.EasyMock.capture; |
| import static org.easymock.EasyMock.eq; |
| import static org.easymock.EasyMock.expectLastCall; |
| import static org.easymock.EasyMock.isA; |
| import static org.easymock.EasyMock.same; |
| |
| import org.mozc.android.inputmethod.japanese.MozcUtil; |
| import org.mozc.android.inputmethod.japanese.keyboard.BackgroundDrawableFactory.DrawableType; |
| import org.mozc.android.inputmethod.japanese.keyboard.Flick.Direction; |
| import org.mozc.android.inputmethod.japanese.keyboard.Key.Stick; |
| import org.mozc.android.inputmethod.japanese.keyboard.KeyState.MetaState; |
| import org.mozc.android.inputmethod.japanese.keyboard.Keyboard.KeyboardSpecification; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchAction; |
| import org.mozc.android.inputmethod.japanese.protobuf.ProtoCommands.Input.TouchEvent; |
| import org.mozc.android.inputmethod.japanese.testing.InstrumentationTestCaseWithMock; |
| import org.mozc.android.inputmethod.japanese.testing.MockResourcesWithDisplayMetrics; |
| import org.mozc.android.inputmethod.japanese.testing.Parameter; |
| import org.mozc.android.inputmethod.japanese.testing.VisibilityProxy; |
| import org.mozc.android.inputmethod.japanese.view.DrawableCache; |
| import org.mozc.android.inputmethod.japanese.view.SkinType; |
| import com.google.common.base.Optional; |
| |
| import android.content.res.Resources; |
| import android.graphics.drawable.ColorDrawable; |
| import android.graphics.drawable.Drawable; |
| import android.os.Handler; |
| import android.os.Looper; |
| import android.test.mock.MockResources; |
| import android.test.suitebuilder.annotation.SmallTest; |
| import android.text.InputType; |
| import android.util.DisplayMetrics; |
| import android.view.MotionEvent; |
| import android.view.View; |
| import android.view.inputmethod.EditorInfo; |
| |
| import org.easymock.Capture; |
| import org.easymock.EasyMock; |
| import org.easymock.IAnswer; |
| |
| import java.util.Arrays; |
| import java.util.Collections; |
| import java.util.EnumSet; |
| import java.util.List; |
| import java.util.Map; |
| import java.util.Set; |
| |
| /** |
| * Unit tests for {@code org.mozc.android.inputmethod.japanese.keyboard.KeyboardView}. |
| */ |
| public class KeyboardViewTest extends InstrumentationTestCaseWithMock { |
| |
| /** |
| * The number of steps of a drag path. |
| */ |
| private static final int STEP_COUNT = 20; |
| |
| // The following are parameters of a dummy key. |
| private static final int WIDTH = 50; |
| private static final int HEIGHT = 30; |
| private static final int HORIZONTAL_GAP = 0; |
| private static final int VERTICAL_GAP = 0; |
| |
| private KeyboardView view; |
| |
| private static boolean touchEvent(KeyboardView view, int action, int x, int y) { |
| return touchEvent(view, 0, 0, action, x, y); |
| } |
| |
| private static boolean touchEvent( |
| KeyboardView view, long downTime, long eventTime, int action, int x, int y) { |
| MotionEvent e = MotionEvent.obtain(downTime, eventTime, action, x, y, 0); |
| try { |
| return view.onTouchEvent(e); |
| } finally { |
| e.recycle(); |
| } |
| } |
| |
| /** Emulates dragging from @{code (fromX, fromY)} to @{code (toX, toY)}. */ |
| private static boolean drag(KeyboardView view, int fromX, int toX, int fromY, int toY) { |
| long downTime = MozcUtil.getUptimeMillis(); |
| |
| boolean result = true; |
| result &= touchEvent(view, downTime, downTime, MotionEvent.ACTION_DOWN, fromX, fromY); |
| |
| for (int i = 0; i < STEP_COUNT; ++i) { |
| int x = fromX + (toX - fromX) * i / STEP_COUNT; |
| int y = fromY + (toY - fromY) * i / STEP_COUNT; |
| |
| long eventTime = MozcUtil.getUptimeMillis(); |
| result &= touchEvent(view, downTime, eventTime, MotionEvent.ACTION_MOVE, x, y); |
| } |
| |
| long eventTime = MozcUtil.getUptimeMillis(); |
| result &= touchEvent(view, downTime, eventTime, MotionEvent.ACTION_UP, toX, toY); |
| return result; |
| } |
| |
| private static KeyEntity createInvalidKeyEntity(int sourceId, int keyCode) { |
| return new KeyEntity( |
| sourceId, keyCode, KeyEntity.INVALID_KEY_CODE, true, 0, |
| Optional.<String>absent(), false, Optional.<PopUp>absent(), 0, 0, 0, 0); |
| } |
| |
| private static KeyState createKeyStateWithKeyEntity( |
| Set<MetaState> metaState, KeyEntity keyEntity) { |
| Flick flick = new Flick(Flick.Direction.CENTER, keyEntity); |
| return new KeyState( |
| "", |
| metaState, |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.singletonList(flick)); |
| } |
| |
| private static KeyState createKeyState(Set<MetaState> metaState, int keyCode) { |
| return createKeyStateWithKeyEntity(metaState, createInvalidKeyEntity(1, keyCode)); |
| } |
| |
| private static Key createKey(int x, int y, int keyCode) { |
| return new Key( |
| x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(createKeyState(Collections.<MetaState>emptySet(), keyCode))); |
| } |
| |
| private static Key createKeyWithKeyEntity(int x, int y, KeyEntity keyEntity) { |
| return new Key( |
| x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList( |
| createKeyStateWithKeyEntity(Collections.<MetaState>emptySet(), keyEntity))); |
| } |
| |
| private static Key createSpacer(int x, int y, Stick stick) { |
| return new Key( |
| x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, false, stick, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.<KeyState>emptyList()); |
| } |
| |
| private static Key createKeyWithModifiedState(int x, int y, int keyCode, int modifiedKeyCode) { |
| return new Key( |
| x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Arrays.asList(createKeyState(Collections.<MetaState>emptySet(), keyCode), |
| createKeyState(EnumSet.of(MetaState.CAPS_LOCK), modifiedKeyCode))); |
| } |
| |
| private static Key createFlickKey( |
| int x, int y, |
| int centerKeyCode, int leftKeyCode, int rightKeyCode, int upKeyCode, int downKeyCode) { |
| Flick center = new Flick(Flick.Direction.CENTER, createInvalidKeyEntity(1, centerKeyCode)); |
| Flick left = new Flick(Flick.Direction.LEFT, createInvalidKeyEntity(1, leftKeyCode)); |
| Flick right = new Flick(Flick.Direction.RIGHT, createInvalidKeyEntity(1, rightKeyCode)); |
| Flick up = new Flick(Flick.Direction.UP, createInvalidKeyEntity(1, upKeyCode)); |
| Flick down = new Flick(Flick.Direction.DOWN, createInvalidKeyEntity(1, downKeyCode)); |
| KeyState keyState = new KeyState( |
| "", |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Collections.<MetaState>emptySet(), |
| Arrays.asList(center, left, right, up, down)); |
| return new Key(x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, false, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(keyState)); |
| } |
| |
| private static Key createModifierKey(int x, int y, int keyCode, Set<MetaState> nextAddMetaStates, |
| Set<MetaState> nextRemoveMetaStates) { |
| KeyEntity entity = createInvalidKeyEntity(1, keyCode); |
| Flick flick = new Flick(Flick.Direction.CENTER, entity); |
| KeyState keyState = new KeyState( |
| "", |
| Collections.<MetaState>emptySet(), |
| nextAddMetaStates, |
| nextRemoveMetaStates, |
| Collections.singletonList(flick)); |
| return new Key(x, y, WIDTH, HEIGHT, HORIZONTAL_GAP, 0, false, true, Stick.EVEN, |
| DrawableType.TWELVEKEYS_REGULAR_KEY_BACKGROUND, |
| Collections.singletonList(keyState)); |
| } |
| |
| /** |
| * Creates a dummy keyboard which has only {@code key}. |
| * @return a new dummy keyboard. |
| */ |
| private static Keyboard createDummyKeyboard(Key key) { |
| Row row = new Row(Collections.singletonList(key), HEIGHT, VERTICAL_GAP); |
| return new Keyboard(Optional.<String>absent(), Collections.singletonList(row), 1, |
| KeyboardSpecification.TWELVE_KEY_TOGGLE_FLICK_KANA); |
| } |
| |
| private KeyEventHandler createKeyEventHandlerMock() { |
| KeyboardActionListener keyboardActionListener = createNiceMock(KeyboardActionListener.class); |
| return createMockBuilder(KeyEventHandler.class) |
| .withConstructor(Looper.class, KeyboardActionListener.class, |
| int.class, int.class, int.class) |
| .withArgs(Looper.myLooper(), keyboardActionListener, 0, 0, 0) |
| .createMock(); |
| } |
| |
| private KeyboardViewBackgroundSurface createKeyboardViewBackgroundSurfaceMock() { |
| return createMockBuilder(KeyboardViewBackgroundSurface.class) |
| .withConstructor(BackgroundDrawableFactory.class, DrawableCache.class) |
| .withArgs(new BackgroundDrawableFactory(new MockResourcesWithDisplayMetrics()), |
| new DrawableCache(getInstrumentation().getContext().getResources())) |
| .createMock(); |
| } |
| |
| @Override |
| public void setUp() throws Exception { |
| super.setUp(); |
| |
| view = new KeyboardView(getInstrumentation().getTargetContext()); |
| view.setKeyboard(createDummyKeyboard(createKey(0, 0, 'a'))); |
| view.layout(0, 0, 100, 60); |
| } |
| |
| @Override |
| public void tearDown() throws Exception { |
| view = null; |
| super.tearDown(); |
| } |
| |
| @SmallTest |
| public void testFlushPendingKeyEventRecursiveCall() { |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| keyEventContext.getKeyCode(), |
| Collections.singletonList(keyEventContext.getTouchEvent().get())); |
| expectLastCall().andAnswer(new IAnswer<Void>() { |
| @Override |
| public Void answer() throws Throwable { |
| // Set Keyboard in this callback which invokes flushPendingKeyEvent again. |
| Key key = createKeyWithModifiedState(0, 0, 'a', 'A'); |
| view.setKeyboard(createDummyKeyboard(key)); |
| return null; |
| } |
| }); |
| keyEventHandler.sendRelease(keyEventContext.getPressedKeyCode()); |
| replayAll(); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| view.metaState = EnumSet.of(MetaState.CAPS_LOCK); |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| Key key = createKeyWithModifiedState(0, 0, 'a', 'A'); |
| view.setKeyboard(createDummyKeyboard(key)); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_press() { |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| keyEventHandler.maybeStartDelayedKeyEvent(isA(KeyEventContext.class)); |
| keyEventHandler.sendPress('a'); |
| replayAll(); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // By pressing a key, internal pressedKey field should be filled. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| assertTrue(keyEventContextMap.isEmpty()); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 25, 15)); |
| |
| verifyAll(); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| assertTrue(view.isKeyPressed); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_pressModified() { |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| keyEventHandler.maybeStartDelayedKeyEvent(isA(KeyEventContext.class)); |
| keyEventHandler.sendPress('A'); |
| replayAll(); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| Key key = createKeyWithModifiedState(0, 0, 'a', 'A'); |
| view.setKeyboard(createDummyKeyboard(key)); |
| |
| // Set modified state. |
| view.metaState = EnumSet.of(MetaState.CAPS_LOCK); |
| |
| // By pressing a key, internal pressedKey field should be filled. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| assertTrue(keyEventContextMap.isEmpty()); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 25, 15)); |
| |
| verifyAll(); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_pressModifier() { |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| keyEventHandler.sendKey( |
| 'a', |
| Arrays.asList( |
| // A TouchEvent for the modifier Key. |
| TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 25, 15, 100, 60, 0)) |
| .build(), |
| // A TouchEvent for 'a' key. |
| TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 100, 60, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease('a'); |
| keyEventHandler.maybeStartDelayedKeyEvent(isA(KeyEventContext.class)); |
| keyEventHandler.sendPress(-1); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| view.setKeyboard(createDummyKeyboard( |
| createModifierKey(0, 0, -1, EnumSet.of(MetaState.CAPS_LOCK), |
| EnumSet.of(MetaState.SHIFT)))); |
| |
| // Set modified state. |
| view.metaState = EnumSet.of(MetaState.SHIFT); |
| |
| KeyEventContext pendingKeyEventContext = |
| new KeyEventContext(createKey(0, 0, 'a'), 1, 100, 60, 100, 60, 0, |
| Collections.<MetaState>emptySet()); |
| // By pressing a key, the pending events should be flushed and |
| // the metaState should be updated. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(1, pendingKeyEventContext); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 25, 15)); |
| |
| verifyAll(); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(EnumSet.of(MetaState.CAPS_LOCK, MetaState.HANDLING_TOUCH_EVENT), view.metaState); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_pressOutside() { |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Pressing non-key region shouldn't cause filling the pressedKey. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| assertTrue(keyEventContextMap.isEmpty()); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 100, -100)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_pressBelowOutside() { |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| keyEventHandler.maybeStartDelayedKeyEvent(isA(KeyEventContext.class)); |
| keyEventHandler.sendPress('a'); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| assertTrue(keyEventContextMap.isEmpty()); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 100, 100)); |
| |
| verifyAll(); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| assertTrue(view.isKeyPressed); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_release() { |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| // The listener should receive two events. |
| // - onKey event with 'a' code. |
| // - onRelease event with 'a' code. |
| // in this order. |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| 'a', |
| Collections.singletonList(TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease('a'); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 25, 15)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_releaseInvalidKey() { |
| class TestData extends Parameter { |
| private final Key key; |
| private final int deltaX; |
| private final int deltaY; |
| TestData(Key key, int deltaX, int deltaY) { |
| this.key = key; |
| this.deltaX = deltaX; |
| this.deltaY = deltaY; |
| } |
| } |
| |
| // Center is valid, but other dictions are invalid. |
| Key validCenter = createFlickKey(0, 0, 'a', |
| KeyEntity.INVALID_KEY_CODE, |
| KeyEntity.INVALID_KEY_CODE, |
| KeyEntity.INVALID_KEY_CODE, |
| KeyEntity.INVALID_KEY_CODE); |
| |
| int delta = 100; |
| TestData[] testDataList = { |
| new TestData(createKey(0, 0, KeyEntity.INVALID_KEY_CODE), 0, 0), |
| // Try four directions, which are assigned INVALID_KEY_CODE. |
| new TestData(validCenter, -delta, 0), |
| new TestData(validCenter, +delta, 0), |
| new TestData(validCenter, 0, -delta), |
| new TestData(validCenter, 0, +delta), |
| }; |
| |
| for (TestData testData : testDataList) { |
| resetAll(); |
| |
| // Prepare a keyboard having a key with invalid key code. |
| KeyboardView view = new KeyboardView(getInstrumentation().getTargetContext()); |
| view.setKeyboard(createDummyKeyboard(testData.key)); |
| view.layout(0, 0, 100, 60); |
| |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| // cancelDelayedKeyEvent is called by each MOVE event. |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| expectLastCall().asStub(); |
| // Pay no attention the parameter of sendRelease. |
| keyEventHandler.sendRelease(EasyMock.anyInt()); |
| // The handler's sendKey shouldn't be sent. |
| replayAll(); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| int startX = 25; |
| int startY = 15; |
| assertTrue(testData.toString(), |
| drag(view, startX, startX + testData.deltaX, startY, startY + testData.deltaY)); |
| |
| verifyAll(); |
| assertTrue(testData.toString(), keyEventContextMap.isEmpty()); |
| } |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_releaseModified() { |
| Key key = createKeyWithModifiedState(0, 0, 'a', 'A'); |
| view.setKeyboard(createDummyKeyboard(key)); |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, EnumSet.of(MetaState.CAPS_LOCK)); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| // The listener should receive two events. |
| // - onKey event with 'A' code. |
| // - onRelease event with 'A' code. |
| // in this order. |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| 'A', |
| Collections.singletonList(TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease('A'); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| view.metaState = EnumSet.of(MetaState.CAPS_LOCK); |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 25, 15)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| assertEquals(EnumSet.of(MetaState.CAPS_LOCK), view.metaState); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_releaseModifierSimple() { |
| Key key = createModifierKey(0, 0, -1, EnumSet.of(MetaState.SHIFT), |
| Collections.<MetaState>emptySet()); |
| view.setKeyboard(createDummyKeyboard(key)); |
| |
| KeyEventContext keyEventContext = |
| new KeyEventContext(key, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| -1, |
| Collections.singletonList(TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease(-1); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| view.metaState = EnumSet.of(MetaState.SHIFT); |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| view.isKeyPressed = false; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 25, 15)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| // Simple releasing a modifier key shouldn't change the metaState. |
| assertEquals(EnumSet.of(MetaState.SHIFT), view.metaState); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_releaseModifierWithOtherKey() { |
| Key key = createModifierKey(0, 0, -1, EnumSet.of(MetaState.SHIFT), |
| Collections.<MetaState>emptySet()); |
| view.setKeyboard(createDummyKeyboard(key)); |
| |
| KeyEventContext keyEventContext = |
| new KeyEventContext(key, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| // Another key event context for 'a' key. |
| KeyEventContext keyEventContext2 = |
| new KeyEventContext(createKey(0, 0, 'a'), 0, 0, 0, 100, 60, 1, |
| EnumSet.of(MetaState.SHIFT)); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| // The listener should receive two events. |
| // - onKey event with 'A' code. |
| // - onRelease event with 'A' code. |
| // in this order. |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext2); |
| keyEventHandler.sendKey( |
| 'a', |
| Arrays.asList( |
| // A TouchEvent for the SHIFT key. |
| TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build(), |
| // A TouchEvent for 'a' key. |
| TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease('a'); |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| -1, |
| Collections.singletonList(TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease(-1); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| view.metaState = EnumSet.of(MetaState.SHIFT); |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| keyEventContextMap.put(1, keyEventContext2); |
| view.isKeyPressed = true; |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 25, 15)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| // Simple releasing a modifier key shouldn't change the metaState. |
| assertTrue(view.metaState.isEmpty()); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_releaseModifierOneTime() { |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext keyEventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(keyEventContext); |
| keyEventHandler.sendKey( |
| 'a', |
| Collections.singletonList(TouchEvent.newBuilder() |
| .setSourceId(1) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_DOWN, 0, 0, 100, 60, 0)) |
| .addStroke(KeyEventContext.createTouchPosition( |
| TouchAction.TOUCH_UP, 25, 15, 100, 60, 0)) |
| .build())); |
| keyEventHandler.sendRelease('a'); |
| replayAll(); |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| view.metaState = EnumSet.of(MetaState.SHIFT); |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, keyEventContext); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 25, 15)); |
| |
| verifyAll(); |
| assertTrue(keyEventContextMap.isEmpty()); |
| // Simple releasing a modifier key shouldn't change the metaState. |
| assertTrue(view.metaState.isEmpty()); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_move() { |
| // Moving events shouldn't trigger the listener, except canceling the delayed key event. |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| replayAll(); |
| |
| // Following code emulates: |
| // - press the center of the key |
| // - move to up, which will make internal flickState to UP |
| // - move to left, which will make internal flickState to LEFT |
| // - move to down, which will make internal flickState to DOWN |
| // - move to right, which will make internal flickState to RIGHT |
| // - and, move back to the key, which will make internal flickState to CENTER. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| assertTrue(keyEventContextMap.isEmpty()); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 25, 15)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 25, -85)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.UP, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, -75, 15)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.LEFT, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 25, 115)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.DOWN, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 125, 15)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.RIGHT, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| verifyAll(); |
| |
| resetAll(); |
| keyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| // Delayed key event is invoked since the next flick direction is CENTER. |
| keyEventHandler.maybeStartDelayedKeyEvent(isA(KeyEventContext.class)); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 25, 15)); |
| assertEquals(1, keyEventContextMap.size()); |
| assertEquals(Flick.Direction.CENTER, |
| keyEventContextMap.values().iterator().next().flickDirection); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testOnTouchEvent_cancel() { |
| Key targetKey = view.getKeyboard().get().getRowList().get(0).getKeyList().get(0); |
| KeyEventContext eventContext = |
| new KeyEventContext(targetKey, 0, 0, 0, 100, 60, 1, Collections.<MetaState>emptySet()); |
| |
| KeyEventHandler keyEventHandler = createKeyEventHandlerMock(); |
| keyEventHandler.cancelDelayedKeyEvent(same(eventContext)); |
| keyEventHandler.sendCancel(); |
| replayAll(); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| // Set pressed condition. |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| keyEventContextMap.put(0, eventContext); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_CANCEL, 25, 15)); |
| assertTrue(keyEventContextMap.isEmpty()); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testFlick() { |
| view.setKeyboard(createDummyKeyboard(createFlickKey(0, 0, 'a', 'b', 'c', 'd', 'e'))); |
| |
| view.layout(0, 0, 50, 30); |
| |
| int fromX = view.getWidth() / 2; |
| int fromY = view.getHeight() / 2; |
| |
| class TestData { |
| final int toX; |
| final int toY; |
| final int expectedCode; |
| TestData(int toX, int toY, int expectedCode) { |
| this.toX = toX; |
| this.toY = toY; |
| this.expectedCode = expectedCode; |
| } |
| } |
| TestData[] testCases = { |
| new TestData(fromX - 75, fromY, 'b'), // Left |
| new TestData(fromX + 75, fromY, 'c'), // Right |
| new TestData(fromX, fromY - 75, 'd'), // Up |
| new TestData(fromX, fromY + 75, 'e'), // Down |
| }; |
| |
| KeyboardActionListener keyboardActionListener = createStrictMock(KeyboardActionListener.class); |
| for (TestData testCase : testCases) { |
| resetAll(); |
| keyboardActionListener.onPress('a'); |
| keyboardActionListener.onKey( |
| eq(testCase.expectedCode), EasyMock.<List<TouchEvent>>notNull()); |
| keyboardActionListener.onRelease('a'); |
| replayAll(); |
| |
| KeyEventHandler keyEventHandler = |
| new KeyEventHandler(Looper.myLooper(), keyboardActionListener, 0, 0, 0); |
| |
| view.setKeyEventHandler(keyEventHandler); |
| |
| assertTrue(view.keyEventContextMap.isEmpty()); |
| assertTrue(drag(view, fromX, testCase.toX, fromY, testCase.toY)); |
| assertTrue(view.keyEventContextMap.isEmpty()); |
| |
| verifyAll(); |
| } |
| } |
| |
| @SmallTest |
| public void testFlickSensitivity() { |
| view.setKeyboard(createDummyKeyboard(createFlickKey(0, 0, 'a', 'b', 'c', 'd', 'e'))); |
| view.layout(0, 0, 50, 30); |
| |
| Map<Integer, KeyEventContext> keyEventContextMap = view.keyEventContextMap; |
| |
| int fromX = view.getWidth() / 2; |
| int fromY = view.getHeight() / 2; |
| |
| view.setFlickSensitivity(-10); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, fromX, fromY)); |
| float threshold1 = keyEventContextMap.values().iterator().next().getFlickThresholdSquared(); |
| |
| view.resetState(); |
| view.setFlickSensitivity(0); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, fromX, fromY)); |
| float threshold2 = keyEventContextMap.values().iterator().next().getFlickThresholdSquared(); |
| |
| view.resetState(); |
| view.setFlickSensitivity(10); |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, fromX, fromY)); |
| float threshold3 = keyEventContextMap.values().iterator().next().getFlickThresholdSquared(); |
| |
| assertTrue(0 < threshold3); |
| assertTrue(threshold3 <= threshold2); |
| assertTrue(threshold2 <= threshold1); |
| } |
| |
| @SmallTest |
| public void testPopUp() { |
| final Drawable icon = new ColorDrawable(); |
| final Drawable flickIcon = new ColorDrawable(); |
| final int invalidResourceId = 0; |
| final int iconResourceId = 1; |
| final int flickIconResourceId = 3; |
| |
| PopUp popup = new PopUp(iconResourceId, invalidResourceId, 40, 0, -30, 10, 10); |
| PopUp flickPopup = new PopUp(flickIconResourceId, invalidResourceId, 40, 0, -30, 10, 10); |
| |
| // Inject drawables as resources. |
| Resources mockResources = new MockResourcesWithDisplayMetrics() { |
| @Override |
| public Drawable getDrawable(int resourceId) { |
| if (resourceId == iconResourceId) { |
| return icon; |
| } |
| if (resourceId == flickIconResourceId) { |
| return flickIcon; |
| } |
| return null; |
| } |
| }; |
| DrawableCache drawableCache = new DrawableCache(mockResources); |
| VisibilityProxy.setField(view, "drawableCache", drawableCache); |
| |
| int x1 = 0; |
| int x2 = WIDTH + HORIZONTAL_GAP; |
| int x3 = (WIDTH + HORIZONTAL_GAP) * 2; |
| int y1 = 0; |
| int y2 = HEIGHT + VERTICAL_GAP; |
| int y3 = (HEIGHT + VERTICAL_GAP) * 2; |
| |
| Key popupKey = new Key( |
| x2, y2, |
| WIDTH, HEIGHT, HORIZONTAL_GAP, 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( |
| new Flick( |
| Direction.CENTER, |
| new KeyEntity( |
| 1, 'a', KeyEntity.INVALID_KEY_CODE, true, 0, |
| Optional.<String>absent(), false, Optional.of(popup), 0, 0, 0, 0)), |
| new Flick( |
| Direction.LEFT, |
| new KeyEntity( |
| 2, 'b', KeyEntity.INVALID_KEY_CODE, true, 0, |
| Optional.<String>absent(), false, Optional.of(flickPopup), 0, 0, 0, 0)))))); |
| |
| Row row1 = new Row( |
| Arrays.asList(createKey(x1, y1, 'c'), createKey(x2, y1, 'd'), createKey(x3, y1, 'e')), |
| HEIGHT, VERTICAL_GAP); |
| Row row2 = new Row( |
| Arrays.asList(createKey(x1, y2, 'f'), popupKey, createKey(x3, y2, 'g')), |
| HEIGHT, VERTICAL_GAP); |
| Row row3 = new Row( |
| Arrays.asList(createKey(x1, y3, 'h'), createKey(x2, y3, 'i'), createKey(x3, y3, 'j')), |
| HEIGHT, VERTICAL_GAP); |
| Keyboard keyboard = new Keyboard(Optional.<String>absent(), |
| Arrays.asList(row1, row2, row3), 1, |
| KeyboardSpecification.TWELVE_KEY_TOGGLE_FLICK_KANA); |
| view.setKeyboard(keyboard); |
| |
| // Set mock preview. |
| PopUpPreview mockPopUpPreview = createMockBuilder(PopUpPreview.class) |
| .withConstructor(View.class, BackgroundDrawableFactory.class, DrawableCache.class) |
| .withArgs(view, new BackgroundDrawableFactory(new MockResourcesWithDisplayMetrics()), |
| drawableCache) |
| .createMock(); |
| PopUpPreview.Pool popupPreviewPool = VisibilityProxy.getField(view, "popupPreviewPool"); |
| VisibilityProxy.<List<PopUpPreview>>getField( |
| popupPreviewPool, "freeList").add(mockPopUpPreview); |
| Handler dismissHandler = new Handler(Looper.myLooper()); |
| VisibilityProxy.setField(popupPreviewPool, "dismissHandler", dismissHandler); |
| |
| // At first, emulate press event. |
| mockPopUpPreview.showIfNecessary(popupKey, Optional.of(popup), false); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 75, 45)); |
| verifyAll(); |
| |
| // Then, moving to left. |
| resetAll(); |
| mockPopUpPreview.showIfNecessary(popupKey, Optional.of(flickPopup), false); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 25, 45)); |
| verifyAll(); |
| |
| // Moving to top. |
| resetAll(); |
| mockPopUpPreview.showIfNecessary(popupKey, Optional.<PopUp>absent(), false); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 75, 15)); |
| verifyAll(); |
| |
| // Moving to center again. |
| resetAll(); |
| mockPopUpPreview.showIfNecessary(popupKey, Optional.of(popup), false); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_MOVE, 75, 45)); |
| verifyAll(); |
| |
| // Finally, release. |
| resetAll(); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_UP, 75, 45)); |
| verifyAll(); |
| |
| assertTrue(dismissHandler.hasMessages(0, mockPopUpPreview)); |
| dismissHandler.removeMessages(0); |
| |
| // If popup is disabled, no events should happen. |
| resetAll(); |
| replayAll(); |
| |
| view.setPopupEnabled(false); |
| verifyAll(); |
| |
| resetAll(); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 75, 45)); |
| verifyAll(); |
| } |
| |
| private void delayedPopupTestImpl( |
| boolean popupEnabled, boolean longPressTimeoutTrigger, boolean popupPresent, |
| boolean expectShowIfNecessaryIsCalled, boolean expectLongPressCallbackIsSet) { |
| // Set up mock drawable cache. |
| MockResources mockResources = new MockResources() { |
| @Override |
| public Drawable getDrawable(int resourceId) { |
| return new ColorDrawable(); |
| } |
| |
| @Override |
| public DisplayMetrics getDisplayMetrics() { |
| return new DisplayMetrics(); |
| } |
| }; |
| DrawableCache drawableCache = new DrawableCache(mockResources); |
| VisibilityProxy.setField(view, "drawableCache", drawableCache); |
| |
| // Set up a dummy keyboard with one key entity and mock key event handler. |
| view.setPopupEnabled(popupEnabled); |
| Optional<PopUp> popup = Optional.absent(); |
| if (popupPresent) { |
| popup = Optional.of(new PopUp(0, 0, 40, 0, -30, 10, 10)); |
| } |
| KeyEntity keyEntity = new KeyEntity( |
| 1, 'a', 'A', longPressTimeoutTrigger, 0, Optional.<String>absent(), false, popup, |
| 0, 0, 0, 0); |
| Key key = createKeyWithKeyEntity(0, 0, keyEntity); |
| view.setKeyboard(createDummyKeyboard(key)); |
| KeyEventHandler mockKeyEventHandler = createKeyEventHandlerMock(); |
| view.setKeyEventHandler(mockKeyEventHandler); |
| |
| // Set up mock popup preview. |
| PopUpPreview mockPopUpPreview = createMockBuilder(PopUpPreview.class) |
| .withConstructor(View.class, BackgroundDrawableFactory.class, DrawableCache.class) |
| .withArgs(view, new BackgroundDrawableFactory(mockResources), drawableCache) |
| .createMock(); |
| PopUpPreview.Pool popupPreviewPool = VisibilityProxy.getField(view, "popupPreviewPool"); |
| VisibilityProxy.<List<PopUpPreview>>getField( |
| popupPreviewPool, "freeList").add(mockPopUpPreview); |
| Handler dismissHandler = new Handler(Looper.myLooper()); |
| VisibilityProxy.setField(popupPreviewPool, "dismissHandler", dismissHandler); |
| |
| // Run test scenario. |
| if (expectShowIfNecessaryIsCalled) { |
| mockPopUpPreview.showIfNecessary(key, popup, false); |
| } |
| if (!popupEnabled) { |
| mockPopUpPreview.dismiss(); |
| } |
| Capture<KeyEventContext> keyEventContextCapture = new Capture<KeyEventContext>(); |
| mockKeyEventHandler.cancelDelayedKeyEvent(isA(KeyEventContext.class)); |
| expectLastCall().anyTimes(); |
| mockKeyEventHandler.maybeStartDelayedKeyEvent(capture(keyEventContextCapture)); |
| mockKeyEventHandler.sendPress('a'); |
| replayAll(); |
| |
| assertTrue(touchEvent(view, MotionEvent.ACTION_DOWN, 75, 45)); |
| verifyAll(); |
| KeyEventContext context = keyEventContextCapture.getValue(); |
| assertEquals(expectLongPressCallbackIsSet, context.longPressCallback.isPresent()); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupEnabled_Trigger_PopupIconPresent() { |
| delayedPopupTestImpl(true, true, true, true, false); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupEnabled_Trigger_PopupIconAbsent() { |
| delayedPopupTestImpl(true, true, false, true, false); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupEnabled_NotTrigger_PopupIconPresent() { |
| delayedPopupTestImpl(true, false, true, true, true); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupEnabled_NotTrigger_PopupIconAbsent() { |
| delayedPopupTestImpl(true, false, false, true, false); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupDisabled_Trigger_PopupIconPresent() { |
| delayedPopupTestImpl(false, true, true, false, false); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupDisabled_Trigger_PopupIconAbsent() { |
| delayedPopupTestImpl(false, true, false, false, false); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupDisabled_NotTrigger_PopupIconPresent() { |
| delayedPopupTestImpl(false, false, true, false, true); |
| } |
| |
| @SmallTest |
| public void testDelayedPopup_PopupDisabled_NotTrigger_PopupIconAbsent() { |
| delayedPopupTestImpl(false, false, false, false, false); |
| } |
| |
| // Unfortunately, there are no way to test multi-touch events because we can create neither |
| // MotionEvent class instances with multi-touch events nor mock instances. |
| // So, just skip the tests for those cases. |
| // TODO(hidehiko): Figure out how to write those tests, though we may need to get rid of |
| // supporting devices with lower APIs for that purpose... |
| |
| @SmallTest |
| public void testGetKeyByCoord() { |
| Key key1 = createKey(0, 0, 'a'); |
| Key key2 = createKey(WIDTH * 2, 0, 'b'); |
| |
| class TestCase { |
| final Key spacer; |
| final Key expectedLeftHalf; |
| final Key expectedRightHalf; |
| |
| TestCase(Key spacer, Key expectedLeftHalf, Key expectedRightHalf) { |
| this.spacer = spacer; |
| this.expectedLeftHalf = expectedLeftHalf; |
| this.expectedRightHalf = expectedRightHalf; |
| } |
| } |
| |
| final TestCase[] testCases = { |
| new TestCase(createSpacer(WIDTH, 0, Stick.EVEN), key1, key2), |
| new TestCase(createSpacer(WIDTH, 0, Stick.LEFT), key1, key1), |
| new TestCase(createSpacer(WIDTH, 0, Stick.RIGHT), key2, key2), |
| }; |
| |
| for (TestCase testCase : testCases) { |
| Row row = new Row(Arrays.asList(key1, testCase.spacer, key2), HEIGHT, VERTICAL_GAP); |
| view.setKeyboard(new Keyboard(Optional.<String>absent(), Collections.singletonList(row), 1, |
| KeyboardSpecification.TWELVE_KEY_TOGGLE_FLICK_KANA)); |
| |
| // Center of key1. |
| assertSame(key1, view.getKeyByCoord(WIDTH / 2, HEIGHT / 2).get()); |
| |
| // Center of key2. |
| assertSame(key2, view.getKeyByCoord(WIDTH * 5 / 2, HEIGHT / 2).get()); |
| |
| // On a spacer. |
| assertSame(testCase.expectedLeftHalf, view.getKeyByCoord(WIDTH * 4 / 3, HEIGHT / 2).get()); |
| assertSame(testCase.expectedRightHalf, view.getKeyByCoord(WIDTH * 5 / 3, HEIGHT / 2).get()); |
| |
| // Both outside of the keyboard. |
| assertSame(key1, view.getKeyByCoord(-WIDTH / 2, HEIGHT / 2).get()); |
| assertSame(key2, view.getKeyByCoord(WIDTH * 7 / 2, HEIGHT / 2).get()); |
| } |
| } |
| |
| @SmallTest |
| public void testOnDetachedFromWindow() { |
| KeyboardViewBackgroundSurface keyboardViewBackgroundSurface = |
| createKeyboardViewBackgroundSurfaceMock(); |
| keyboardViewBackgroundSurface.reset(); |
| replayAll(); |
| VisibilityProxy.setField(view, "backgroundSurface", keyboardViewBackgroundSurface); |
| |
| view.onDetachedFromWindow(); |
| |
| verifyAll(); |
| } |
| |
| @SuppressWarnings("unchecked") |
| @SmallTest |
| public void testSetSkinType() { |
| Resources resources = getInstrumentation().getTargetContext().getResources(); |
| KeyboardViewBackgroundSurface keyboardViewBackgroundSurface = |
| createKeyboardViewBackgroundSurfaceMock(); |
| keyboardViewBackgroundSurface.requestUpdateKeyboard( |
| isA(Keyboard.class), isA(Set.class)); |
| |
| DrawableCache drawableCache = createMockBuilder(DrawableCache.class) |
| .withConstructor(Resources.class) |
| .withArgs(new MockResourcesWithDisplayMetrics()) |
| .createMock(); |
| drawableCache.setSkin(SkinType.ORANGE_LIGHTGRAY.getSkin(resources)); |
| |
| BackgroundDrawableFactory backgroundDrawableFactory = |
| new BackgroundDrawableFactory(createNiceMock(MockResourcesWithDisplayMetrics.class)); |
| backgroundDrawableFactory.setSkin(SkinType.ORANGE_LIGHTGRAY.getSkin(resources)); |
| replayAll(); |
| |
| VisibilityProxy.setField(view, "backgroundSurface", keyboardViewBackgroundSurface); |
| VisibilityProxy.setField(view, "drawableCache", drawableCache); |
| VisibilityProxy.setField(view, "backgroundDrawableFactory", backgroundDrawableFactory); |
| |
| view.setSkin(SkinType.ORANGE_LIGHTGRAY.getSkin(resources)); |
| |
| verifyAll(); |
| } |
| |
| @SmallTest |
| public void testSetKeyboard() { |
| KeyboardView view = new KeyboardView(getInstrumentation().getTargetContext()); |
| Set<MetaState> originalMetaStates = EnumSet.of( |
| MetaState.NO_GLOBE, |
| MetaState.CAPS_LOCK, |
| MetaState.ACTION_GO, |
| MetaState.VARIATION_EMAIL_ADDRESS, |
| MetaState.COMPOSING); |
| view.updateMetaStates(originalMetaStates, EnumSet.noneOf(MetaState.class)); |
| assertEquals(originalMetaStates, view.getMetaStates()); |
| view.setKeyboard(new Keyboard(Optional.<String>absent(), Collections.<Row>emptyList(), 0f, |
| KeyboardSpecification.TWELVE_KEY_TOGGLE_FLICK_KANA)); |
| assertEquals( |
| EnumSet.of( |
| MetaState.NO_GLOBE, |
| MetaState.ACTION_GO, |
| MetaState.VARIATION_EMAIL_ADDRESS, |
| MetaState.COMPOSING), |
| view.getMetaStates()); |
| } |
| |
| @SmallTest |
| public void testSetEditorInfo() { |
| KeyboardView view = new KeyboardView(getInstrumentation().getTargetContext()); |
| |
| class TestData extends Parameter { |
| final int imeOptions; |
| final int inputType; |
| final Set<MetaState> expectedMetaStates; |
| TestData(int imeOptions, int inputType, Set<MetaState> expectedMetaStates) { |
| this.imeOptions = imeOptions; |
| this.inputType = inputType; |
| this.expectedMetaStates = expectedMetaStates; |
| } |
| } |
| |
| // Keep the order. KeyboardView's state is not reset in the iteration. |
| TestData[] testDataList = { |
| new TestData(0, 0, EnumSet.of(MetaState.NO_GLOBE)), |
| new TestData(EditorInfo.IME_ACTION_DONE, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_DONE)), |
| new TestData(EditorInfo.IME_ACTION_GO, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_GO)), |
| new TestData(EditorInfo.IME_ACTION_NEXT, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_NEXT)), |
| new TestData(EditorInfo.IME_ACTION_NONE, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_NONE)), |
| new TestData(EditorInfo.IME_ACTION_PREVIOUS, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_PREVIOUS)), |
| new TestData(EditorInfo.IME_ACTION_SEARCH, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_SEARCH)), |
| new TestData(EditorInfo.IME_ACTION_SEND, |
| 0, EnumSet.of(MetaState.NO_GLOBE, MetaState.ACTION_SEND)), |
| new TestData(0, InputType.TYPE_TEXT_VARIATION_URI | InputType.TYPE_CLASS_TEXT, |
| EnumSet.of(MetaState.NO_GLOBE, MetaState.VARIATION_URI)), |
| new TestData(0, InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS | InputType.TYPE_CLASS_TEXT, |
| EnumSet.of(MetaState.NO_GLOBE, MetaState.VARIATION_EMAIL_ADDRESS)), |
| new TestData(0, InputType.TYPE_TEXT_VARIATION_WEB_EMAIL_ADDRESS | InputType.TYPE_CLASS_TEXT, |
| EnumSet.of(MetaState.NO_GLOBE, MetaState.VARIATION_EMAIL_ADDRESS)), |
| new TestData(0, InputType.TYPE_TEXT_VARIATION_SHORT_MESSAGE | InputType.TYPE_CLASS_TEXT, |
| EnumSet.of(MetaState.NO_GLOBE)), |
| new TestData(0, InputType.TYPE_TEXT_VARIATION_EMAIL_ADDRESS | InputType.TYPE_CLASS_TEXT, |
| EnumSet.of(MetaState.NO_GLOBE, MetaState.VARIATION_EMAIL_ADDRESS)), |
| new TestData(0, InputType.TYPE_NUMBER_VARIATION_PASSWORD | InputType.TYPE_CLASS_NUMBER, |
| EnumSet.of(MetaState.NO_GLOBE)), |
| new TestData(EditorInfo.IME_ACTION_DONE | EditorInfo.IME_FLAG_NO_ENTER_ACTION, |
| 0, EnumSet.of(MetaState.NO_GLOBE)), |
| }; |
| |
| for (TestData testData : testDataList) { |
| EditorInfo editorInfo = new EditorInfo(); |
| editorInfo.imeOptions = testData.imeOptions; |
| editorInfo.inputType = testData.inputType; |
| view.setEditorInfo(editorInfo); |
| assertEquals(testData.toString(), testData.expectedMetaStates, view.getMetaStates()); |
| } |
| } |
| } |
