Toleranz der Android Tastatur

[yolonaut]

Hallo,
ich habe es jetzt endlich geschafft mir die Android Tastatur nachzubauen. Die Tasten sind bei mir Buttons die ein Bild als background haben. Die Größenverhältnisse stimmen mit der originalen Tastatur überein.
Mir ist aufgefallen, dass es viel schwieriger ist auf meiner Tastatur zu tippen, als auf der originalen. Es scheint eine Art Toleranz zu geben:

Drückt man hier also ins "Leere" wird trotzdem eine Taste gedrückt. Drückt man auf den roten Punkt, wird trotzdem ein A geschrieben. Drück man an die Stelle des blauen Punktes bekommt man ein U oder ein J.
Ich habe es nicht geschafft einen Punkt zu treffen, bei dem nichts geschieht.
Diese Toleranz ist sehr hilfreich beim Tippen und ich möchte das auch auf meiner Tastatur, habe aber überhaupt keine Idee wie das umgesetzt wurde.
Habt ihr vielleicht Ideen oder genauere Informationen zu dieser Funktion ?

LG

 

[StefMa]

Mir fallen dazu spontan zwei sachen ein:

1. Du setzt hinter die Buttons jeweils ein unsichbares View, welches auch klickbar ist, und weißt entsprechend einen Buchstaben zu.

2. Dein Hintergrund ist generell Klickbar und du schreibst ein algorythmus und "berechnest dir" was er eventuell schreiben wollte und ersetzt den entsprechenden leeren buchstaben. Als hilfe kann man sich dann ja noch die position wiedergeben lassen. So zum beisiel beim Blauenpunkt "u/h/j/i"...

Gruß

€dit: Um 1 zu verdeutlichen siehe anhang

 

[Dee_]

Schau doch mal in den SDK Samples da gibt es auch ein Keyboard. Vllt gibts da den Code. Projekt heißt glaube ich SoftKeyboard

 

[kleinerkathe]

Ich weiß nicht was für Code genau unter den Samples drin ist, aber du kannst dir die Tastatur auch online auschecken:
https://android.googlesource.com/platform/packages/inputmethods/LatinIME/

Das ist die AOSP-Tastatur

 

[Dee_]

Jo, die geht natürlich auch. @yolonaut der Code müsste dir definitv helfen.

 

[yolonaut]

Im Code der AOSP-Tastatur wurde ich fündig. Im Sample SoftKeyboard fand ich zum Thema nichts.


In der Keyboard.java findet man das hier am Ende:

[LIST=1]
[*]  /**
[*]     * Returns the array of the keys that are closest to the given point.
[*]     * @param x the x-coordinate of the point
[*]     * @param y the y-coordinate of the point
[*]     * @return the array of the nearest keys to the given point. If the given
[*]     * point is out of range, then an array of size zero is returned.
[*]     */
[*]    public Key[] getNearestKeys(final int x, final int y) {
[*]        // Avoid dead pixels at edges of the keyboard
[*]        final int adjustedX = Math.max(0, Math.min(x, mOccupiedWidth - 1));
[*]        final int adjustedY = Math.max(0, Math.min(y, mOccupiedHeight - 1));
[*]        return mProximityInfo.getNearestKeys(adjustedX, adjustedY);
[*]    }
[/LIST]

In der KeyDetector.Java das hier:

[LIST=1]
[*]/**
[*]     * Detect the key whose hitbox the touch point is in.
[*]     *
[*]     * @param x The x-coordinate of a touch point
[*]     * @param y The y-coordinate of a touch point
[*]     * @return the key that the touch point hits.
[*]     */
[*]    public Key detectHitKey(int x, int y) {
[*]        final int touchX = getTouchX(x);
[*]        final int touchY = getTouchY(y);
[*]        int minDistance = Integer.MAX_VALUE;
[*]        Key primaryKey = null;
[*]        for (final Key key: mKeyboard.getNearestKeys(touchX, touchY)) {
[*]            // An edge key always has its enlarged hitbox to respond to an event that occurred in
[*]            // the empty area around the key. (@see Key#markAsLeftEdge(KeyboardParams)} etc.)
[*]            if (!key.isOnKey(touchX, touchY)) {
[*]                continue;
[*]            }
[*]            final int distance = key.squaredDistanceToEdge(touchX, touchY);
[*]            if (distance > minDistance) {
[*]                continue;
[*]            }
[*]            // To take care of hitbox overlaps, we compare key's code here too.
[*]            if (primaryKey == null || distance < minDistance
[*]                    || key.getCode() > primaryKey.getCode()) {
[*]                minDistance = distance;
[*]                primaryKey = key;
[*]            }
[*]        }
[*]        return primaryKey;
[*]    }
[/LIST]

In der ProximityInfo.Java gibt es noch diesen Teil:

2. public void fillArrayWithNearestKeyCodes(final int x, final int y, final int primaryKeyCode,
3. final int[] dest) {
4. final int destLength = dest.length;
5. if (destLength < 1) {
6. return;
7. }
8. int index = 0;
9. if (primaryKeyCode > Constants.CODE_SPACE) {
10. dest[index++] = primaryKeyCode;
11. }
12. final Key[] nearestKeys = getNearestKeys(x, y);
13. for (Key key : nearestKeys) {
14. if (index >= destLength) {
15. break;
16. }
17. final int code = key.getCode();
18. if (code <= Constants.CODE_SPACE) {
19. break;
20. }
21. dest[index++] = code;
22. }
23. if (index < destLength) {
24. dest[index] = Constants.NOT_A_CODE;
25. }
26. }
28. public Key[] getNearestKeys(final int x, final int y) {
29. if (mGridNeighbors == null) {
30. return EMPTY_KEY_ARRAY;
31. }
32. if (x >= 0 && x < mKeyboardMinWidth && y >= 0 && y < mKeyboardHeight) {
33. int index = (y / mCellHeight) * mGridWidth + (x / mCellWidth);
34. if (index < mGridSize) {
35. return mGridNeighbors[index];
36. }
37. }
38. return EMPTY_KEY_ARRAY;
39. }

Ich habe aufgrund der vielen verschiedenen Klassen Schwierigkeiten zu verstehen, wie das letzten Endes funktioniert und wie ich es auf meine Buttons (Tasten) übertragen kann.
Könnt ihr mir dabei helfen zu verstehen und den Code etwas zu entschlüsseln ?
Vielen Dank schonmal !

 

[Dee_]

Am besten du gehst das mal Schritt für Schritt durch. Debuggen hilft da meiner Meinung nach. Zumindest versuche ich anderen Code so zu verstehen. Ist ja verständlich das du nach ner Stunde den kompletten Code nicht verstehen kannst.
Gruß dee