forked from extern/Unexpected-Keyboard
833dfa31bb
'keyVerticalInterval' was mistakenly used to compute the height of the keyboard and the vertical position of keys. While the code handling pointers did not use this value, the hit box of the bottom row was shifted by several pixels. Make sure 'keyVerticalInterval' is only used for rendering and not for placing the keys.
464 lines
13 KiB
Java
464 lines
13 KiB
Java
package juloo.keyboard2;
|
|
|
|
import android.content.Context;
|
|
import android.graphics.Canvas;
|
|
import android.graphics.Paint;
|
|
import android.graphics.RectF;
|
|
import android.os.Handler;
|
|
import android.os.Message;
|
|
import android.os.Vibrator;
|
|
import android.util.AttributeSet;
|
|
import android.util.DisplayMetrics;
|
|
import android.view.KeyEvent;
|
|
import android.view.MotionEvent;
|
|
import android.view.View;
|
|
import android.widget.PopupWindow;
|
|
import java.util.ArrayList;
|
|
|
|
public class Keyboard2View extends View
|
|
implements View.OnTouchListener, Handler.Callback
|
|
{
|
|
private static final long VIBRATE_MIN_INTERVAL = 100;
|
|
|
|
private KeyboardData _keyboard;
|
|
|
|
private ArrayList<KeyDown> _downKeys = new ArrayList<KeyDown>();
|
|
|
|
private int _flags = 0;
|
|
|
|
private Vibrator _vibratorService;
|
|
private long _lastVibration = 0;
|
|
|
|
private Handler _handler;
|
|
private static int _currentWhat = 0;
|
|
|
|
private Config _config;
|
|
|
|
private float _keyWidth;
|
|
|
|
private Theme _theme;
|
|
|
|
private static RectF _tmpRect = new RectF();
|
|
|
|
public Keyboard2View(Context context, AttributeSet attrs)
|
|
{
|
|
super(context, attrs);
|
|
_vibratorService = (Vibrator)context.getSystemService(Context.VIBRATOR_SERVICE);
|
|
_handler = new Handler(this);
|
|
_theme = new Theme(getContext(), attrs);
|
|
_config = Config.globalConfig();
|
|
refreshConfig(null);
|
|
setOnTouchListener(this);
|
|
}
|
|
|
|
/* Internally calls [reset()]. */
|
|
public void refreshConfig(KeyboardData kw)
|
|
{
|
|
if (kw != null)
|
|
setKeyboard(kw); // handle layout options then calls reset().
|
|
}
|
|
|
|
public void setKeyboard(KeyboardData kw)
|
|
{
|
|
if (!_config.shouldOfferSwitchingToNextInputMethod)
|
|
kw = kw.replaceKeys(
|
|
new KeyboardData.ReplaceKeysByEvent(KeyValue.EVENT_CHANGE_METHOD, null));
|
|
if (_config.key_flags_to_remove != 0)
|
|
kw = kw.replaceKeys(
|
|
new KeyboardData.ReplaceKeysByFlags(_config.key_flags_to_remove, null));
|
|
// Replace the action key to show the right label.
|
|
KeyValue action_key = null;
|
|
if (_config.actionLabel != null)
|
|
{
|
|
action_key = new KeyValue(_config.actionLabel, _config.actionLabel,
|
|
KeyValue.CHAR_NONE, KeyValue.EVENT_ACTION, KeyValue.FLAG_NOREPEAT);
|
|
}
|
|
if (_config.swapEnterActionKey && action_key != null)
|
|
kw = kw.replaceKeys(
|
|
new KeyboardData.ReplaceKeysByEvent2(KeyEvent.KEYCODE_ENTER,
|
|
action_key, KeyValue.EVENT_ACTION,
|
|
KeyValue.getKeyByName("enter")));
|
|
else
|
|
kw = kw.replaceKeys(
|
|
new KeyboardData.ReplaceKeysByEvent(KeyValue.EVENT_ACTION, action_key));
|
|
_keyboard = kw;
|
|
reset();
|
|
}
|
|
|
|
public void reset()
|
|
{
|
|
_flags = 0;
|
|
_downKeys.clear();
|
|
requestLayout();
|
|
invalidate();
|
|
}
|
|
|
|
@Override
|
|
public boolean onTouch(View v, MotionEvent event)
|
|
{
|
|
float x;
|
|
float y;
|
|
float keyW;
|
|
int p;
|
|
|
|
switch (event.getActionMasked())
|
|
{
|
|
case MotionEvent.ACTION_UP:
|
|
case MotionEvent.ACTION_POINTER_UP:
|
|
onTouchUp(event.getPointerId(event.getActionIndex()));
|
|
break ;
|
|
case MotionEvent.ACTION_DOWN:
|
|
case MotionEvent.ACTION_POINTER_DOWN:
|
|
p = event.getActionIndex();
|
|
onTouchDown(event.getX(p), event.getY(p), event.getPointerId(p));
|
|
break ;
|
|
case MotionEvent.ACTION_MOVE:
|
|
for (p = 0; p < event.getPointerCount(); p++)
|
|
onTouchMove(event.getX(p), event.getY(p), event.getPointerId(p));
|
|
break ;
|
|
default:
|
|
return (false);
|
|
}
|
|
return (true);
|
|
}
|
|
|
|
private KeyDown getKeyDown(int pointerId)
|
|
{
|
|
for (KeyDown k : _downKeys)
|
|
{
|
|
if (k.pointerId == pointerId)
|
|
return (k);
|
|
}
|
|
return (null);
|
|
}
|
|
|
|
private KeyDown getKeyDown(KeyboardData.Key key)
|
|
{
|
|
for (KeyDown k : _downKeys)
|
|
{
|
|
if (k.key == key)
|
|
return (k);
|
|
}
|
|
return (null);
|
|
}
|
|
|
|
private KeyDown getKeyDown(KeyValue kv)
|
|
{
|
|
for (KeyDown k : _downKeys)
|
|
{
|
|
if (k.value == kv)
|
|
return (k);
|
|
}
|
|
return (null);
|
|
}
|
|
|
|
private void onTouchMove(float moveX, float moveY, int pointerId)
|
|
{
|
|
KeyDown key = getKeyDown(pointerId);
|
|
KeyValue newValue;
|
|
|
|
if (key != null)
|
|
{
|
|
moveX -= key.downX;
|
|
moveY -= key.downY;
|
|
float absDist = Math.abs(moveX) + Math.abs(moveY);
|
|
key.ptrDist = absDist;
|
|
if (absDist < _config.swipe_dist_px)
|
|
newValue = key.key.key0;
|
|
else if (moveX < 0)
|
|
newValue = (moveY < 0) ? key.key.key1 : key.key.key3;
|
|
else if (moveY < 0)
|
|
newValue = key.key.key2;
|
|
else
|
|
newValue = key.key.key4;
|
|
if (newValue != null && newValue != key.value)
|
|
{
|
|
if (key.timeoutWhat != -1)
|
|
{
|
|
_handler.removeMessages(key.timeoutWhat);
|
|
if ((newValue.flags & KeyValue.FLAG_NOREPEAT) == 0)
|
|
_handler.sendEmptyMessageDelayed(key.timeoutWhat, _config.longPressTimeout);
|
|
}
|
|
key.value = newValue;
|
|
key.flags = newValue.flags;
|
|
updateFlags();
|
|
invalidate();
|
|
handleKeyDown(newValue);
|
|
}
|
|
}
|
|
}
|
|
|
|
private void onTouchDown(float touchX, float touchY, int pointerId)
|
|
{
|
|
float y = _config.marginTop - _config.keyHeight;
|
|
for (KeyboardData.Row row : _keyboard.rows)
|
|
{
|
|
y += _config.keyHeight;
|
|
if (touchY < y || touchY >= (y + _config.keyHeight))
|
|
continue ;
|
|
float x = _config.horizontalMargin;
|
|
for (KeyboardData.Key key : row.keys)
|
|
{
|
|
x += key.shift * _keyWidth;
|
|
float keyW = _keyWidth * key.width;
|
|
if (touchX >= x && touchX < (x + keyW))
|
|
{
|
|
int what = _currentWhat++;
|
|
if (key.key0 != null && (key.key0.flags & KeyValue.FLAG_NOREPEAT) == 0)
|
|
_handler.sendEmptyMessageDelayed(what, _config.longPressTimeout);
|
|
_downKeys.add(new KeyDown(pointerId, key, touchX, touchY, what));
|
|
handleKeyDown(key.key0);
|
|
updateFlags();
|
|
invalidate();
|
|
return ;
|
|
}
|
|
x += keyW;
|
|
}
|
|
}
|
|
}
|
|
|
|
// Whether a key is already activated (key down but pointer up)
|
|
private KeyDown getActivatedKey(KeyValue kv)
|
|
{
|
|
for (KeyDown k : _downKeys)
|
|
{
|
|
if (k.value == kv && k.pointerId == -1)
|
|
return (k);
|
|
}
|
|
return (null);
|
|
}
|
|
|
|
private void onTouchUp(int pointerId)
|
|
{
|
|
KeyDown k = getKeyDown(pointerId);
|
|
|
|
if (k != null)
|
|
{
|
|
// Stop key repeat
|
|
if (k.timeoutWhat != -1)
|
|
{
|
|
_handler.removeMessages(k.timeoutWhat);
|
|
k.timeoutWhat = -1;
|
|
}
|
|
KeyDown k_on = getActivatedKey(k.value);
|
|
if (k_on != null)
|
|
{
|
|
_downKeys.remove(k); // Remove dupplicate
|
|
// Same key with FLAG_LOCK is already on, do lock
|
|
if ((k_on.flags & KeyValue.FLAG_LOCK) != 0)
|
|
{
|
|
k_on.flags ^= KeyValue.FLAG_LOCK; // Next time, disable it
|
|
k_on.flags |= KeyValue.FLAG_LOCKED;
|
|
}
|
|
// Otherwise, toggle it
|
|
else
|
|
{
|
|
_downKeys.remove(k_on);
|
|
}
|
|
}
|
|
// Key stay activated
|
|
else if ((k.flags & KeyValue.FLAG_KEEP_ON) != 0)
|
|
{
|
|
k.pointerId = -1; // Set pointer up
|
|
}
|
|
else // Regular key up
|
|
{
|
|
for (int i = 0; i < _downKeys.size(); i++)
|
|
{
|
|
KeyDown downKey = _downKeys.get(i);
|
|
// Disable other activated keys that aren't locked
|
|
if (downKey.pointerId == -1 && (downKey.flags & KeyValue.FLAG_LOCKED) == 0)
|
|
_downKeys.remove(i--);
|
|
// Other keys currently down won't stay activated
|
|
else if ((downKey.flags & KeyValue.FLAG_KEEP_ON) != 0)
|
|
downKey.flags ^= KeyValue.FLAG_KEEP_ON;
|
|
}
|
|
_downKeys.remove(k);
|
|
handleKeyUp(k);
|
|
}
|
|
updateFlags();
|
|
invalidate();
|
|
}
|
|
}
|
|
|
|
private void handleKeyUp(KeyDown key)
|
|
{
|
|
if (key.value != null && (key.flags & (KeyValue.FLAG_LOCKED | KeyValue.FLAG_NOCHAR)) == 0)
|
|
_config.handler.handleKeyUp(key.value, _flags);
|
|
}
|
|
|
|
private void handleKeyDown(KeyValue key)
|
|
{
|
|
if (key == null)
|
|
return ;
|
|
vibrate();
|
|
}
|
|
|
|
private void updateFlags()
|
|
{
|
|
_flags = 0;
|
|
for (KeyDown k : _downKeys)
|
|
_flags |= k.flags;
|
|
}
|
|
|
|
private void vibrate()
|
|
{
|
|
if (!_config.vibrateEnabled)
|
|
return ;
|
|
long now = System.currentTimeMillis();
|
|
if ((now - _lastVibration) > VIBRATE_MIN_INTERVAL)
|
|
{
|
|
_lastVibration = now;
|
|
try
|
|
{
|
|
_vibratorService.vibrate(_config.vibrateDuration);
|
|
}
|
|
catch (Exception e)
|
|
{
|
|
e.printStackTrace();
|
|
}
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public boolean handleMessage(Message msg)
|
|
{
|
|
for (KeyDown key : _downKeys)
|
|
{
|
|
if (key.timeoutWhat == msg.what)
|
|
{
|
|
long nextInterval = _config.longPressInterval;
|
|
if (_config.preciseRepeat && (key.flags & KeyValue.FLAG_PRECISE_REPEAT) != 0)
|
|
{
|
|
// Modulate repeat interval depending on the distance of the pointer
|
|
float accel = Math.min(4.f, Math.max(0.3f, key.ptrDist / (_config.swipe_dist_px * 15.f)));
|
|
nextInterval = (long)((float)nextInterval / accel);
|
|
}
|
|
_handler.sendEmptyMessageDelayed(msg.what, nextInterval);
|
|
_config.handler.handleKeyUp(key.value, _flags);
|
|
return (true);
|
|
}
|
|
}
|
|
return (false);
|
|
}
|
|
|
|
@Override
|
|
public void onMeasure(int wSpec, int hSpec)
|
|
{
|
|
DisplayMetrics dm = getContext().getResources().getDisplayMetrics();
|
|
int width = dm.widthPixels;
|
|
int height =
|
|
(int)(_config.keyHeight * _keyboard.keysHeight
|
|
+ _keyboard.rows.size()
|
|
+ _config.marginTop + _config.marginBottom);
|
|
setMeasuredDimension(width, height);
|
|
_keyWidth = (width - (_config.horizontalMargin * 2)) / _keyboard.keysWidth;
|
|
}
|
|
|
|
@Override
|
|
protected void onDraw(Canvas canvas)
|
|
{
|
|
float y = _config.marginTop + _config.keyVerticalInterval / 2;
|
|
for (KeyboardData.Row row : _keyboard.rows)
|
|
{
|
|
y += row.shift * _config.keyHeight;
|
|
float x = _config.horizontalMargin + _config.keyHorizontalInterval / 2;
|
|
float keyH = row.height * _config.keyHeight - _config.keyVerticalInterval;
|
|
for (KeyboardData.Key k : row.keys)
|
|
{
|
|
x += k.shift * _keyWidth;
|
|
float keyW = _keyWidth * k.width - _config.keyHorizontalInterval;
|
|
KeyDown keyDown = getKeyDown(k);
|
|
_tmpRect.set(x, y, x + keyW, y + keyH);
|
|
canvas.drawRoundRect(_tmpRect, _theme.keyBorderRadius, _theme.keyBorderRadius,
|
|
(keyDown != null) ? _theme.keyDownBgPaint : _theme.keyBgPaint);
|
|
if (k.key0 != null)
|
|
drawLabel(canvas, k.key0, keyW / 2f + x, (keyH + _theme.labelTextSize) / 2f + y, keyDown);
|
|
float subPadding = _config.keyPadding;
|
|
if (k.key1 != null)
|
|
drawSubLabel(canvas, k.key1, x + subPadding, y + subPadding, false, true, keyDown);
|
|
if (k.key3 != null)
|
|
drawSubLabel(canvas, k.key3, x + subPadding, y + keyH - subPadding, false, false, keyDown);
|
|
if (k.key2 != null)
|
|
drawSubLabel(canvas, k.key2, x + keyW - subPadding, y + subPadding, true, true, keyDown);
|
|
if (k.key4 != null)
|
|
drawSubLabel(canvas, k.key4, x + keyW - subPadding, y + keyH - subPadding, true, false, keyDown);
|
|
x += _keyWidth * k.width;
|
|
}
|
|
y += row.height * _config.keyHeight;
|
|
}
|
|
}
|
|
|
|
@Override
|
|
public void onDetachedFromWindow()
|
|
{
|
|
super.onDetachedFromWindow();
|
|
}
|
|
|
|
private int labelColor(KeyValue k, KeyDown hasKeyDown, int defaultColor)
|
|
{
|
|
if (hasKeyDown != null)
|
|
{
|
|
KeyDown kd = getKeyDown(k);
|
|
if (kd != null)
|
|
{
|
|
if ((kd.flags & KeyValue.FLAG_LOCKED) != 0)
|
|
return _theme.lockedColor;
|
|
if (kd.pointerId == -1)
|
|
return _theme.activatedColor;
|
|
}
|
|
}
|
|
return defaultColor;
|
|
}
|
|
|
|
private void drawLabel(Canvas canvas, KeyValue k, float x, float y, KeyDown keyDown)
|
|
{
|
|
k = KeyModifier.handleFlags(k, _flags);
|
|
Paint p = _theme.labelPaint(((k.flags & KeyValue.FLAG_KEY_FONT) != 0));
|
|
p.setColor(labelColor(k, keyDown, _theme.labelColor));
|
|
p.setTextSize(_theme.labelTextSize * scaleTextSize(k));
|
|
canvas.drawText(k.symbol, x, y, p);
|
|
}
|
|
|
|
private void drawSubLabel(Canvas canvas, KeyValue k, float x, float y, boolean right, boolean up, KeyDown keyDown)
|
|
{
|
|
k = KeyModifier.handleFlags(k, _flags);
|
|
Paint p = _theme.subLabelPaint(((k.flags & KeyValue.FLAG_KEY_FONT) != 0), right);
|
|
p.setColor(labelColor(k, keyDown, _theme.subLabelColor));
|
|
p.setTextSize(_theme.sublabelTextSize * scaleTextSize(k));
|
|
y -= up ? p.ascent() : p.descent();
|
|
canvas.drawText(k.symbol, x, y, p);
|
|
}
|
|
|
|
private float scaleTextSize(KeyValue k)
|
|
{
|
|
return ((k.symbol.length() < 2) ? 1.f : 0.8f) * _config.characterSize;
|
|
}
|
|
|
|
private static class KeyDown
|
|
{
|
|
/* -1 if pointer is up. */
|
|
public int pointerId;
|
|
public KeyValue value;
|
|
public KeyboardData.Key key;
|
|
public float downX;
|
|
public float downY;
|
|
/* Manhattan distance of the pointer to the center of the key */
|
|
public float ptrDist;
|
|
public int flags;
|
|
public int timeoutWhat;
|
|
|
|
public KeyDown(int pointerId, KeyboardData.Key key, float x, float y, int what)
|
|
{
|
|
this.pointerId = pointerId;
|
|
value = key.key0;
|
|
this.key = key;
|
|
downX = x;
|
|
downY = y;
|
|
ptrDist = 0.f;
|
|
flags = (value == null) ? 0 : value.flags;
|
|
timeoutWhat = what;
|
|
}
|
|
}
|
|
}
|