Fix inconsistent behavior with backspace in the Emoji pallete.

In some ways, the delete key on the Emoji palette was
inconsistent with that in other keyboard layouts.
- It deletes a character in down events, not up events.
- A user cannot cancel the event by moving the finger away from
  the key.

This patch fixes these inconsistencies by revisin
EmojiPalettesView.DeleteKeyOnTouchListener. Notable changes are:
- An explicit state machine is introduced because there are
  different event sequences to be considered.
- Background thread is replaced with CountDownTimer so tha
  key-repeat events can be naturally generated in the UI thread.
- MotionEvent.ACTION_MOVE is now handled to cancel the
  subsequent delete key events when the finger is moved away
  from the key area.

Bug: 12464067
Change-Id: Ibc360a1394afef368a8d9af7b4c0e99e8ce1d83c
main
Yohei Yukawa 2014-01-24 15:31:41 +09:00
parent b1814c9633
commit ea8c1c811c
1 changed files with 97 additions and 59 deletions

View File

@ -23,12 +23,13 @@ import android.content.SharedPreferences;
import android.content.res.ColorStateList;
import android.content.res.Resources;
import android.content.res.TypedArray;
import android.graphics.Color;
import android.graphics.Rect;
import android.os.Build;
import android.os.CountDownTimer;
import android.preference.PreferenceManager;
import android.support.v4.view.PagerAdapter;
import android.support.v4.view.ViewPager;
import android.text.format.DateUtils;
import android.util.AttributeSet;
import android.util.Log;
import android.util.Pair;
@ -58,6 +59,7 @@ import java.util.Arrays;
import java.util.Comparator;
import java.util.HashMap;
import java.util.concurrent.ConcurrentHashMap;
import java.util.concurrent.TimeUnit;
/**
* View class to implement Emoji palettes.
@ -752,9 +754,8 @@ public final class EmojiPalettesView extends LinearLayout implements OnTabChange
}
}
// TODO: Do the same things done in PointerTracker
private static class DeleteKeyOnTouchListener implements OnTouchListener {
private static final long MAX_REPEAT_COUNT_TIME = 30 * DateUtils.SECOND_IN_MILLIS;
private static final long MAX_REPEAT_COUNT_TIME = TimeUnit.SECONDS.toMillis(30);
private final int mDeleteKeyPressedBackgroundColor;
private final long mKeyRepeatStartTimeout;
private final long mKeyRepeatInterval;
@ -765,61 +766,36 @@ public final class EmojiPalettesView extends LinearLayout implements OnTabChange
res.getColor(R.color.emoji_key_pressed_background_color);
mKeyRepeatStartTimeout = res.getInteger(R.integer.config_key_repeat_start_timeout);
mKeyRepeatInterval = res.getInteger(R.integer.config_key_repeat_interval);
mTimer = new CountDownTimer(MAX_REPEAT_COUNT_TIME, mKeyRepeatInterval) {
@Override
public void onTick(long millisUntilFinished) {
final long elapsed = MAX_REPEAT_COUNT_TIME - millisUntilFinished;
if (elapsed < mKeyRepeatStartTimeout) {
return;
}
onKeyRepeat();
}
@Override
public void onFinish() {
onKeyRepeat();
}
};
}
/** Key-repeat state. */
private static final int KEY_REPEAT_STATE_INITIALIZED = 0;
// The key is touched but auto key-repeat is not started yet.
private static final int KEY_REPEAT_STATE_KEY_DOWN = 1;
// At least one key-repeat event has already been triggered and the key is not released.
private static final int KEY_REPEAT_STATE_KEY_REPEAT = 2;
private KeyboardActionListener mKeyboardActionListener =
KeyboardActionListener.EMPTY_LISTENER;
private DummyRepeatKeyRepeatTimer mTimer;
private synchronized void startRepeat() {
if (mTimer != null) {
abortRepeat();
}
mTimer = new DummyRepeatKeyRepeatTimer();
mTimer.start();
}
private synchronized void abortRepeat() {
mTimer.abort();
mTimer = null;
}
// TODO: Remove
// This function is mimicking the repeat code in PointerTracker.
// Specifically referring to PointerTracker#startRepeatKey and PointerTracker#onKeyRepeat.
private class DummyRepeatKeyRepeatTimer extends Thread {
public boolean mAborted = false;
@Override
public void run() {
int repeatCount = 1;
int timeCount = 0;
while (timeCount < MAX_REPEAT_COUNT_TIME && !mAborted) {
if (timeCount > mKeyRepeatStartTimeout) {
pressDelete(repeatCount);
}
timeCount += mKeyRepeatInterval;
++repeatCount;
try {
Thread.sleep(mKeyRepeatInterval);
} catch (InterruptedException e) {
}
}
}
public void abort() {
mAborted = true;
}
}
public void pressDelete(final int repeatCount) {
mKeyboardActionListener.onPressKey(
Constants.CODE_DELETE, repeatCount, true /* isSinglePointer */);
mKeyboardActionListener.onCodeInput(
Constants.CODE_DELETE, NOT_A_COORDINATE, NOT_A_COORDINATE);
mKeyboardActionListener.onReleaseKey(
Constants.CODE_DELETE, false /* withSliding */);
}
// TODO: Do the same things done in PointerTracker
private final CountDownTimer mTimer;
private int mState = KEY_REPEAT_STATE_INITIALIZED;
private int mRepeatCount = 0;
public void setKeyboardActionListener(final KeyboardActionListener listener) {
mKeyboardActionListener = listener;
@ -827,18 +803,80 @@ public final class EmojiPalettesView extends LinearLayout implements OnTabChange
@Override
public boolean onTouch(final View v, final MotionEvent event) {
switch(event.getAction()) {
switch (event.getActionMasked()) {
case MotionEvent.ACTION_DOWN:
v.setBackgroundColor(mDeleteKeyPressedBackgroundColor);
pressDelete(0 /* repeatCount */);
startRepeat();
onTouchDown(v);
return true;
case MotionEvent.ACTION_MOVE:
final float x = event.getX();
final float y = event.getY();
if (x < 0.0f || v.getWidth() < x || y < 0.0f || v.getHeight() < y) {
// Stop generating key events once the finger moves away from the view area.
onTouchCanceled(v);
}
return true;
case MotionEvent.ACTION_CANCEL:
case MotionEvent.ACTION_UP:
v.setBackgroundColor(0);
abortRepeat();
onTouchUp(v);
return true;
}
return false;
}
private void handleKeyDown() {
mKeyboardActionListener.onPressKey(
Constants.CODE_DELETE, mRepeatCount, true /* isSinglePointer */);
}
private void handleKeyUp() {
mKeyboardActionListener.onCodeInput(
Constants.CODE_DELETE, NOT_A_COORDINATE, NOT_A_COORDINATE);
mKeyboardActionListener.onReleaseKey(
Constants.CODE_DELETE, false /* withSliding */);
++mRepeatCount;
}
private void onTouchDown(final View v) {
mTimer.cancel();
mRepeatCount = 0;
handleKeyDown();
v.setBackgroundColor(mDeleteKeyPressedBackgroundColor);
mState = KEY_REPEAT_STATE_KEY_DOWN;
mTimer.start();
}
private void onTouchUp(final View v) {
mTimer.cancel();
if (mState == KEY_REPEAT_STATE_KEY_DOWN) {
handleKeyUp();
}
v.setBackgroundColor(Color.TRANSPARENT);
mState = KEY_REPEAT_STATE_INITIALIZED;
}
private void onTouchCanceled(final View v) {
mTimer.cancel();
v.setBackgroundColor(Color.TRANSPARENT);
mState = KEY_REPEAT_STATE_INITIALIZED;
}
// Called by {@link #mTimer} in the UI thread as an auto key-repeat signal.
private void onKeyRepeat() {
switch (mState) {
case KEY_REPEAT_STATE_INITIALIZED:
// Basically this should not happen.
break;
case KEY_REPEAT_STATE_KEY_DOWN:
// Do not call {@link #handleKeyDown} here because it has already been called
// in {@link #onTouchDown}.
handleKeyUp();
mState = KEY_REPEAT_STATE_KEY_REPEAT;
break;
case KEY_REPEAT_STATE_KEY_REPEAT:
handleKeyDown();
handleKeyUp();
break;
}
}
}
}