/// <summary>
/// This method is called when the user presses a key on the keyboard.
/// This method then sanitizes the input, and sends it to the method
/// to handle the letter guessed.
/// </summary>
/// <param name="v"></param>
/// <param name="keyCode"></param>
/// <param name="e"></param>
/// <returns></returns>
bool IOnKeyListener.OnKey(View v, Keycode keyCode, KeyEvent e)
{
if (e.Action == KeyEventActions.Up)
{
Console.WriteLine(keyCode.ToString());
Console.WriteLine(e.ToString());
Console.WriteLine(e.UnicodeChar);
bool bEnteredChar = char.IsLetter((char)e.UnicodeChar);
if (bEnteredChar)
{
GuessCharacterInWord(keyCode.ToString());
return(true);
}
else
{
Console.WriteLine("Unknown key entered");
//Toast.MakeText(this,
// string.Format("Unknown key {0} entered!", keyCode.ToString()),
// ToastLength.Long).Show();
return(false);
}
}
else
{
return(false);
}
}
public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
{
System.Diagnostics.Debug.WriteLine($"OnKeyDown: keyCode:{keyCode}, long:{e.IsLongPress}");
/*if ((_lastKeyCodeTime != DateTime.MinValue) &&
* ((DateTime.Now - _lastKeyCodeTime).TotalMilliseconds<250) &&
* !e.IsLongPress &&
* _lastKeyCode == keyCode
* )
* {
* return base.OnKeyDown(keyCode, e); // prevent multiple key
* }
*
* _lastKeyCodeTime = DateTime.Now;
* _lastKeyCode = keyCode;*/
if (e.IsLongPress)
{
MessagingCenter.Send(keyCode.ToString(), BaseViewModel.KeyLongMessage);
}
MessagingCenter.Send(keyCode.ToString(), BaseViewModel.KeyMessage);
return(base.OnKeyDown(keyCode, e));
}
public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
{
if (keyCode == Keycode.Back && e.Action == KeyEventActions.Down)
{
if (!lastBackKeyDownTime.HasValue || System.DateTime.Now - lastBackKeyDownTime.Value > new System.TimeSpan(0, 0, 2))
{
Toast.MakeText(this.ApplicationContext, "再按一次退出程序", ToastLength.Short).Show();
lastBackKeyDownTime = System.DateTime.Now;
}
else
{
thread.Interrupt();
mReader.signOut();
ModuleManager.NewInstance().SetScanStatus(false);
ModuleManager.NewInstance().SetUHFStatus(false);
Finish();
}
return(true);
}
if (keyCode.ToString() == "F4")
{
RunOnUiThread(() =>
{
Thread.Sleep(150);
listAdapter.refresh(items);
});
return(true);
}
return(base.OnKeyDown(keyCode, e));
}
public static Key GetKeyCodeAsKey(Keycode keycode)
{
string key = keycode.ToString();
if (key.StartsWith(Keycode.Num.ToString()))
{
key = "Number" + key.Last();
}
switch (keycode)
{
case Keycode.Back:
return(Key.Escape);
case Keycode.Del:
return(Key.Back);
default:
if (Enum.TryParse(key, out Key result))
{
return(result);
}
break;
}
return(Key.Unknown);
}
public override bool OnKeyUp([GeneratedEnum] Keycode keyCode, KeyEvent e)
{
var handled = true;
string key = keyCode.ToString();
if (!key.Equals("Enter"))
{
if (key.Contains("Num"))
{
keys += key.Replace("Num", "");
}
else
{
keys += key;
}
}
else
{
if (_page is MainPageView)
{
MainPageView view = _page as MainPageView;
view.Scanner(keys, e.ToString());
}
keys = string.Empty;
}
return(handled || base.OnKeyUp(keyCode, e));
}
public bool OnKey(View view, [GeneratedEnum] Keycode keyCode, KeyEvent e)
{
if (view.Id == Resource.Id.zipCodeEntry)
{
Log.Debug("V", keyCode.ToString()); // Validate key by key
}
return(false);
}
public static string DisplayString(Keycode k)
{
if (!KeyNames.TryGetValue(k, out var ret))
{
return(k.ToString());
}
return(ret);
}
public override bool OnKeyUp([GeneratedEnum] Keycode keyCode, KeyEvent e)
{
var handled = false;
if (e.IsCtrlPressed)
{
switch (keyCode)
{
case Keycode.X:
_page?.OnKeyCommand(KeyCommand.Cut);
break;
case Keycode.C:
_page?.OnKeyCommand(KeyCommand.Copy);
handled = true;
break;
case Keycode.V:
_page?.OnKeyCommand(KeyCommand.Paste);
handled = true;
break;
default:
break;
}
}
else
{
if (keyCode >= Keycode.A && keyCode <= Keycode.Z)
{
// Letter
handled = true;
}
else if ((keyCode >= Keycode.Num0 && keyCode <= Keycode.Num9) ||
(keyCode >= Keycode.Numpad0 && keyCode <= Keycode.Num9))
{
// Number
handled = true;
}
var desc = $"{_page?.Name ?? string.Empty} : {nameof(OnKeyUp)} : {keyCode}";
System.Diagnostics.Debug.WriteLine(desc);
if (handled)
{
_page?.OnKeyUp(keyCode.ToString(), desc);
}
}
return(handled || base.OnKeyUp(keyCode, e));
}
/// <summary>
/// 监听按键
/// </summary>
/// <param name="keyCode">按键码</param>
/// <param name="event">按键事件</param>
public void OnKeyEvent(Keycode keyCode, KeyEvent @event)
{
var code = keyCode.ToString();
if (string.IsNullOrWhiteSpace(code))
{
return;
}
code = code.ToLower();
switch (@event.Action)
{
case KeyEventActions.Down:
//按键按下事件
if (events.events.ContainsKey($"{OnKeyDownKey}{code}"))
{
events.events[$"{OnKeyDownKey}{code}"]?.Invoke();
}
//一次性的按键按下事件
if (events.eventsOnce.ContainsKey($"{OnKeyDownKey}{code}"))
{
events.eventsOnce[$"{OnKeyDownKey}{code}"]?.Invoke();
}
break;
case KeyEventActions.Up:
//按键弹起事件
if (events.events.ContainsKey($"{OnKeyUpKey}{code}"))
{
events.events[$"{OnKeyUpKey}{code}"]?.Invoke();
}
//一次性的按键弹起事件
if (events.eventsOnce.ContainsKey($"{OnKeyUpKey}{code}"))
{
events.eventsOnce[$"{OnKeyUpKey}{code}"]?.Invoke();
}
break;
default:
//其他事件
break;
}
}
private void keyDown(Keycode arg, KeyEvent e)
{
Key key = AndroidKeyboardHandler.GetKeyCodeAsKey(arg);
string keynum = arg.ToString();
bool upper = e.IsShiftPressed;
if (keynum.StartsWith(Keycode.Num.ToString()))
{
switch (keynum.Last())
{
case '1':
pending = upper ? "!" : "1";
return;
case '2':
pending = upper ? "@" : "2";
return;
case '3':
pending = upper ? "#" : "3";
return;
case '4':
pending = upper ? "$" : "4";
return;
case '5':
pending = upper ? "%" : "5";
return;
case '6':
pending = upper ? "^" : "6";
return;
case '7':
pending = upper ? "&" : "7";
return;
case '8':
pending = upper ? "*" : "8";
return;
case '9':
pending = upper ? "(" : "9";
return;
case '0':
pending = upper ? ")" : "0";
return;
default:
pending = "" + keynum.Last();
return;
}
}
switch (arg)
{
default:
pending += upper ? e.DisplayLabel.ToString() : e.DisplayLabel.ToString().ToLower();
break;
}
}
public static string DisplayString(Keycode k)
{
string ret;
if (!KeyNames.TryGetValue(k, out ret))
return k.ToString();
return ret;
}
/// <summary>
/// This method maps the <see cref="Xamarin.Android"/> <see cref="Keycode"/> to <see cref="Key"/> from opentk.
/// </summary>
/// <param name="code">The <see cref="Keycode"/> to be converted into a <see cref="Key"/>.</param>
/// <returns>The <see cref="Key"/> that was converted from <see cref="Keycode"/>.</returns>
public static Key GetKeyCodeAsKey(Keycode keyCode)
{
int code = (int)keyCode;
// number keys
int firstNumKey = (int)Keycode.Num0;
int lastNumKey = (int)Keycode.Num9;
if (code >= firstNumKey && code <= lastNumKey)
{
return(Key.Number0 + code - firstNumKey);
}
// letters
int firstLetterKey = (int)Keycode.A;
int lastLetterKey = (int)Keycode.Z;
if (code >= firstLetterKey && code <= lastLetterKey)
{
return(Key.A + code - firstLetterKey);
}
// function keys
int firstFuntionKey = (int)Keycode.F1;
int lastFunctionKey = (int)Keycode.F12;
if (code >= firstFuntionKey && code <= lastFunctionKey)
{
return(Key.F1 + code - firstFuntionKey);
}
// keypad keys
int firstKeypadKey = (int)Keycode.Numpad0;
int lastKeyPadKey = (int)Keycode.NumpadDot;
if (code >= firstKeypadKey && code <= lastKeyPadKey)
{
return(Key.Keypad0 + code - firstKeypadKey);
}
// direction keys
int firstDirectionKey = (int)Keycode.DpadUp;
int lastDirectionKey = (int)Keycode.DpadRight;
if (code >= firstDirectionKey && code <= lastDirectionKey)
{
return(Key.Up + code - firstDirectionKey);
}
// one to one mappings
switch (keyCode)
{
case Keycode.Back:
return(Key.Escape);
case Keycode.MediaPlayPause:
return(Key.PlayPause);
case Keycode.SoftLeft:
return(Key.Left);
case Keycode.SoftRight:
return(Key.Right);
case Keycode.Star:
return(Key.KeypadMultiply);
case Keycode.Pound:
return(Key.BackSlash); // english keyboard layout
case Keycode.Del:
return(Key.BackSpace);
case Keycode.ForwardDel:
return(Key.Delete);
case Keycode.Power:
return(Key.Sleep);
case Keycode.MoveEnd:
return(Key.End);
case Keycode.MediaPause:
return(Key.Pause);
case Keycode.MediaClose:
return(Key.Stop);
case Keycode.LeftBracket:
return(Key.BracketLeft);
case Keycode.RightBracket:
return(Key.BracketRight);
case Keycode.MediaPrevious:
return(Key.TrackPrevious);
case Keycode.MediaNext:
return(Key.TrackNext);
case Keycode.CtrlLeft:
return(Key.ControlLeft);
case Keycode.CtrlRight:
return(Key.ControlRight);
case Keycode.MetaLeft:
return(Key.WinLeft);
case Keycode.MetaRight:
return(Key.WinRight);
case Keycode.Equals:
return(Key.Plus);
case Keycode.At:
case Keycode.Apostrophe:
return(Key.Quote);
}
if (Enum.TryParse(keyCode.ToString(), out Key key))
{
return(key);
}
// this is the worst case senario. Please note that the osu-framework keyboard handling cannot cope with Key.Unknown.
return(Key.Unknown);
}
private void keyDown(Keycode arg, KeyEvent e)
{
Key key = AndroidKeyboardHandler.GetKeyCodeAsKey(arg);
string keynum = arg.ToString();
bool upper = e.IsShiftPressed;
if (keynum.StartsWith(Keycode.Num.ToString()))
{
switch (keynum.Last())
{
case '1':
pending = upper ? "!" : "1";
return;
case '2':
pending = upper ? "@" : "2";
return;
case '3':
pending = upper ? "#" : "3";
return;
case '4':
pending = upper ? "$" : "4";
return;
case '5':
pending = upper ? "%" : "5";
return;
case '6':
pending = upper ? "^" : "6";
return;
case '7':
pending = upper ? "&" : "7";
return;
case '8':
pending = upper ? "*" : "8";
return;
case '9':
pending = upper ? "(" : "9";
return;
case '0':
pending = upper ? ")" : "0";
return;
default:
pending = "" + keynum.Last();
return;
}
}
if (upper)
{
char toAdd;
switch (arg)
{
case Keycode.Grave:
toAdd = '~';
break;
case Keycode.Minus:
toAdd = '_';
break;
case Keycode.Equals:
toAdd = '+';
break;
case Keycode.LeftBracket:
toAdd = '{';
break;
case Keycode.RightBracket:
toAdd = '}';
break;
case Keycode.Backslash:
toAdd = '|';
break;
case Keycode.Apostrophe:
toAdd = '"';
break;
case Keycode.Semicolon:
toAdd = ':';
break;
case Keycode.Slash:
toAdd = '?';
break;
case Keycode.Period:
toAdd = '>';
break;
case Keycode.Comma:
toAdd = '<';
break;
default:
toAdd = e.DisplayLabel;
break;
}
pending += toAdd;
}
else
{
pending += e.DisplayLabel.ToString().ToLower();
}
}
public override bool OnKeyUp([GeneratedEnum] Keycode keyCode, KeyEvent e)
{
System.Console.WriteLine(keyCode.ToString());
return(base.OnKeyUp(keyCode, e));
}
public override bool OnKeyDown([GeneratedEnum] Keycode keyCode, KeyEvent e)
{
Xamarin.Forms.MessagingCenter.Send <IKeyEventSender, string>(this, "KeyDown", keyCode.ToString());
return(base.OnKeyDown(keyCode, e));
}
public override bool OnKeyDown(Keycode keyCode, KeyEvent e)
{
MessagingCenter.Send(keyCode.ToString(), BaseViewModel.MSG_KeyDown);
return(base.OnKeyDown(keyCode, e));
}
public override bool OnKeyUp(Keycode keyCode, KeyEvent e)
{
Xamarin.Forms.MessagingCenter.Send <IKeyboardListener, string>(this, "KeyboardListener", keyCode.ToString());
return(base.OnKeyUp(keyCode, e));
}