Erstellen einer SoftKeyboard mit mehreren / alternativen Zeichen pro Taste

Habe ich folgte den Beispielen auf developer.android.com über Eingabemethoden und spielte mit den SoftKeyboard Beispielanwendung. Diese zusammen geben mehr als genug Informationen in Bezug auf die Schaffung von einfachen keyboard.

Was ich nicht sehen kann in der API ist die Möglichkeit zu schaffen, Alternative /mehrere Zeichen pro Taste auf der standard-Tastatur (LatinIME Tastatur).

Erstellen einer SoftKeyboard mit mehreren /alternativen Zeichen pro Taste

Bild oben ist das Ergebnis eines langen drücken auf die "a" - Taste. Wenn Sie lange drücken Sie eine Taste, es ist möglich, füllen Sie ein popup mit den alternativen Zeichen.

Erstellen einer SoftKeyboard mit mehreren /alternativen Zeichen pro Taste

Es ist auch möglich, ein Fenster mit einem Hinweis auf einige Tasten, die den Benutzer auffordern, drücken und halten Sie eine Taste, um das popup-Menü.

Bisher habe ich noch nicht gefunden, eine einzelne Quelle von Informationen darüber, wie dies erreicht wird, hoffentlich wird jemand in der Lage sein, um mir einen Vorsprung, bis dahin werde ich Folgen Sie den Quellcode der eingebauten Tastatur und sehen, ob ich kann reverse Engineering.

Edit: Würde helfen, wenn developer.android.com 's link, um die LatinIME Tastatur hat kein link zu einem Bild von einem Schafe 🙂 die Eigentliche source-code für LatinIME.java.

Edit 2: Mehr als Referenz als alles andere, das ist die Reihenfolge glaube ich eine übliche longPress Aktion durchläuft, um zu zeigen Sie die popup-Tastatur in KeyboardView.java:

onTouchEvent()
onModifiedTouchEvent()
mHandkler.handleMessage() with MSG_LONGPRESS
openPopupIfRequired() 
onLongPress()

Edit 3:

Habe ich noch nicht dachte, dieses heraus - Wie fügen Sie label-Vorschläge zu lösen? Eine Antwort es vermuten lässt, basiert nicht in der API und in der Tat, ich habe nicht einen gefunden, der codeto tun. Jedoch ist die Tastatur auf 2.3.4 (API 10) zeigt diese Funktionalität umgesetzt:

Erstellen einer SoftKeyboard mit mehreren /alternativen Zeichen pro Taste

Würde sehr gerne herausfinden, wie ES funktioniert, aber es ist nicht überall in der onDraw() Methode, die ich sehen kann - das lässt mich glauben, dass es geschrieben wird, die außerhalb des KeyboardView element. Ich kann Sie aber nicht finden layout - Datei verwendet, um die Anzeige der KeyboardView element auf der eingebauten Tastatur - Wenn jemand weiß, wo man diese vielleicht geben mir die Ahnung, die ich brauche.

Edit 4: Zog Taste Vorschau Frage hier, weil es etwas off-topic:

Wie sperrst du das SoftKeyboard-Taste, Vorschau-Fenster?

InformationsquelleAutor der Frage |

Umsetzung alternate key-popup:

Für jede Taste, die Sie möchten, um ein popup-Tastatur, Sie sollte definieren, popupCharacters und popupKeyboard:

/res/xml/[Keyboard].xml

<Key android:keyLabel="("
    android:popupKeyboard="@xml/keyboard_popup_template"
    android:popupCharacters="[{&lt;" />

Den popupKeyboard ist eine XML-Repräsentation der Tastatur verwendet, die in der popup mit den alternativen Tasten:

/res/xml/keyboard_popup_template.xml

<Keyboard xmlns:android="http://schemas.android.com/apk/res/android"
    android:keyWidth="10%p"
    android:horizontalGap="0px"
    android:verticalGap="0px"
    android:keyHeight="56dp">
</Keyboard>

Styling die alt-Taste popup:

Wenn Sie das layout ändern möchten/Stil des popup (standardmäßig @android:layout/keyboard_popup_keyboard.xml) können Sie eine android:popupLayout Attribut-Punkte, die zu einer layout-Datei:

<android.inputmethodservice.KeyboardView
    android:id="@+id/keyboard"
    android:layout_width="match_parent"
    android:layout_height="wrap_content"
    android:layout_alignParentBottom="true"
    android:background="#FF272727"
    android:popupLayout="@layout/keyboard_popup_keyboard" />

Umsetzung Wichtiger Vorschau-Overlay:

Die einzige Lösung, die ich habe in der Lage zu klopfen zusammen, um Karte-Taste "Vorschau" (Ohne vollständig umschreiben der KeyboardView Quellcode) ist unter:

Einwickeln der <KeyboardView> tag mit einem <FrameLayout> mit einer Höhe angegeben durch Multiplikation der keyHeight durch die Menge der Zeilen. Innerhalb dieses Tags habe ich einfach erstellt ein LinearLayout zu halten Zeilen, dann ein LinearLayout für jede Zeile eine TextView mit einem Gewicht gleich dem %p-Wert angegeben für jede <Key>:

<TextView android:text="!" style="@style/Custom.Widget.KeyboardKeyOverlay"  android:layout_width="0dp" android:layout_height="wrap_content" android:layout_weight="10"/>

Und Stil:

<style name="CustomTheme.Widget.KeyboardKeyOverlay">
    <item name="android:background">@android:color/transparent</item>
    <item name="android:textColor">#FFAAAAAA</item>
    <item name="android:paddingRight">6dp</item>
    <item name="android:paddingTop">4dp</item>
    <item name="android:textSize">10sp</item>
    <item name="android:gravity">right</item>
    <item name="android:textStyle">bold</item>
</style>

Produziert:

Erstellen einer SoftKeyboard mit mehreren /alternativen Zeichen pro Taste

Ich werde nicht glücklich sein bis ich es geschafft haben, implementieren Sie diese in der gleichen Weise wie das System die Tastatur funktioniert!

InformationsquelleAutor der Antwort

14

Ausgehend von meinen eigenen Versuch einer Codierung ein softkeyboard fand ich heraus, dass:
- Schön/bling-bling-Funktionen, die normalerweise erfordert, dass Sie erweitern KeyboardView und im Grunde schreiben große Teile der Zeichnung code. Leider nicht tun Sie dies durch überschreiben einige der wichtigsten Methoden, da fast alles, was privat ist. Möchten Sie vielleicht einen Blick (und einige ausleihen code aus:
  - (base)/core/java/android/inputmethodservice/KeyboardView.java (android core code-repo)
  - (apps)/other/LatinIME/LatinKeyboardView.java (android core apps repo)
Beachten Sie, dass die Schafe auf android.kernel.org ist es dir zu sagen, dass das repo ist geschlossen wegen Cracker, aber es spiegelt den code an anderer Stelle (verloren die links leider)
- Der Basis KeyboardView hat keine Unterstützung für beschattet-Taste Hinweise, müssen Sie den code Ihrer eigenen KeyboardView eine chance zu bekommen, um das überschreiben der onDraw () - Methode.
Nun auf das, was Sie kann tun:
- Können Sie dieses Problem umgehen, indem Sie die Bilder für die Tasten: verwenden Sie xml -<Key ... android:keyIcon="@drawable/this_key_icon_file />. Leider, werden Sie sicherlich haben schlechte Ergebnisse für Buchstaben mit dieser Methode (Auflösung Probleme).
- Können Sie (und konfigurieren Sie Aussehen) popup-Tastatur, die erscheint, auf lange drücken.
Deklarieren Sie eine Tastatur-Vorlage res/xml/kbd_popup_template.xml :
```
<Keyboard xmlns:android="http://schemas.android.com/apk/res/android"
    android:keyWidth="10%p"
    android:horizontalGap="0px"
    android:verticalGap="0px"
    android:keyHeight="@dimen/key_height">
</Keyboard>
```
Deklarieren string-Werte mit den Tasten, die Sie wollen auf dieser Tastatur res/values/strings.xml:
```
<resources xmlns:xliff="urn:oasis:names:tc:xliff:document:1.2">
    <string name="alternates_for_a">àáâãäåæ</string>
</ressources>
```
Verwenden Sie dann beide in Ihre Tastatur-layout definition:
```
<Key android:codes="97" android:keyLabel="a"  
    android:popupKeyboard="@xml/kbd_popup_template"
    android:popupCharacters="@string/alternates_for_a" />
```
- Können Sie auch doppelt Antippen, triple-tap, ... Funktion zum generieren von alternativen für die Taste, die Sie Tippen sind. So zu tun, verwenden Sie einfach einen Liste für die android-Tasten:
  
  <Key android:codes="97,224,230" .../>
produzieren, 97='a' für einzelne Leitungswasser, 224='à' für double-tap-230='æ " für dreifach-Tippen.

Die Dauer zu berücksichtigen Doppeltippen festgelegt ist, zu 800ms in den android-Quellcode. Es ist leider hardcoded (und ein bisschen hoch, ich fühle mich).

Sich bewusst sein, dass, wenn Doppel-Tippen, es ist im Grunde sendet eine 'a' first, dann, nach dem zweiten Tippen aber es sendet 'à'. Einige apps, nicht wie diese.

InformationsquelleAutor der Antwort Laurent'
12

Popup-Tastatur mit der Schaltfläche schließen ist ärgerlich, wenn wir nur ein popup-Charakter.
Einfachere Möglichkeit ist das überschreiben der onLongPress Methode der KeyboardView Klasse wie dieses.
```
@Override
protected boolean onLongPress(Key key) {
    if (key.codes[0] == '1') {
        getOnKeyboardActionListener().onKey('!', null);
        return true;
    }
}
```
InformationsquelleAutor der Antwort

Wenn Sie wollen, um text auf der Oberseite des Schlüssels, die Sie tun können, es in der onDraw () - Methode in der Klasse, überschreibt KeyboardView

 @Override
public void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    ...
    Paint paint = new Paint();
    paint.setTextAlign(Paint.Align.CENTER);
    paint.setTextSize(18);
    paint.setColor(Color.WHITE);
    //get all your keys and draw whatever you want
    List <Keyboard.Key> keys = getKeyboard().getKeys();
    for(Keyboard.Key key: keys) {
        if(key.label != null) {

            if (key.label.toString().equals("q") || key.label.toString().equals("Q"))
                canvas.drawText(String.valueOf(1), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("w") || key.label.toString().equals("W"))
                canvas.drawText(String.valueOf(2), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("e") || key.label.toString().equals("E"))
                canvas.drawText(String.valueOf(3), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("r") || key.label.toString().equals("R"))
                canvas.drawText(String.valueOf(4), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("t") || key.label.toString().equals("T"))
                canvas.drawText(String.valueOf(5), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("y") || key.label.toString().equals("Y"))
                canvas.drawText(String.valueOf(6), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("u") || key.label.toString().equals("U"))
                canvas.drawText(String.valueOf(7), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("i") || key.label.toString().equals("I"))
                canvas.drawText(String.valueOf(8), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("o") || key.label.toString().equals("o"))
                canvas.drawText(String.valueOf(9), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else if (key.label.toString().equals("p") || key.label.toString().equals("P"))
                canvas.drawText(String.valueOf(0), key.x + (key.width / 2) + 10, key.y + 25, paint);

            else
            {}
        }
    }
}

InformationsquelleAutor der Antwort

Für jeden, der versucht, schließen Sie die popup-Tastatur durch Tippen außerhalb seiner Sicht-Bereich, ich hatte Glück, indem ein TouchListener auf die KeyboardView innerhalb der Klasse, die sich InputMethodService

public class YourIME extends InputMethodService{
    @Override 
    public View onCreateInputView() {
        mInputView = (LatinKeyboardView) getLayoutInflater().inflate(R.layout.input, null);
        setLatinKeyboard(mQwertyKeyboard);

        mInputView.setOnTouchListener(new View.OnTouchListener() {
            @Override
            public boolean onTouch(View view, MotionEvent motionEvent) {

                if(motionEvent.getAction() == MotionEvent.ACTION_DOWN) {                        
                    mInputView.closing(); //Close popup keyboard if it's showing
                }
                return false;
            }
        });

        return mInputView;
    }
//The rest of your ime ...
}

InformationsquelleAutor der Antwort

wenn Sie wollen, um text auf der Oberseite des Schlüssels, die Sie tun können, es in der onDraw () - Methode in Ihrer Klasse, die Sie erweitert KeyboardView ich so etwas Tat vielleicht jemandem helfen kann

Erstellen einer SoftKeyboard mit mehreren /alternativen Zeichen pro Taste

 @Override
public void onDraw(Canvas canvas) {
    super.onDraw(canvas);
    Log.d("LatinKeyboardView", "onDraw");

    Paint paint = new Paint();
    paint.setTextAlign(Paint.Align.CENTER);
    paint.setTextSize(30);
    paint.setColor(Color.LTGRAY);

    List<Key> keys = getKeyboard().getKeys();
    for (Key key : keys) {
        if (key.label != null) {
            switch (key.codes[0]) {

                //qQ
                case 81:
                case 113:
                case 1602:
                case 1618:
                    canvas.drawText(String.valueOf(1), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //wW
                case 87:
                case 119:
                case 1608:
                case 1572:
                    canvas.drawText(String.valueOf(2), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //eE
                case 69:
                case 101:
                case 1593:
                case 1617:
                    canvas.drawText(String.valueOf(3), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;


                //rR
                case 82:
                case 114:
                case 1585:
                case 1681:
                    canvas.drawText(String.valueOf(4), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //tT
                case 84:
                case 116:
                case 1578:
                case 1657:
                    canvas.drawText(String.valueOf(5), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //yY
                case 89:
                case 121:
                case 1746:
                case 1552:
                    canvas.drawText(String.valueOf(6), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //uU
                case 85:
                case 117:
                case 1569:
                case 1574:
                    canvas.drawText(String.valueOf(7), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //iI
                case 73:
                case 105:
                case 1740:
                case 1648:
                    canvas.drawText(String.valueOf(8), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //oO
                case 79:
                case 111:
                case 1729:
                case 1731:
                    canvas.drawText(String.valueOf(9), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //pP
                case 80:
                case 112:
                case 1662:
                case 1615:
                    canvas.drawText(String.valueOf(0), key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;


                //aA
                case 65:
                case 97:
                case 1575:
                case 1570:
                    canvas.drawText("@", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //sS
                case 83:
                case 115:
                case 1587:
                case 1589:
                    canvas.drawText("#", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //dD
                case 68:
                case 100:
                case 1583:
                case 1672:
                    canvas.drawText("$", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //fF
                case 70:
                case 102:
                case 1601:
                case 1613:
                    canvas.drawText("%", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //gG
                case 71:
                case 103:
                case 1711:
                case 1594:
                    canvas.drawText("&", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //hH
                case 72:
                case 104:
                case 1726:
                case 1581:
                    canvas.drawText("-", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //jJ
                case 74:
                case 106:
                case 1580:
                case 1590:
                    canvas.drawText("+", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //kK
                case 75:
                case 107:
                case 1705:
                case 1582:
                    canvas.drawText("(", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //lL
                case 76:
                case 108:
                case 1604:
                case 1614:
                    canvas.drawText(")", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //zZ
                case 90:
                case 122:
                case 1586:
                case 1584:
                    canvas.drawText("*", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //xX
                case 88:
                case 120:
                case 1588:
                case 1679:
                    canvas.drawText("\"", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //cC
                case 67:
                case 99:
                case 1670:
                case 1579:
                    canvas.drawText("\'", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //vV
                case 86:
                case 118:
                case 1591:
                case 1592:
                    canvas.drawText(":", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //bB
                case 66:
                case 98:
                case 1576:
                case 1616:
                    canvas.drawText(";", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;

                //nN
                case 78:
                case 110:
                case 1606:
                case 1722:
                    canvas.drawText("!", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;
                //mM
                case 77:
                case 109:
                case 1605:
                case 1611:
                    canvas.drawText("?", key.x + (key.width - keyXAxis), key.y + keyYAxis, paint);
                    break;


            }

        }

    }
}

passen diese Achse nach Ihrer Wahl

int keyXAxis = 25;
int keyYAxis = 50;

InformationsquelleAutor der Antwort

Schreibe einen Kommentar

Du musst angemeldet sein, um einen Kommentar abzugeben.