我正在覆盖要捕获的视图（openGL表面视图）的onKeyDown方法 所有的按键。问题是在几个设备上KEYCODE_DEL不是 抓获。我尝试在视图中添加一个onKeyListener，并捕获除了退格键之外的所有内容。
必须有一种方法来听这个关键的新闻事件，但是如何？
答案 0 :(得分：50)
2014年12月12日更新：将修复范围更改为不限于＆lt; API级别19，因为在第三方键盘上仍然存在超过19的错误。
1/9/2014更新：我已经设计了一种方法，通过代码解决所有Google键盘（LatinIME）KEYCODE_DEL问题，特别是 问题42904和62306。
Turix的答案中的增强功能已经获得许可，已纳入我自己的代码。删除Turix的改进需要将垃圾字符注入可编辑缓冲区，而不是找到一种增量方法来确保一个字符始终位于该缓冲区中。
我已在部署的应用中使用（类似）代码，欢迎您进行测试：
https://play.google.com/store/apps/details?id=com.goalstate.WordGames.FullBoard.trialsuite]
<强>引言
下面介绍的解决方法适用于所有版本的Google键盘，包括过去和将来，就这两个错误而言。此解决方法确实不要求应用程序仍然停留在针对API级别15或更低级别的应用程序，某些应用程序已限制使用这些应用程序，以便利用绕过问题42904的兼容性代码。
对于已实现onCreateInputConnection（）的覆盖的视图，这些问题仅作为作为错误出现，并且将TYPE_NULL返回到调用IME（在传递给它的EditorInfo参数的inputType成员中） IME的方法）。只有通过这样做，视图才能合理地期望将从软键盘返回键事件（包括KEYCODE_DEL）。因此，此处提供的解决方法需要TYPE_NULL InputType。
对于不使用TYPE_NULL的应用程序，由onCreateInputConnection（）覆盖的视图返回的BaseInputConnection派生对象中有各种覆盖，当用户执行编辑时，IME会调用这些覆盖，而不是 IME生成关键事件。这种（非TYPE_NULL）方法通常是优越的，因为软键盘的功能现在远远超出了单纯的键，如语音输入，完成等等。关键事件是一种较旧的方法，而那些实现LatinIME的方法谷歌曾表示，他们希望看到TYPE_NULL（和关键事件）的使用消失。
如果停止使用TYPE_NULL是一个选项，那么我建议你继续使用InputConnection覆盖方法而不是键事件的推荐方法（或者更简单地说，使用从EditText派生的类，对你而言）。
尽管如此，TYPE_NULL行为尚未正式停止，因此LatinIME在某些情况下无法生成KEYCODE_DEL事件确实是一个错误。我提供以下解决方法来解决此问题。
<强>概览
应用从LatinIME接收KEYCODE_DEL时遇到的问题是由于已知的两个错误，报告此处：
https://code.google.com/p/android/issues/detail?id=42904 （列为WorkingAsIntended，但问题是，我维护一个错误，因为它导致无法支持针对API级别16及以上的应用程序的KEYCODE_DEL事件生成，这些应用程序专门列出了TYPE_NULL的InputType。问题在最新修复LatinIME的发布版本，但过去发布的版本仍然存在此错误，因此使用TYPE_NULL且定位API级别16或更高级别的应用仍然需要可以在应用内执行的变通方法。
，此处：
http://code.google.com/p/android/issues/detail?id=62306 （目前列为固定但尚未发布 - FutureRelease - 但即使一旦发布，我们仍然需要一个可以在应用程序内执行的解决方法来处理过去的版本，这些版本将持续存在＆＃34;在野外＃ 34。）
与本论文一致（KEYCODE_DEL事件遇到的问题是由于LatinIME中的错误），我发现当使用外部硬件键盘时，以及使用第三方SwiftKey软键盘时，这些问题都不会发生，而他们做是针对特定版本的LatinIME发生的。
某些LatinIME版本中存在这些问题中的一个或另一个（但不是同时发生）。因此，开发人员在测试期间很难知道他们是否解决了所有KEYCODE_DEL问题，有时在执行Android（或Google键盘）更新时，问题将无法在测试中重现。尽管如此，导致该问题的LatinIME版本将出现在使用中的许多设备上。这迫使我深入研究AOSP LatinIME git repo，以确定两个问题中每个问题的确切范围（即特定的LatinIME和Android版本，这两个问题可能存在于每个问题中）。以下解决方法代码仅限于这些特定版本。
下面介绍的解决方法代码包含广泛的注释，可以帮助您了解它尝试完成的任务。在介绍代码之后，我将提供一些额外的讨论，其中将包括特定的Android开源项目（AOSP）提交，其中两个错误中的每一个都被引入，并且它已经消失，以及可能的Android版本包括受影响的Google键盘版本。
我会警告任何想使用这种方法执行自己的测试以验证它适用于他们的特定应用程序的人。我认为它将在一般情况下工作，并在许多设备和LatinIME版本上进行了测试，但推理很复杂，所以请谨慎行事。如果您发现任何问题，请在下面发表评论。
<强> CODE ：
然后，这是我对这两个问题的解决方法，并在代码注释中包含解释：
首先，在您自己的源文件InputConnectionAccomodatingLatinIMETypeNullIssues.java中包含以下类（编辑以品味）：
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.BaseInputConnection;
/**
*
* @author Carl Gunther
* There are bugs with the LatinIME keyboard's generation of KEYCODE_DEL events
* that this class addresses in various ways. These bugs appear when the app
* specifies TYPE_NULL, which is the only circumstance under which the app
* can reasonably expect to receive key events for KEYCODE_DEL.
*
* This class is intended for use by a view that overrides
* onCreateInputConnection() and specifies to the invoking IME that it wishes
* to use the TYPE_NULL InputType. This should cause key events to be returned
* to the view.
*
*/
public class InputConnectionAccomodatingLatinIMETypeNullIssues extends BaseInputConnection {
//This holds the Editable text buffer that the LatinIME mistakenly *thinks*
// that it is editing, even though the views that employ this class are
// completely driven by key events.
Editable myEditable = null;
//Basic constructor
public InputConnectionAccomodatingLatinIMETypeNullIssues(View targetView, boolean fullEditor) {
super(targetView, fullEditor);
}
//This method is called by the IME whenever the view that returned an
// instance of this class to the IME from its onCreateInputConnection()
// gains focus.
@Override
public Editable getEditable() {
//Some versions of the Google Keyboard (LatinIME) were delivered with a
// bug that causes KEYCODE_DEL to no longer be generated once the number
// of KEYCODE_DEL taps equals the number of other characters that have
// been typed. This bug was reported here as issue 62306.
//
// As of this writing (1/7/2014), it is fixed in the AOSP code, but that
// fix has not yet been released. Even when it is released, there will
// be many devices having versions of the Google Keyboard that include the bug
// in the wild for the indefinite future. Therefore, a workaround is required.
//
//This is a workaround for that bug which just jams a single garbage character
// into the internal buffer that the keyboard THINKS it is editing even
// though we have specified TYPE_NULL which *should* cause LatinIME to
// generate key events regardless of what is in that buffer. We have other
// code that attempts to ensure as the user edites that there is always
// one character remaining.
//
// The problem arises because when this unseen buffer becomes empty, the IME
// thinks that there is nothing left to delete, and therefore stops
// generating KEYCODE_DEL events, even though the app may still be very
// interested in receiving them.
//
//So, for example, if the user taps in ABCDE and then positions the
// (app-based) cursor to the left of A and taps the backspace key three
// times without any evident effect on the letters (because the app's own
// UI code knows that there are no letters to the left of the
// app-implemented cursor), and then moves the cursor to the right of the
// E and hits backspace five times, then, after E and D have been deleted,
// no more KEYCODE_DEL events will be generated by the IME because the
// unseen buffer will have become empty from five letter key taps followed
// by five backspace key taps (as the IME is unaware of the app-based cursor
// movements performed by the user).
//
// In other words, if your app is processing KEYDOWN events itself, and
// maintaining its own cursor and so on, and not telling the IME anything
// about the user's cursor position, this buggy processing of the hidden
// buffer will stop KEYCODE_DEL events when your app actually needs them -
// in whatever Android releases incorporate this LatinIME bug.
//
// By creating this garbage characters in the Editable that is initially
// returned to the IME here, we make the IME think that it still has
// something to delete, which causes it to keep generating KEYCODE_DEL
// events in response to backspace key presses.
//
// A specific keyboard version that I tested this on which HAS this
// problem but does NOT have the "KEYCODE_DEL completely gone" (issue 42904)
// problem that is addressed by the deleteSurroundingText() override below
// (the two problems are not both present in a single version) is
// 2.0.19123.914326a, tested running on a Nexus7 2012 tablet.
// There may be other versions that have issue 62306.
//
// A specific keyboard version that I tested this on which does NOT have
// this problem but DOES have the "KEYCODE_DEL completely gone" (issue
// 42904) problem that is addressed by the deleteSurroundingText()
// override below is 1.0.1800.776638, tested running on the Nexus10
// tablet. There may be other versions that also have issue 42904.
//
// The bug that this addresses was first introduced as of AOSP commit tag
// 4.4_r0.9, and the next RELEASED Android version after that was
// android-4.4_r1, which is the first release of Android 4.4. So, 4.4 will
// be the first Android version that would have included, in the original
// RELEASED version, a Google Keyboard for which this bug was present.
//
// Note that this bug was introduced exactly at the point that the OTHER bug
// (the one that is addressed in deleteSurroundingText(), below) was first
// FIXED.
//
// Despite the fact that the above are the RELEASES associated with the bug,
// the fact is that any 4.x Android release could have been upgraded by the
// user to a later version of Google Keyboard than was present when the
// release was originally installed to the device. I have checked the
// www.archive.org snapshots of the Google Keyboard listing page on the Google
// Play store, and all released updates listed there (which go back to early
// June of 2013) required Android 4.0 and up, so we can be pretty sure that
// this bug is not present in any version earlier than 4.0 (ICS), which means
// that we can limit this fix to API level 14 and up. And once the LatinIME
// problem is fixed, we can limit the scope of this workaround to end as of
// the last release that included the problem, since we can assume that
// users will not upgrade Google Keyboard to an EARLIER version than was
// originally included in their Android release.
//
// The bug that this addresses was FIXED but NOT RELEASED as of this AOSP
// commit:
//https://android.googlesource.com/platform/packages/inputmethods/LatinIME/+
// /b41bea65502ce7339665859d3c2c81b4a29194e4/java/src/com/android
// /inputmethod/latin/LatinIME.java
// so it can be assumed to affect all of KitKat released thus far
// (up to 4.4.2), and could even affect beyond KitKat, although I fully
// expect it to be incorporated into the next release *after* API level 19.
//
// When it IS released, this method should be changed to limit it to no
// higher than API level 19 (assuming that the fix is released before API
// level 20), just in order to limit the scope of this fix, since poking
// 1024 characters into the Editable object returned here is of course a
// kluge. But right now the safest thing is just to not have an upper limit
// on the application of this kluge, since the fix for the problem it
// addresses has not yet been released (as of 1/7/2014).
if(Build.VERSION.SDK_INT >= 14) {
if(myEditable == null) {
myEditable = new EditableAccomodatingLatinIMETypeNullIssues(
EditableAccomodatingLatinIMETypeNullIssues.ONE_UNPROCESSED_CHARACTER);
Selection.setSelection(myEditable, 1);
}
else {
int myEditableLength = myEditable.length();
if(myEditableLength == 0) {
//I actually HAVE seen this be zero on the Nexus 10 with the keyboard
// that came with Android 4.4.2
// On the Nexus 10 4.4.2 if I tapped away from the view and then back to it, the
// myEditable would come back as null and I would create a new one. This is also
// what happens on other devices (e.g., the Nexus 6 with 4.4.2,
// which has a slightly later version of the Google Keyboard). But for the
// Nexus 10 4.4.2, the keyboard had a strange behavior
// when I tapped on the rack, and then tapped Done on the keyboard to close it,
// and then tapped on the rack AGAIN. In THAT situation,
// the myEditable would NOT be set to NULL but its LENGTH would be ZERO. So, I
// just append to it in that situation.
myEditable.append(
EditableAccomodatingLatinIMETypeNullIssues.ONE_UNPROCESSED_CHARACTER);
Selection.setSelection(myEditable, 1);
}
}
return myEditable;
}
else {
//Default behavior for keyboards that do not require any fix
return super.getEditable();
}
}
//This method is called INSTEAD of generating a KEYCODE_DEL event, by
// versions of Latin IME that have the bug described in Issue 42904.
@Override
public boolean deleteSurroundingText(int beforeLength, int afterLength) {
//If targetSdkVersion is set to anything AT or ABOVE API level 16
// then for the GOOGLE KEYBOARD versions DELIVERED
// with Android 4.1.x, 4.2.x or 4.3.x, NO KEYCODE_DEL EVENTS WILL BE
// GENERATED BY THE GOOGLE KEYBOARD (LatinIME) EVEN when TYPE_NULL
// is being returned as the InputType by your view from its
// onCreateInputMethod() override, due to a BUG in THOSE VERSIONS.
//
// When TYPE_NULL is specified (as this entire class assumes is being done
// by the views that use it, what WILL be generated INSTEAD of a KEYCODE_DEL
// is a deleteSurroundingText(1,0) call. So, by overriding this
// deleteSurroundingText() method, we can fire the KEYDOWN/KEYUP events
// ourselves for KEYCODE_DEL. This provides a workaround for the bug.
//
// The specific AOSP RELEASES involved are 4.1.1_r1 (the very first 4.1
// release) through 4.4_r0.8 (the release just prior to Android 4.4).
// This means that all of KitKat should not have the bug and will not
// need this workaround.
//
// Although 4.0.x (ICS) did not have this bug, it was possible to install
// later versions of the keyboard as an app on anything running 4.0 and up,
// so those versions are also potentially affected.
//
// The first version of separately-installable Google Keyboard shown on the
// Google Play store site by www.archive.org is Version 1.0.1869.683049,
// on June 6, 2013, and that version (and probably other, later ones)
// already had this bug.
//
//Since this required at least 4.0 to install, I believe that the bug will
// not be present on devices running versions of Android earlier than 4.0.
//
//AND, it should not be present on versions of Android at 4.4 and higher,
// since users will not "upgrade" to a version of Google Keyboard that
// is LOWER than the one they got installed with their version of Android
// in the first place, and the bug will have been fixed as of the 4.4 release.
//
// The above scope of the bug is reflected in the test below, which limits
// the application of the workaround to Android versions between 4.0.x and 4.3.x.
//
//UPDATE: A popular third party keyboard was found that exhibits this same issue. It
// was not fixed at the same time as the Google Play keyboard, and so the bug in that case
// is still in place beyond API LEVEL 19. So, even though the Google Keyboard fixed this
// as of level 19, we cannot take out the fix based on that version number. And so I've
// removed the test for an upper limit on the version; the fix will remain in place ad
// infinitum - but only when TYPE_NULL is used, so it *should* be harmless even when
// the keyboard does not have the problem...
if((Build.VERSION.SDK_INT >= 14) // && (Build.VERSION.SDK_INT < 19)
&& (beforeLength == 1 && afterLength == 0)) {
//Send Backspace key down and up events to replace the ones omitted
// by the LatinIME keyboard.
return super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL))
&& super.sendKeyEvent(new KeyEvent(KeyEvent.ACTION_UP, KeyEvent.KEYCODE_DEL));
}
else {
//Really, I can't see how this would be invoked, given that we're using
// TYPE_NULL, for non-buggy versions, but in order to limit the impact
// of this change as much as possible (i.e., to versions at and above 4.0)
// I am using the original behavior here for non-affected versions.
return super.deleteSurroundingText(beforeLength, afterLength);
}
}
}
接下来，从每个View派生类中获取需要从LatinIME软键盘接收键事件的类，并按如下方式对其进行编辑：
首先，在要接收的视图中创建对onCreateInputConnection（）的覆盖 关键事件如下：
@Override
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
//Passing FALSE as the SECOND ARGUMENT (fullEditor) to the constructor
// will result in the key events continuing to be passed in to this
// view. Use our special BaseInputConnection-derived view
InputConnectionAccomodatingLatinIMETypeNullIssues baseInputConnection =
new InputConnectionAccomodatingLatinIMETypeNullIssues(this, false);
//In some cases an IME may be able to display an arbitrary label for a
// command the user can perform, which you can specify here. A null value
// here asks for the default for this key, which is usually something
// like Done.
outAttrs.actionLabel = null;
//Special content type for when no explicit type has been specified.
// This should be interpreted (by the IME that invoked
// onCreateInputConnection())to mean that the target InputConnection
// is not rich, it can not process and show things like candidate text
// nor retrieve the current text, so the input method will need to run
// in a limited "generate key events" mode. This disables the more
// sophisticated kinds of editing that use a text buffer.
outAttrs.inputType = InputType.TYPE_NULL;
//This creates a Done key on the IME keyboard if you need one
outAttrs.imeOptions = EditorInfo.IME_ACTION_DONE;
return baseInputConnection;
}
其次，对视图的onKey（）处理程序进行以下更改：
this.setOnKeyListener(new OnKeyListener() {
@Override public
boolean onKey(View v, int keyCode, KeyEvent event) {
if(event.getAction() != KeyEvent.ACTION_DOWN) {
//We only look at ACTION_DOWN in this code, assuming that ACTION_UP is redundant.
// If not, adjust accordingly.
return false;
}
else if(event.getUnicodeChar() ==
(int)EditableAccomodatingLatinIMETypeNullIssues.ONE_UNPROCESSED_CHARACTER.charAt(0))
{
//We are ignoring this character, and we want everyone else to ignore it, too, so
// we return true indicating that we have handled it (by ignoring it).
return true;
}
//Now, just do your event handling as usual...
if(keyCode == KeyEvent.KEYCODE_ENTER) {
//Trap the Done key and close the keyboard if it is pressed (if that's what you want to do)
InputMethodManager imm = (InputMethodManager)
mainActivity.getSystemService(Context.INPUT_METHOD_SERVICE));
imm.hideSoftInputFromWindow(LetterRack.this.getWindowToken(), 0);
return true;
}
else if(keyCode == KeyEvent.KEYCODE_DEL) {
//Backspace key processing goes here...
return true;
}
else if((keyCode >= KeyEvent.KEYCODE_A) && (keyCode <= KeyEvent.KEYCODE_Z)) {
//(Or, use event.getUnicodeChar() if preferable to key codes).
//Letter processing goes here...
return true;
}
//Etc. } };
最后，我们需要为可编辑定义一个类，以确保始终至少有一个 我们的可编辑缓冲区中的字符：
import android.text.SpannableStringBuilder;
public class EditableAccomodatingLatinIMETypeNullIssues extends SpannableStringBuilder {
EditableAccomodatingLatinIMETypeNullIssues(CharSequence source) {
super(source);
}
//This character must be ignored by your onKey() code.
public static CharSequence ONE_UNPROCESSED_CHARACTER = "/";
@Override
public SpannableStringBuilder replace(final int
spannableStringStart, final int spannableStringEnd, CharSequence replacementSequence,
int replacementStart, int replacementEnd) {
if (replacementEnd > replacementStart) {
//In this case, there is something in the replacementSequence that the IME
// is attempting to replace part of the editable with.
//We don't really care about whatever might already be in the editable;
// we only care about making sure that SOMETHING ends up in it,
// so that the backspace key will continue to work.
// So, start by zeroing out whatever is there to begin with.
super.replace(0, length(), "", 0, 0);
//We DO care about preserving the new stuff that is replacing the stuff in the
// editable, because this stuff might be sent to us as a keydown event. So, we
// insert the new stuff (typically, a single character) into the now-empty editable,
// and return the result to the caller.
return super.replace(0, 0, replacementSequence, replacementStart, replacementEnd);
}
else if (spannableStringEnd > spannableStringStart) {
//In this case, there is NOTHING in the replacementSequence, and something is
// being replaced in the editable.
// This is characteristic of a DELETION.
// So, start by zeroing out whatever is being replaced in the editable.
super.replace(0, length(), "", 0, 0);
//And now, we will place our ONE_UNPROCESSED_CHARACTER into the editable buffer, and return it.
return super.replace(0, 0, ONE_UNPROCESSED_CHARACTER, 0, 1);
}
// In this case, NOTHING is being replaced in the editable. This code assumes that there
// is already something there. This assumption is probably OK because in our
// InputConnectionAccomodatingLatinIMETypeNullIssues.getEditable() method
// we PLACE a ONE_UNPROCESSED_CHARACTER into the newly-created buffer. So if there
// is nothing replacing the identified part
// of the editable, and no part of the editable that is being replaced, then we just
// leave whatever is in the editable ALONE,
// and we can be confident that there will be SOMETHING there. This call to super.replace()
// in that case will be a no-op, except
// for the value it returns.
return super.replace(spannableStringStart, spannableStringEnd,
replacementSequence, replacementStart, replacementEnd);
}
}
这样就完成了我发现的源代码更改似乎可以解决这两个问题。
其他说明：
问题42904描述的问题是在API级别16提供的LatinIME版本中引入的。在此之前，无论是否使用TYPE_NULL，都会生成KEYCODE_DEL事件。在使用Jelly Bean发布的LatinIME中，这一代已停止使用，但TYPE_NULL没有例外，因此针对API级别16以上的应用程序有效禁用了TYPE_NULL行为。但是，添加了兼容性代码，允许具有targetSdkVersion＆lt; 16继续接收KEYCODE_DEL事件，即使没有TYPE_NULL。请参阅第1493行的AOSP提交：
因此，您可以通过将应用中的targetSdkVersion设置为15或更低来解决此问题。
从提交4.4_r0.9开始（刚好在4.4版本之前），通过在保护KEYCODE_DEL生成的条件中添加isTypeNull（）测试来解决此问题。不幸的是，在这一点上引入了一个新的错误（62306），如果用户键入退格键的次数与输入其他字符的次数相同，则导致整个子句包装KEYCODE_DEL生成被跳过。这导致在这些情况下无法生成KEYCODE_DEL，即使使用TYPE_NULL，甚至使用targetSdkVersion＆lt; = 15。这导致以前能够通过兼容性代码（targetSdkVersion＆lt; = 15）突然获得正确的KEYCODE_DEL行为的应用程序突然当用户升级其Google键盘副本（或执行包含新版Google键盘的OTA）时，会遇到此问题。请参阅第2146行的AOSP git文件（该条款包括＆＃34; NOT_A_CODE＆＃34;）：
此问题在发布的Google键盘版本中一直持续到现在（2014年1月7日）。它已在回购中修复，但截至本文撰写时尚未发布。
可以在这里找到未发布的提交（包含它的git提交合并了一个标题为＃34的提交;在TYPE_NULL＆＃34时发送退格作为事件），在第2110行（你可以看到＆＃34; NOT_A_CODE＆用于阻止我们到达生成KEYCODE_DEL的子句的＃34;子句已被删除）：
发布此修补程序后，该版本的Google键盘将不再具有影响TYPE_NULL的这两个问题。 然而，对于无限期的未来，仍会在特定设备上安装旧版本。因此，问题仍然需要解决方法。最终，随着越来越多的人升级到不包括修复程序的最后一个级别，这种解决方法将越来越少。但它已经确定了自己的阶段（一旦你做出指示的更改以对范围进行最终限制，最后修复实际上已经发布，以便你知道它实际上是什么）。
答案 1 :(得分：20)
答案 2 :(得分：5)
<强>引言
在测试了@ Carl和@Turix的解决方案之后，我注意到了：
Carl的解决方案不适用于unicode字符或字符序列，因为这些似乎与ACTION_MULTIPLE事件一起提供，这使得难以区分“虚拟”字符和实际字符。
我无法在我的Nexus 5（4.4.2）上使用最新版本的Android deleteSurroundingText。我测试了几个不同的sdk版本，但没有一个工作。也许Google决定再次改变DEL键背后的逻辑......
因此，我使用Carl和Turix的答案提出了以下组合解决方案。我的解决方案通过结合Carl的长假字符前缀的想法来使DEL工作，但使用Turix的解决方案来自定义Editable来生成正确的键事件。
<强>结果：
我已经在不同版本的Android和不同键盘的多个设备上测试了此解决方案。以下所有测试用例都适用于我。我没有找到这种解决方案不起作用的情况。
我还测试了不同的sdk版本：
如果此解决方案也适合您，那么请
观点：
public class MyInputView extends EditText implements View.OnKeyListener {
private String DUMMY;
...
public MyInputView(Context context) {
super(context);
init(context);
}
private void init(Context context) {
this.context = context;
this.setOnKeyListener(this);
// Generate a dummy buffer string
// Make longer or shorter as desired.
DUMMY = "";
for (int i = 0; i < 1000; i++)
DUMMY += "\0";
}
@Override
public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
MyInputConnection ic = new MyInputConnection(this, false);
outAttrs.inputType = InputType.TYPE_NULL;
return ic;
}
@Override
public boolean onKey(View view, int keyCode, KeyEvent keyEvent) {
int action = keyEvent.getAction();
// Catch unicode characters (even character sequeneces)
// But make sure we aren't catching the dummy buffer.
if (action == KeyEvent.ACTION_MULTIPLE) {
String s = keyEvent.getCharacters();
if (!s.equals(DUMMY)) {
listener.onSend(s);
}
}
// Catch key presses...
if (action == KeyEvent.ACTION_DOWN) {
switch (keyCode) {
case KeyEvent.KEYCODE_DEL:
...
break;
case KeyEvent.KEYCODE_ENTER:
...
break;
case KeyEvent.KEYCODE_TAB:
...
break;
default:
char ch = (char)keyEvent.getUnicodeChar();
if (ch != '\0') {
...
}
break;
}
}
return false;
}
}
输入连接：
public class MyInputConnection extends BaseInputConnection {
private MyEditable mEditable;
public MyInputConnection(View targetView, boolean fullEditor) {
super(targetView, fullEditor);
}
private class MyEditable extends SpannableStringBuilder {
MyEditable(CharSequence source) {
super(source);
}
@Override
public SpannableStringBuilder replace(final int start, final int end, CharSequence tb, int tbstart, int tbend) {
if (tbend > tbstart) {
super.replace(0, length(), "", 0, 0);
return super.replace(0, 0, tb, tbstart, tbend);
}
else if (end > start) {
super.replace(0, length(), "", 0, 0);
return super.replace(0, 0, DUMMY, 0, DUMMY.length());
}
return super.replace(start, end, tb, tbstart, tbend);
}
}
@Override
public Editable getEditable() {
if (Build.VERSION.SDK_INT < 14)
return super.getEditable();
if (mEditable == null) {
mEditable = this.new MyEditable(DUMMY);
Selection.setSelection(mEditable, DUMMY.length());
}
else if (mEditable.length() == 0) {
mEditable.append(DUMMY);
Selection.setSelection(mEditable, DUMMY.length());
}
return mEditable;
}
@Override
public boolean deleteSurroundingText(int beforeLength, int afterLength) {
// Not called in latest Android version...
return super.deleteSurroundingText(beforeLength, afterLength);
}
}
答案 3 :(得分：3)
我遇到过类似的问题，其中没有通过退格键接收KEYCODE_DEL。这取决于我认为的软输入键盘，因为我的问题只发生在一些第三方键盘（我认为是swype）而不是默认谷歌键盘的情况下。
答案 4 :(得分：3)
（这个答案是作为Carl公布的答案的补遗。）
虽然非常感谢对这两个错误的研究和理解，但我在卡尔发布的解决方法上遇到了一些麻烦。我遇到的主要问题是，虽然卡尔的评论栏表示KeyEvent.ACTION_MULTIPLE中的onKey()路径只会被视为“选择信箱后收到的第一个事件”，对我而言，每一个键事件采取了这条道路。 （我通过查看API级别18的BaseInputConnection.java代码发现这是因为每次Editable都使用了整个sendCurrentText()文本。我不确定它为什么会起作用对于卡尔而不是我。）
因此，在Carl的解决方案的启发下，我将其改编为没有这个问题。我对62306问题的解决方案（与Carl的回答相关）试图达到“欺骗”IME的相同基本效果，认为总有更多的文本可以退格。但是，它通过确保Editable中的完全一个字符来实现此目的。为此，您需要以类似于以下的方式扩展实现Editable接口SpannedStringBuilder的基础类：
private class MyEditable extends SpannableStringBuilder
{
MyEditable(CharSequence source) {
super(source);
}
@Override
public SpannableStringBuilder replace(final int start, final int end, CharSequence tb, int tbstart, int tbend) {
if (tbend > tbstart) {
super.replace(0, length(), "", 0, 0);
return super.replace(0, 0, tb, tbstart, tbend);
}
else if (end > start) {
super.replace(0, length(), "", 0, 0);
return super.replace(0, 0, DUMMY_CHAR, 0, 1);
}
return super.replace(start, end, tb, tbstart, tbend);
}
}
基本上，只要IME尝试将字符添加到Editable（通过调用replace()），该字符就会替换那里的任何单个字符。同时，如果IME试图删除那里的内容，replace()覆盖替换那里的单个“虚拟”字符（应该是你的应用程序将忽略的东西）以保持长度为1。
这意味着getEditable()和onKey()的实现可能比Carl上面发布的更简单。例如，假设上面的MyEditable类是作为内部类实现的，getEditable()就变成了：
@Override
public Editable getEditable() {
if (Build.VERSION.SDK_INT < 14)
return super.getEditable();
if (mEditable == null) {
mEditable = this.new MyEditable(DUMMY_CHAR);
Selection.setSelection(mEditable, 1);
}
else if (m_editable.length() == 0) {
mEditable.append(DUMMY_CHAR);
Selection.setSelection(mEditable, 1);
}
return mEditable;
}
请注意，使用此解决方案，无需维护1024个字符的长字符串。也不存在“退缩太多”的危险（正如卡尔关于按住退格键的评论中所讨论的那样）。
为了完整性，onKey()变为类似：
@Override
public boolean onKey(View v, int keyCode, KeyEvent event)
{
if (event.getAction() != KeyEvent.ACTION_DOWN)
return false;
if ((int)DUMMY_CHAR.charAt(0) == event.getUnicodeChar())
return true;
// Handle event/keyCode here as normal...
}
最后，我应该注意，以上所有内容都是作为解决方法来发布62306 。我对其他问题42904的解决方案没有任何问题，由Carl发布（覆盖deleteSurroundingText()）并建议在发布时使用它。
答案 5 :(得分：3)
由于@ Carl的想法，我找到了一个适用于任何输入类型的解决方案。下面我提供一个完整的工作示例应用程序，包含2个类：MainActivity和CustomEditText：
package com.example.edittextbackspace;
import android.app.Activity;
import android.os.Bundle;
import android.text.InputType;
import android.view.ViewGroup.LayoutParams;
public class MainActivity extends Activity
{
@Override
protected void onCreate(Bundle savedInstanceState)
{
super.onCreate(savedInstanceState);
CustomEditText edittext = initEditText();
setContentView(edittext);
}
private CustomEditText initEditText()
{
CustomEditText editText = new CustomEditText(this)
{
@Override
public void backSpaceProcessed()
{
super.backSpaceProcessed();
editTextBackSpaceProcessed(this);
}
};
editText.setInputType(InputType.TYPE_CLASS_NUMBER);
editText.setLayoutParams(new LayoutParams(LayoutParams.WRAP_CONTENT, LayoutParams.WRAP_CONTENT));
editText.setText("1212");
return editText;
}
private void editTextBackSpaceProcessed(CustomEditText customEditText)
{
// Backspace event is called and properly processed
}
}
package com.example.edittextbackspace;
import android.content.Context;
import android.text.Editable;
import android.text.Selection;
import android.text.TextWatcher;
import android.util.Log;
import android.view.KeyEvent;
import android.view.View;
import android.view.inputmethod.BaseInputConnection;
import android.view.inputmethod.CorrectionInfo;
import android.view.inputmethod.EditorInfo;
import android.view.inputmethod.InputConnection;
import android.widget.EditText;
import java.util.ArrayList;
import java.util.List;
public class CustomEditText extends EditText implements View.OnFocusChangeListener, TextWatcher
{
private String LOG = this.getClass().getName();
private int _inputType = 0;
private int _imeOptions = 5 | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
private List<String> _lastComposingTextsList = new ArrayList<String>();
private BaseInputConnection _inputConnection = null;
private String _lastComposingText = "";
private boolean _commitText = true;
private int _lastCursorPosition = 0;
private boolean _isComposing = false;
private boolean _characterRemoved = false;
private boolean _isTextComposable = false;
public CustomEditText(Context context)
{
super(context);
setOnFocusChangeListener(this);
addTextChangedListener(this);
}
@Override
public InputConnection onCreateInputConnection(final EditorInfo outAttrs)
{
CustomEditText.this._inputConnection = new BaseInputConnection(this, false)
{
@Override
public boolean deleteSurroundingText(int beforeLength, int afterLength)
{
handleEditTextDeleteEvent();
return super.deleteSurroundingText(beforeLength, afterLength);
}
@Override
public boolean setComposingText(CharSequence text, int newCursorPosition)
{
CustomEditText.this._isTextComposable = true;
CustomEditText.this._lastCursorPosition = getSelectionEnd();
CustomEditText.this._isComposing = true;
if (text.toString().equals(CustomEditText.this._lastComposingText))
return true;
else
CustomEditText.this._commitText = true;
if (text.length() < CustomEditText.this._lastComposingText.length())
{
CustomEditText.this._lastComposingText = text.toString();
try
{
if (text.length() > 0)
{
if (CustomEditText.this._lastComposingTextsList.size() > 0)
{
if (CustomEditText.this._lastComposingTextsList.size() > 0)
{
CustomEditText.this._lastComposingTextsList.remove(CustomEditText.this._lastComposingTextsList.size() - 1);
}
}
else
{
CustomEditText.this._lastComposingTextsList.add(text.toString().substring(0, text.length() - 1));
}
}
int start = Math.max(getSelectionStart(), 0) - 1;
int end = Math.max(getSelectionEnd(), 0);
CustomEditText.this._characterRemoved = true;
getText().replace(Math.min(start, end), Math.max(start, end), "");
}
catch (Exception e)
{
Log.e(LOG, "Exception in setComposingText: " + e.toString());
}
return true;
}
else
{
CustomEditText.this._characterRemoved = false;
}
if (text.length() > 0)
{
CustomEditText.this._lastComposingText = text.toString();
String textToInsert = Character.toString(text.charAt(text.length() - 1));
int start = Math.max(getSelectionStart(), 0);
int end = Math.max(getSelectionEnd(), 0);
CustomEditText.this._lastCursorPosition++;
getText().replace(Math.min(start, end), Math.max(start, end), textToInsert);
CustomEditText.this._lastComposingTextsList.add(text.toString());
}
return super.setComposingText("", newCursorPosition);
}
@Override
public boolean commitText(CharSequence text, int newCursorPosition)
{
CustomEditText.this._isComposing = false;
CustomEditText.this._lastComposingText = "";
if (!CustomEditText.this._commitText)
{
CustomEditText.this._lastComposingTextsList.clear();
return true;
}
if (text.toString().length() > 0)
{
try
{
String stringToReplace = "";
int cursorPosition = Math.max(getSelectionStart(), 0);
if (CustomEditText.this._lastComposingTextsList.size() > 1)
{
if (text.toString().trim().isEmpty())
{
getText().replace(cursorPosition, cursorPosition, " ");
}
else
{
stringToReplace = CustomEditText.this._lastComposingTextsList.get(CustomEditText.this._lastComposingTextsList.size() - 2) + text.charAt(text.length() - 1);
getText().replace(cursorPosition - stringToReplace.length(), cursorPosition, text);
}
CustomEditText.this._lastComposingTextsList.clear();
return true;
}
else if (CustomEditText.this._lastComposingTextsList.size() == 1)
{
getText().replace(cursorPosition - 1, cursorPosition, text);
CustomEditText.this._lastComposingTextsList.clear();
return true;
}
}
catch (Exception e)
{
Log.e(LOG, "Exception in commitText: " + e.toString());
}
}
else
{
if (!getText().toString().isEmpty())
{
int cursorPosition = Math.max(getSelectionStart(), 0);
CustomEditText.this._lastCursorPosition = cursorPosition - 1;
getText().replace(cursorPosition - 1, cursorPosition, text);
if (CustomEditText.this._lastComposingTextsList.size() > 0)
{
CustomEditText.this._lastComposingTextsList.remove(CustomEditText.this._lastComposingTextsList.size() - 1);
}
return true;
}
}
return super.commitText(text, newCursorPosition);
}
@Override
public boolean sendKeyEvent(KeyEvent event)
{
int keyCode = event.getKeyCode();
CustomEditText.this._lastComposingTextsList.clear();
if (keyCode > 60 && keyCode < 68 || !CustomEditText.this._isTextComposable || (CustomEditText.this._lastComposingTextsList != null && CustomEditText.this._lastComposingTextsList.size() == 0))
{
return super.sendKeyEvent(event);
}
else
return false;
}
@Override
public boolean finishComposingText()
{
if (CustomEditText.this._lastComposingTextsList != null && CustomEditText.this._lastComposingTextsList.size() > 0)
CustomEditText.this._lastComposingTextsList.clear();
CustomEditText.this._isComposing = true;
CustomEditText.this._commitText = true;
return super.finishComposingText();
}
@Override
public boolean commitCorrection(CorrectionInfo correctionInfo)
{
CustomEditText.this._commitText = false;
return super.commitCorrection(correctionInfo);
}
};
outAttrs.actionLabel = null;
outAttrs.inputType = this._inputType;
outAttrs.imeOptions = this._imeOptions;
return CustomEditText.this._inputConnection;
}
@Override
public boolean onKeyDown(int keyCode, KeyEvent keyEvent)
{
if (keyCode == KeyEvent.KEYCODE_DEL)
{
int cursorPosition = this.getSelectionEnd() - 1;
if (cursorPosition < 0)
{
removeAll();
}
}
return super.onKeyDown(keyCode, keyEvent);
}
@Override
public void setInputType(int type)
{
CustomEditText.this._isTextComposable = false;
this._inputType = type;
super.setInputType(type);
}
@Override
public void setImeOptions(int imeOptions)
{
this._imeOptions = imeOptions | EditorInfo.IME_FLAG_NO_EXTRACT_UI;
super.setImeOptions(this._imeOptions);
}
public void handleEditTextDeleteEvent()
{
int end = Math.max(getSelectionEnd(), 0);
if (end - 1 >= 0)
{
removeChar();
backSpaceProcessed();
}
else
{
removeAll();
}
}
private void removeAll()
{
int startSelection = this.getSelectionStart();
int endSelection = this.getSelectionEnd();
if (endSelection - startSelection > 0)
this.setText("");
else
nothingRemoved();
}
private void removeChar()
{
KeyEvent event = new KeyEvent(KeyEvent.ACTION_DOWN, KeyEvent.KEYCODE_DEL);
super.onKeyDown(event.getKeyCode(), event);
}
public void nothingRemoved()
{
// Backspace didn't remove anything. It means, a cursor of the editText was in the first position. We can use this method, for example, to switch focus to a previous view
}
public void backSpaceProcessed()
{
// Backspace is properly processed
}
@Override
protected void onSelectionChanged(int selStart, int selEnd)
{
if (CustomEditText.this._isComposing)
{
int startSelection = this.getSelectionStart();
int endSelection = this.getSelectionEnd();
if (((CustomEditText.this._lastCursorPosition != selEnd && !CustomEditText.this._characterRemoved) || (!CustomEditText.this._characterRemoved && CustomEditText.this._lastCursorPosition != selEnd)) || Math.abs(CustomEditText.this._lastCursorPosition - selEnd) > 1 || Math.abs(endSelection - startSelection) > 1)
{
// clean autoprediction words
CustomEditText.this._lastComposingText = "";
CustomEditText.this._lastComposingTextsList.clear();
CustomEditText.super.setInputType(CustomEditText.this._inputType);
}
}
}
@Override
public void onFocusChange(View v, boolean hasFocus)
{
if (!hasFocus) {
CustomEditText.this._lastComposingText = "";
CustomEditText.this._lastComposingTextsList.clear();
}
}
@Override
public void beforeTextChanged(CharSequence s, int start, int count, int after)
{
int startSelection = getSelectionStart();
int endSelection = getSelectionEnd();
if (Math.abs(endSelection - startSelection) > 0)
{
Selection.setSelection(getText(), endSelection);
}
}
@Override
public void afterTextChanged(Editable s)
{
}
@Override
public void onTextChanged(CharSequence s, int start, int before, int count)
{
super.onTextChanged(s, start, before, count);
}
}
<强>更新 我更新了代码，因为在三星Galaxy S6等某些设备上启用了文本预测时，它无法正常工作（感谢@Jonas，他在下面的评论中告知了这个问题）并使用了InputType.TYPE_TEXT_FLAG_NO_SUGGESTIONS在这种情况下无效。我在很多设备上测试了这个解决方案，但仍然不确定它是否适用于所有设备。如果EditText有任何不正确的行为，我希望我能收到一些评论。
答案 6 :(得分：2)
我认为如果您覆盖相应视图/活动的dispatchKeyEvent方法（在我的情况下，主要活动很好），您可能会发现可以拦截密钥。
例如，我正在为具有硬件滚动键的设备开发应用程序，我惊讶地发现永远不会为它们调用onKeyUp / onKeyDown方法。相反，默认情况下，按键会经过一堆dispatchKeyEvent s直到它在某处调用滚动方法（在我的情况下，奇怪的是，一键按下会在两个单独的可滚动视图中调用滚动方法 - 如何恼人的）。
答案 7 :(得分：0)
如果您检查了退格字符的十进制数，该怎么办？
我认为它类似于'/ r'（十进制数7）或其他东西，至少对于ASCII。
编辑： 我猜Android使用UTF-8，所以这个十进制数是8。 http://www.fileformat.info/info/unicode/char/0008/index.htm
答案 8 :(得分：-1)
鉴于Umair的回复，您可以考虑在此处应用解决方法：
捕捉触摸事件，表明它不是关键事件，并且在显示键盘时会在屏幕的右下方发生。
How to get the Touch position in android?
Is there a way to tell if the soft-keyboard is shown?
希望有所帮助
答案 9 :(得分：-1)
InputFilter调用退格键，如果edittext为空。
editText.setFilters(new InputFilter[]{new InputFilter() {
@Override
public CharSequence filter(CharSequence source, int start, int end, Spanned dest, int dstart, int dend) {
if(source.equals("")) {
//a backspace was entered
}
return source;
}
}});
答案 10 :(得分：-2)
这是老帖子，并提供我的建议以防有人需要超快速黑客/实施。
我提出的最简单的工作是在OnKeyListener上实现TextWatcher，在 onTextChanged 中与之前的现有字符串进行比较是否减少一个字符。
这样做的好处是它可以在任何类型的键盘上使用，而且不需要很长的编码过程。
例如我的editText只包含一个字符，所以我比较了 characterSequence ，如果它是空字符串，那么我们可以确认按下删除键。
以下是解释相同的代码：
@Override
public void onTextChanged(CharSequence charSequence, int i, int i2, int i3) {
if(charSequence.toString().equals("")) //Compare here for any change in existing string by single character with previous string
{
//Carry out your tasks here it comes in here when Delete Key is pressed.
}
}
注意：在这种情况下，我的edittext只包含单个字符，因此我将charSequesnce与空字符串进行比较（因为按下delete会使其为空），根据您的需要，您需要修改它和比较（如按下键子串后是原始字符串的一部分）它与现有字符串。希望它有所帮助。