Un editor di metodi di inserimento (IME) è un controllo utente che consente agli utenti di inserire del testo. Android fornisce un framework di metodi di inserimento estendibile che consente alle applicazioni di offrire agli utenti metodi di inserimento alternativi, come le tastiere sullo schermo o l'input vocale. Dopo aver installato gli IME, l'utente può selezionarne uno dalle impostazioni di sistema e utilizzarlo nell'intero sistema. È possibile attivare un solo IME alla volta.
Per aggiungere un IME al sistema Android, crea un'applicazione Android contenente una classe che estende InputMethodService.
Inoltre, in genere crei un'attività "settings" che passa le opzioni al servizio IME. Puoi anche definire un'interfaccia utente delle impostazioni da visualizzare nelle impostazioni di sistema.
Questa pagina tratta i seguenti argomenti:
- Il ciclo di vita dell'IME
- Dichiarazione dei componenti IME nel file manifest dell'applicazione
- L'API IME
- Progettare un'interfaccia utente dell'IME
- Invio di testo da un IME a un'applicazione
- Lavorare con i sottotipi di IME
- Altre considerazioni relative all'IME
Se non hai mai utilizzato IME, leggi innanzitutto l'articolo introduttivo Metodi di inserimento sullo schermo.
Ciclo di vita dell'IME
Il seguente diagramma descrive il ciclo di vita di un IME:
Le sezioni seguenti descrivono come implementare l'interfaccia utente e il codice associati a un IME che segue questo ciclo di vita.
Dichiara i componenti IME nel file manifest
Nel sistema Android, un IME è un'applicazione Android che contiene un servizio IME speciale. Il
file manifest dell'applicazione deve dichiarare il servizio, richiedere le autorizzazioni necessarie, fornire un
filtro per intent che corrisponda all'azione action.view.InputMethod e fornire metadati
che definiscono le caratteristiche dell'IME. Inoltre, per fornire un'interfaccia di impostazioni che consenta all'utente di modificare il comportamento dell'IME, puoi definire un'attività "settings" che può essere avviata dalle impostazioni di sistema.
Lo snippet seguente dichiara un servizio IME. Richiede l'autorizzazione
BIND_INPUT_METHOD
per consentire al servizio di connettere l'IME al sistema, configura un filtro per intent corrispondente all'azione
android.view.InputMethod e definisce i metadati per l'IME:
<!-- Declares the input method service. -->
<service android:name="FastInputIME"
android:label="@string/fast_input_label"
android:permission="android.permission.BIND_INPUT_METHOD">
<intent-filter>
<action android:name="android.view.InputMethod" />
</intent-filter>
<meta-data android:name="android.view.im"
android:resource="@xml/method" />
</service>
Lo snippet successivo dichiara l'attività di impostazioni per l'IME. Ha un filtro per intent per
ACTION_MAIN che
indica che questa attività è il punto di contatto principale per l'applicazione IME:
<!-- Optional: an activity for controlling the IME settings. -->
<activity android:name="FastInputIMESettings"
android:label="@string/fast_input_settings">
<intent-filter>
<action android:name="android.intent.action.MAIN"/>
</intent-filter>
</activity>
Puoi anche fornire l'accesso alle impostazioni dell'IME direttamente dalla relativa UI.
L'API del metodo di immissione
Le classi specifiche per le IME si trovano nei pacchetti
android.inputmethodservice
e
android.view.inputmethod. La classe KeyEvent è importante per gestire i caratteri della tastiera.
La parte centrale di un IME è un componente di servizio, una classe che estendeInputMethodService. Oltre a implementare il normale ciclo di vita del servizio, questa classe ha callback per fornire l'interfaccia utente dell'IME, gestire l'input dell'utente e inviare il testo al campo attivo. Per impostazione predefinita, la classe InputMethodService fornisce la maggior parte dell'implementazione per la gestione dello stato e della visibilità dell'IME e la comunicazione con il campo di immissione corrente.
Sono importanti anche le seguenti classi:
BaseInputConnection-
Definisce il canale di comunicazione da un
InputMethodall'applicazione che riceve l'input. Lo utilizzi per leggere il testo intorno al cursore, confermare il testo nella casella di testo e inviare all'applicazione eventi chiave non elaborati. Le applicazioni devono estendere questa classe anziché implementare l'interfaccia di baseInputConnection. KeyboardView-
Un'estensione di
Viewche visualizza una tastiera e risponde agli eventi di input utente. Il layout della tastiera è specificato da un'istanza diKeyboard, che puoi definire in un file XML.
Progettare l'interfaccia utente del metodo di immissione
Esistono due elementi visivi principali per un IME: la visualizzazione di input e la visualizzazione di candidati. Devi implementare solo gli elementi pertinenti al metodo di inserimento che stai progettando.
Visualizzazione di input
La visualizzazione di input è l'interfaccia utente in cui l'utente inserisce il testo sotto forma di clic sui tasti, scrittura a mano libera o gesti. Quando l'IME viene visualizzato per la prima volta, il sistema chiama il callback
onCreateInputView(). Nell'implementazione di questo metodo, crea il layout che vuoi visualizzare nella finestra dell'IME e restituiscilo al sistema. Lo snippet seguente mostra un esempio di implementazione del metodo onCreateInputView():
Kotlin
override fun onCreateInputView(): View {
return layoutInflater.inflate(R.layout.input, null).apply {
if (this is MyKeyboardView) {
setOnKeyboardActionListener(this@MyInputMethod)
keyboard = latinKeyboard
}
}
}
Java
@Override
public View onCreateInputView() {
MyKeyboardView inputView =
(MyKeyboardView) getLayoutInflater().inflate(R.layout.input, null);
inputView.setOnKeyboardActionListener(this);
inputView.setKeyboard(latinKeyboard);
return inputView;
}
In questo esempio, MyKeyboardView è un'istanza di un'implementazione personalizzata di
KeyboardView che esegue il rendering di un Keyboard.
Visualizzazione Candidati
La visualizzazione delle alternative è l'interfaccia utente in cui l'IME mostra potenziali correzioni o suggerimenti di parole da selezionare dall'utente. Nel ciclo di vita dell'IME, il sistema chiama
onCreateCandidatesView()
quando è pronto per visualizzare la visualizzazione dei candidati. Nell'implementazione di questo metodo, restituisci un layout che mostri i suggerimenti di parole o restituisci null se non vuoi mostrare nulla. Una risposta null è il comportamento predefinito, quindi non devi implementarla se non fornisci suggerimenti.
Considerazioni sul design dell'interfaccia utente
Questa sezione descrive alcune considerazioni sul design dell'interfaccia utente per gli IME.
Gestire più dimensioni dello schermo
L'interfaccia utente dell'IME deve essere in grado di adattarsi a schermi di dimensioni diverse e gestire sia l'orientamento orizzontale sia quello verticale. In modalità IME non a schermo intero, lascia uno spazio sufficiente per consentire all'applicazione di mostrare il campo di testo e l'eventuale contesto associato, in modo che l'IME non occupi più della metà dello schermo. In modalità IME a schermo intero, questo non è un problema.
Gestire diversi tipi di input
I campi di testo Android ti consentono di impostare un tipo di input specifico, ad esempio testo in formato libero, numeri, URL, indirizzi email e stringhe di ricerca. Quando implementi un nuovo IME, rileva il tipo di input di ogni campo e fornisci l'interfaccia appropriata. Tuttavia, non devi configurare l'IME per verificare se l'utente inserisce un testo valido per il tipo di input. È responsabilità dell'applicazione proprietaria del campo di testo.
Ad esempio, di seguito è riportata l'interfaccia fornita dall'IME latino per l'input di testo della piattaforma Android:
Ecco l'interfaccia fornita dall'IME latino per l'input numerico della piattaforma Android:
Quando un campo di immissione riceve lo stato attivo e l'IME si avvia, il sistema chiama
onStartInputView(),
passando un oggetto
EditorInfo
che contiene i dettagli sul tipo di immissione e su altri attributi del campo di testo. In questo oggetto, il campo inputType contiene il tipo di input del campo di testo.
Il campo inputType è un int che contiene pattern di bit per varie impostazioni del tipo di input. Per testarlo per il tipo di input del campo di testo, mascheralo con la costanteTYPE_MASK_CLASS, come segue:
Kotlin
inputType and InputType.TYPE_MASK_CLASS
Java
inputType & InputType.TYPE_MASK_CLASS
Il pattern di bit del tipo di input può avere uno di diversi valori, tra cui:
TYPE_CLASS_NUMBER- Un campo di testo per l'inserimento di numeri. Come illustrato nella figura 3, l'IME latino mostra un tastierino numerico per i campi di questo tipo.
TYPE_CLASS_DATETIME- Un campo di testo per inserire una data e un'ora.
TYPE_CLASS_PHONE- Un campo di testo per inserire i numeri di telefono.
TYPE_CLASS_TEXT- Un campo di testo per inserire qualsiasi carattere supportato.
Queste costanti sono descritte in maggiore dettaglio nella documentazione di riferimento perInputType.
Il campo inputType può contenere altri bit che indicano una variante del tipo di campo di testo, ad esempio:
TYPE_TEXT_VARIATION_PASSWORD- Una variante di
TYPE_CLASS_TEXTper inserire le password. Il metodo di inserimento mostra simboli anziché il testo effettivo. TYPE_TEXT_VARIATION_URI- Una variante di
TYPE_CLASS_TEXTper inserire URL web e altri Uniform Resource Identifier (URI). TYPE_TEXT_FLAG_AUTO_COMPLETE- Una variante di
TYPE_CLASS_TEXTper inserire il testo che l'applicazione completa automaticamente da un dizionario, una ricerca o un'altra funzionalità.
Nascondi inputType con la costante appropriata quando esegui il test per queste varianti. Le costanti della maschera disponibili sono elencate nella documentazione di riferimento di InputType.
Invia un messaggio all'applicazione
Quando l'utente inserisce il testo con il tuo IME, puoi inviare il testo all'applicazione inviando singoli eventi correlati ai tasti o modificando il testo intorno al cursore nel campo di testo dell'applicazione. In entrambi i casi,
utilizza un'istanza di InputConnection per inviare il testo. Per ottenere questa istanza, chiama
InputMethodService.getCurrentInputConnection().
Modificare il testo attorno al cursore
Quando gestisci la modifica del testo esistente, alcuni metodi utili in
BaseInputConnection sono i seguenti:
-
getTextBeforeCursor() - Restituisce un
CharSequencecontenente il numero di caratteri richiesti prima della posizione corrente del cursore. -
getTextAfterCursor() - Restituisce un
CharSequencecontenente il numero di caratteri richiesti successivi alla posizione corrente del cursore. -
deleteSurroundingText() - Elimina il numero specificato di caratteri prima e dopo la posizione corrente del cursore.
-
commitText() - Esegue il commit di un
CharSequencenel campo di testo e imposta una nuova posizione del cursore.
Ad esempio, lo snippet seguente mostra come sostituire i quattro caratteri a sinistra del cursore con il testo "Ciao!":
Kotlin
currentInputConnection.also { ic: InputConnection ->
ic.deleteSurroundingText(4, 0)
ic.commitText("Hello", 1)
ic.commitText("!", 1)
}
Java
InputConnection ic = getCurrentInputConnection();
ic.deleteSurroundingText(4, 0);
ic.commitText("Hello", 1);
ic.commitText("!", 1);
Supporto della composizione del testo prima del commit
Se l'IME prevede il testo o richiede più passaggi per comporre un glifo o una parola, puoi mostrare lo stato di avanzamento nel campo di testo finché l'utente non conferma la parola, quindi puoi sostituire la composizione parziale con il testo completato. Puoi applicare un trattamento speciale al testo aggiungendo un
elemento span quando lo passi a
setComposingText().
Il seguente snippet mostra come mostrare l'avanzamento in un campo di testo:
Kotlin
currentInputConnection.also { ic: InputConnection ->
ic.setComposingText("Composi", 1)
ic.setComposingText("Composin", 1)
ic.commitText("Composing ", 1)
}
Java
InputConnection ic = getCurrentInputConnection();
ic.setComposingText("Composi", 1);
ic.setComposingText("Composin", 1);
ic.commitText("Composing ", 1);
Intercettare gli eventi chiave hardware
Anche se la finestra del metodo di inserimento non ha lo stato attivo esplicito, riceve prima gli eventi chiave hardware e può consumarli o inoltrarli all'applicazione. Ad esempio, potresti voler utilizzare i tasti direzionali per navigare all'interno dell'interfaccia utente per la selezione dei candidati durante la composizione. Potresti anche bloccare il tasto Indietro per chiudere eventuali finestre di dialogo provenienti dalla finestra del metodo di inserimento.
Per intercettare le chiavi hardware, sostituisci
onKeyDown()
e
onKeyUp().
Chiama il metodo super() per le chiavi che non vuoi gestire autonomamente.
Creare un sottotipo di IME
I sottotipi consentono all'IME di esporre più modalità di immissione e lingue supportate da un IME. Un sottotipo può rappresentare quanto segue:
- Una locale, ad esempio en_US o fr_FR
- Una modalità di inserimento, ad esempio vocale, tastiera o scrittura a mano
- Altri stili di input, moduli o proprietà specifici per l'IME, come i layout tastiera con 10 tasti o QWERTY
La modalità può essere qualsiasi testo, ad esempio "tastiera" o "voce". Un sottotipo può anche esporre una combinazione di questi elementi.
Le informazioni sul sottotipo vengono utilizzate per una finestra di dialogo di commutazione dell'IME disponibile nella barra delle notifiche e per le impostazioni dell'IME. Le informazioni consentono inoltre al framework di visualizzare direttamente un sottotipo specifico di un IME. Quando crei un IME, utilizza la funzionalità di sottotipo, perché aiuta l'utente a identificare e cambiare tra lingue e modalità IME diverse.
Definisci i sottotipi in uno dei file di risorse XML del metodo di inserimento utilizzando l'elemento<subtype>. Il seguente snippet di codice definisce un IME con due sottotipi: un
sottotipo di tastiera per la locale inglese statunitense e un altro
sottotipo di tastiera per la locale lingua francese per la Francia:
<input-method xmlns:android="http://schemas.android.com/apk/res/android"
android:settingsActivity="com.example.softkeyboard.Settings"
android:icon="@drawable/ime_icon">
<subtype android:name="@string/display_name_english_keyboard_ime"
android:icon="@drawable/subtype_icon_english_keyboard_ime"
android:languageTag="en-US"
android:imeSubtypeMode="keyboard"
android:imeSubtypeExtraValue="somePrivateOption=true" />
<subtype android:name="@string/display_name_french_keyboard_ime"
android:icon="@drawable/subtype_icon_french_keyboard_ime"
android:languageTag="fr-FR"
android:imeSubtypeMode="keyboard"
android:imeSubtypeExtraValue="someVariable=30,someInternalOption=false" />
<subtype android:name="@string/display_name_german_keyboard_ime" ... />
</input-method>
Per assicurarti che i sottotipi siano etichettati correttamente nell'interfaccia utente, utilizza "%s" per ottenere un'etichetta del sottotipo uguale a quella dell'etichetta locale del sottotipo. Questo è dimostrato nei due snippet di codice successivi. Il primo snippet mostra parte del file XML del metodo di inserimento:
<subtype
android:label="@string/label_subtype_generic"
android:imeSubtypeLocale="en_US"
android:icon="@drawable/icon_en_us"
android:imeSubtypeMode="keyboard" />
Lo snippet successivo fa parte del file strings.xml dell'IME. La risorsa stringa
label_subtype_generic, utilizzata dalla definizione dell'interfaccia utente del metodo di inserimento per impostare l'etichetta del
sottotipo, è definita come segue:
<string name="label_subtype_generic">%s</string>
Questa impostazione fa sì che il nome visualizzato del sottotipo corrisponda all'impostazione della locale. Ad esempio, in qualsiasi lingua inglese, il nome visualizzato è "Inglese (Stati Uniti)".
Scegliere i sottotipi di IME dalla barra delle notifiche
Il sistema Android gestisce tutti i sottotipi esposti da tutti gli IME. I sottotipi di IME vengono trattati come modalità dell'IME a cui appartengono. L'utente può passare dalla barra delle notifiche o dall'app Impostazioni a un menu di sottotipi di IME disponibili, come mostrato nella figura seguente:
Scegliere i sottotipi di IME dalle Impostazioni di sistema
L'utente può anche controllare il modo in cui vengono utilizzati i sottotipi nel riquadro delle impostazioni Lingua e inserimento nelle impostazioni di sistema:
Passare da un sottotipo di IME all'altro
Puoi consentire agli utenti di passare facilmente da un sottotipo di IME all'altro fornendo un tasto di attivazione/disattivazione, ad esempio l'icona della lingua a forma di globo sulla tastiera. In questo modo, la tastiera è più facile da usare e comoda per l'utente. Per attivare questo passaggio, segui questi passaggi:
- Dichiara
supportsSwitchingToNextInputMethod = "true"nei file di risorse XML del metodo di inserimento. La dichiarazione deve avere il seguente aspetto:<input-method xmlns:android="http://schemas.android.com/apk/res/android" android:settingsActivity="com.example.softkeyboard.Settings" android:icon="@drawable/ime_icon" android:supportsSwitchingToNextInputMethod="true"> - Chiama il metodo
shouldOfferSwitchingToNextInputMethod(). - Se il metodo restituisce true, mostra un tasto di attivazione/disattivazione.
- Quando l'utente tocca il tasto di attivazione/disattivazione, chiama
switchToNextInputMethod(), passando false. Un valore false indica al sistema di trattare tutti i sottotipi allo stesso modo, indipendentemente dall'IME a cui appartengono. Se specifichi true, il sistema deve scorrere i sottotipi nell'IME corrente.
Considerazioni generali sull'IME
Di seguito sono riportati altri aspetti da considerare durante l'implementazione dell'IME:
- Offrire agli utenti un modo per impostare le opzioni direttamente dall'interfaccia utente dell'IME.
- Fornisci agli utenti un modo per passare a un IME diverso direttamente dall'interfaccia utente del metodo di inserimento, perché sul dispositivo potrebbero essere installati più IME.
- Apri rapidamente l'interfaccia utente dell'IME. Precarica o carica su richiesta le risorse di grandi dimensioni in modo che gli utenti vedano il metodo di inserimento immediato non appena toccano un campo di testo. Memorizza nella cache le risorse e le visualizzazioni per le invocazioni successive del metodo di immissione.
- Libera allocazioni di memoria di grandi dimensioni subito dopo aver nascosto la finestra del metodo di inserimento, in modo che le applicazioni abbiano memoria sufficiente per funzionare. Utilizza un messaggio in ritardo per rilasciare le risorse se la tastiera virtuale è nascosta per alcuni secondi.
- Assicurati che gli utenti possano inserire il maggior numero possibile di caratteri per la lingua o le impostazioni internazionali associate all'IME. Gli utenti potrebbero utilizzare la punteggiatura nelle password o nei nomi utente, pertanto il tuo IME deve fornire molti caratteri diversi per consentire agli utenti di inserire una password e accedere al dispositivo.