Un IME (Input Method Editor) è un controllo utente che consente agli utenti di inserire testo. Android offre un framework estensibile di metodo di input che consente alle applicazioni di fornire agli utenti metodi di input alternativi, come tastiere sullo schermo o input vocale. Dopo aver installato gli IME, l'utente può selezionarne uno le impostazioni di sistema e utilizzarle in tutto il sistema. È possibile attivare un solo IME alla volta.
Per aggiungere un IME al sistema Android, crea un'applicazione Android contenente una classe
si estende
InputMethodService.
Inoltre, solitamente crei "impostazioni" l'attività che trasmette opzioni al servizio IME. Tu
puoi anche definire una UI delle impostazioni che viene visualizzata 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
- Progettazione di un'interfaccia utente IME
- Inviare testo da un IME a un'applicazione
- Utilizzo dei sottotipi IME
- Altre considerazioni relative all'IME
Se non hai utilizzato gli IME, leggi l'articolo introduttivo Metodi di immissione sullo schermo per prima cosa.
Il ciclo di vita dell'IME
Il seguente diagramma descrive il ciclo di vita di un IME:
Le seguenti sezioni 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. La
del file manifest dell'applicazione deve dichiarare il servizio, richiedere le autorizzazioni necessarie, fornire
filtro per intent che corrisponde all'azione action.view.InputMethod e fornire metadati
che definisce le caratteristiche dell'IME. Inoltre, per fornire un'interfaccia di impostazioni che consente
modificare il comportamento dell'IME, è possibile definire "impostazioni" dell'attività che può essere avviata
Impostazioni di sistema.
Il seguente snippet dichiara un servizio IME. Richiedono l'autorizzazione
BIND_INPUT_METHOD
per consentire al servizio di collegare l'IME al sistema, configura un filtro per intent che corrisponde 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à relativa alle impostazioni per l'IME. Ha un filtro per intent per
ACTION_MAIN che
indica che questa attività è il punto di ingresso 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 sua interfaccia utente.
L'API del metodo di input
Le classi specifiche per gli IME si trovano nella
android.inputmethodservice
e
android.view.inputmethod
pacchetti. Il corso KeyEvent è
è importante per la gestione
dei caratteri della tastiera.
La parte centrale di un IME è un componente di servizio, una classe che si estende
InputMethodService. Oltre a implementare il normale ciclo di vita del servizio,
dispone di callback per fornire l'interfaccia utente dell'IME, gestire l'input utente e inviare testo al
campo attivo. Per impostazione predefinita, la classe InputMethodService fornisce la maggior parte delle
implementazione per gestire lo stato e la visibilità dell'IME e comunicare con il
campo di immissione.
Anche i seguenti corsi sono importanti:
BaseInputConnection-
Definisce il canale di comunicazione da un
InputMethodall'applicazione che riceve il suo input. Puoi utilizzarlo per leggere il testo intorno alla il cursore, eseguire il commit del testo nella casella di testo e inviare gli eventi chiave non elaborati all'applicazione. Le applicazioni devono estendere questa classe anziché implementare l'interfaccia di baseInputConnection. KeyboardView-
Un'estensione di
Viewche esegue il rendering di una tastiera e risponde agli eventi di input dell'utente. Il layout della tastiera viene specificato da un di Compute Engine,Keyboard, che puoi definire in un file XML.
Progetta l'interfaccia utente del metodo di inserimento
Gli elementi visivi principali di un IME sono due: la visualizzazione input e la candidati. È sufficiente implementare gli elementi pertinenti che stai progettando.
Visualizzazione immissione
La visualizzazione degli input è la UI 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
onCreateInputView()
di Google. Nell'implementazione di questo metodo, crea il layout che vuoi visualizzare nell'IME
e restituisce il layout al sistema. Il seguente snippet mostra un esempio di implementazione
il 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 candidati è l'interfaccia utente in cui l'IME mostra potenziali correzioni o suggerimenti di parole
che l'utente può selezionare. Nel ciclo di vita dell'IME, il sistema chiama
onCreateCandidatesView()
quando è pronto per mostrare la vista candidati. Nell'implementazione di questo metodo, restituisci
che mostra i suggerimenti di parole, oppure restituire null se non si desidera mostrare nulla. Un valore nullo
risposta è il comportamento predefinito, quindi non è necessario implementarlo se non specifichi
suggerimenti.
Considerazioni sulla progettazione dell'UI
In questa sezione vengono descritte alcune considerazioni sulla progettazione dell'interfaccia utente per gli IME.
Gestione di più dimensioni dello schermo
L'interfaccia utente dell'IME deve essere in grado di adattarsi a schermi di diverse dimensioni e di gestire sia l'orientamento orizzontale orientamenti verticali. In modalità IME non a schermo intero, lascia spazio sufficiente per l'applicazione il campo di testo e gli eventuali contesti associati, in modo che non venga occupata più della metà dello schermo l'IME. In modalità IME a schermo intero, non è un problema.
Gestione di 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 e a fornire l'interfaccia appropriata. Tuttavia, non devi configurare l'IME per controlla se l'utente inserisce un testo valido per il tipo di input. Questa è responsabilità del un'applicazione proprietaria del campo di testo.
Ad esempio, ecco l'interfaccia fornita dall'IME latino per il testo della piattaforma Android input:
Ecco l'interfaccia fornita dall'IME latino per la piattaforma Android input numerico:
Quando un campo di immissione viene attivato e l'IME viene avviato, il sistema chiama
onStartInputView(),
passando un
Oggetto EditorInfo
contenente i dettagli sul tipo di input e altri attributi del campo di testo. In questo oggetto,
il
inputType
contiene il tipo di input del campo di testo.
Il campo inputType è un int che contiene pattern di bit per varie
le impostazioni del tipo di input. Per testare il tipo di input del campo di testo, mascheralo con la costante
TYPE_MASK_CLASS,
nel seguente modo:
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 inserire numeri. Come illustrato nella figura 3, l'IME latino mostra un tastierino numerico per 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 i caratteri supportati.
Queste costanti sono descritte più dettagliatamente nella documentazione di riferimento per
InputType.
Il campo inputType può contenere altri bit che indicano una variante del campo di testo
di tipo predefinito, come ad esempio:
TYPE_TEXT_VARIATION_PASSWORD- Una variante di
TYPE_CLASS_TEXTper l'inserimento delle password. Il metodo di inserimento mostra dingbat anziché il testo effettivo. TYPE_TEXT_VARIATION_URI- Una variante di
TYPE_CLASS_TEXTper l'inserimento di URL web e altre risorse uniformi identificatori (URI). TYPE_TEXT_FLAG_AUTO_COMPLETE- Una variante di
TYPE_CLASS_TEXTper l'inserimento del testo che l'applicazione vengono completati automaticamente da un dizionario, da una ricerca o da un'altra funzionalità.
Maschera inputType con la costante appropriata quando esegui il test per queste varianti. La
le costanti di maschera disponibili sono elencate nella documentazione di riferimento per InputType.
Invia testo all'applicazione
Quando l'utente inserisce testo con il tuo IME, puoi inviare testo all'applicazione inviando singole
eventi chiave o modificando il testo attorno al cursore nel campo di testo dell'applicazione. In entrambi i casi,
utilizza un'istanza di InputConnection per pubblicare il testo. Per ottenere questa istanza, chiama
InputMethodService.getCurrentInputConnection().
Modificare il testo intorno al cursore
Ecco alcuni metodi utili per la modifica di testo esistente
BaseInputConnection sono i seguenti:
-
getTextBeforeCursor() - restituisce un
CharSequencecontenente il numero di caratteri richiesti prima della posizione attuale del cursore. -
getTextAfterCursor() - Restituisci un
CharSequencecontenente il numero di caratteri richiesti che seguono la posizione attuale del cursore. -
deleteSurroundingText() - Elimina il numero specificato di caratteri prima e dopo la posizione attuale del cursore.
-
commitText() - Esegui il commit di
CharSequencenel campo di testo e imposta una nuova posizione del cursore.
Ad esempio, il seguente snippet mostra come sostituire i quattro caratteri a sinistra della cursore con il testo "Hello!":
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 scrittura del testo prima di impegnarsi
Se l'IME prevede testo o richiede più passaggi per comporre un glifo o una parola, puoi mostrare
i progressi nel campo di testo finché l'utente non esegue il commit della parola. A questo punto puoi sostituire
composizione con il testo completo. Puoi trattare il testo in modo speciale aggiungendo un'opzione
span quando lo passi
setComposingText().
Il seguente snippet illustra 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);
Intercetta eventi chiave hardware
Anche se la finestra del metodo di immissione non ha uno stato attivo esplicito, riceve eventi chiave hardware. e può utilizzarli o inoltrarli all'applicazione. Ad esempio, potresti voler utilizza i tasti direzionali per navigare all'interno dell'interfaccia utente per la selezione del candidato durante la composizione. Potresti anche voler bloccare il tasto Indietro per chiudere le eventuali finestre di dialogo che hanno origine dal metodo di inserimento. finestra.
Per intercettare le chiavi hardware, sostituisci
onKeyDown()
e
onKeyUp().
Chiama il metodo super() per le chiavi che non vuoi gestire autonomamente.
Crea un sottotipo di IME
I sottotipi consentono all'IME di esporre più modalità di input e lingue supportate da un IME. Un sottotipo può rappresentano quanto segue:
- Una lingua, ad esempio en_US o fr_FR
- Una modalità di immissione, ad esempio voce, tastiera o scrittura a mano libera
- Altri stili di input, moduli o proprietà specifici dell'IME, ad esempio 10 tasti o QWERTY layout tastiera
La modalità può essere qualsiasi testo, ad esempio "tastiera" o "voce". Un sottotipo può anche esporre una combinazione di questi.
Le informazioni sul sottotipo vengono utilizzate per una finestra di dialogo del selettore IME disponibile nella barra delle notifiche e per le impostazioni IME. Le informazioni consentono inoltre al framework di visualizzare un sottotipo specifico di IME strato Add. Quando crei un IME, utilizza la funzionalità di sottotipo perché aiuta l'utente a identificare e passare da un linguaggio IME e da una modalità all'altra.
Definisci i sottotipi in uno dei file di risorse XML del metodo di input utilizzando il metodo
Elemento <subtype>. Lo snippet di codice riportato di seguito definisce un IME con due sottotipi:
sottotipo di tastiera per l'impostazione internazionale dell'inglese americano e un altro sottotipo di tastiera per la lingua francese
impostazioni internazionali della 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 tuoi sottotipi siano etichettati correttamente nell'interfaccia utente, usa "%s" per ottenere un'etichetta di sottotipo che corrisponde all'etichetta di impostazioni internazionali del sottotipo. Ciò è dimostrato nei prossimi due snippet di codice. La 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 la
dell'etichetta del sottotipo, è definita come segue:
<string name="label_subtype_generic">%s</string>
Con questa impostazione, il nome visualizzato del sottotipo corrisponde alle impostazioni internazionali. Ad esempio, in qualsiasi Impostazioni internazionali dell'inglese, il nome visualizzato è "Inglese (Stati Uniti)".
Scegli i sottotipi IME dalla barra di notifica
Il sistema Android gestisce tutti i sottotipi esposti da tutti gli IME. I sottotipi IME vengono trattati come modalità all'IME a cui appartengono. L'utente può passare dalla barra delle notifiche o dall'app Impostazioni a un dei sottotipi IME disponibili, come mostrato nella figura seguente:
Scegli i sottotipi IME dalle impostazioni di sistema
L'utente può anche controllare come vengono utilizzati i sottotipi nel campo Lingua e riquadro delle impostazioni di input. nelle impostazioni di sistema:
Passare da un sottotipo di IME all'altro
Puoi consentire agli utenti di passare facilmente da un sottotipo di IME fornendo una chiave di passaggio a un altro, ad esempio icona lingua a forma di globo sulla tastiera. Ciò migliora l'usabilità della tastiera ed è comoda per l'utente. Per attivare il passaggio, svolgi i seguenti passaggi:
- Dichiara
supportsSwitchingToNextInputMethod = "true"nel codice XML del metodo di inserimento di risorse. La tua dichiarazione deve avere un aspetto simile al seguente snippet di codice:<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
shouldOfferSwitchingToNextInputMethod(). - Se il metodo restituisce true, viene visualizzata una chiave di passaggio.
- Quando l'utente tocca il tasto per il passaggio, chiama
switchToNextInputMethod(), passare false. Il valore false indica al sistema di trattare tutti i sottotipi in modo uguale, indipendentemente a quale IME appartengono. Se specifichi true, il sistema deve scorrere i sottotipi nella categoria IME corrente.
Considerazioni generali sull'IME
Di seguito sono riportati altri aspetti da considerare durante l'implementazione dell'IME:
- Offri agli utenti un modo per impostare le opzioni direttamente dall'interfaccia utente dell'IME.
- Offri 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.
- Visualizza rapidamente l'interfaccia utente dell'IME. Precarica o carica on demand risorse di grandi dimensioni in modo che gli utenti visualizzare l'IME non appena toccano un campo di testo. Memorizza nella cache risorse e viste per le successive del metodo di input.
- Rilascia allocazioni di memoria di grandi dimensioni subito dopo che la finestra del metodo di input è nascosta, quindi che le applicazioni abbiano memoria sufficiente per l'esecuzione. Utilizza un messaggio in ritardo per rilasciare risorse se l'IME è nascosto per qualche secondo.
- Assicurati che gli utenti possano inserire il maggior numero possibile di caratteri per la lingua o le impostazioni internazionali associati all'IME. Gli utenti potrebbero utilizzare la punteggiatura nelle password o nei nomi utente, quindi l'IME deve fornire molti caratteri diversi per consentire agli utenti di inserire una password e accedere dispositivo.