Un editor del metodo di input (IME) è un controllo utente che consente agli utenti di inserire il testo. Android fornisce un framework estensibile dei metodi di immissione che consente alle applicazioni di fornire agli utenti metodi di immissione alternativi, come tastiere sullo schermo o 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 un corso che estenda
InputMethodService
.
Inoltre, in genere crei un'attività di "impostazioni" che trasmette le opzioni al servizio IME. Puoi anche definire un'interfaccia utente per le impostazioni che verrà visualizzata nelle impostazioni di sistema.
Questa pagina tratta i seguenti argomenti:
- Ciclo di vita dell'IME
- Dichiarazione dei componenti IME nel manifest dell'applicazione
- API IME
- Progettare l'UI di un IME
- Invio di testo da un IME a un'applicazione
- Utilizzare i sottotipi di IME
- Altre considerazioni relative all'IME
Se non hai utilizzato gli IME, leggi prima l'articolo introduttivo sui metodi di immissione sullo schermo.
Ciclo di vita dell'IME
Il seguente diagramma descrive il ciclo di vita di un IME:
![Un'immagine che mostra il ciclo di vita di un IME.](https://developer.android.google.cn/static/resources/articles/images/inputmethod_lifecycle_image.png?authuser=6&hl=it)
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 intent che corrisponda all'azione action.view.InputMethod
e fornire metadati che definiscano le caratteristiche dell'IME. Inoltre, per fornire un'interfaccia delle impostazioni che consenta all'utente di modificare il comportamento dell'IME, puoi definire un'attività "impostazioni" che può essere avviata dalle impostazioni del sistema.
Lo snippet seguente dichiara un servizio IME. Richiede l'autorizzazione
BIND_INPUT_METHOD
per consentire al servizio di connettere l'IME al sistema, configurare un filtro per intent che corrisponda all'azione
android.view.InputMethod
e definire 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 UI.
L'API del metodo di input
Le classi specifiche degli 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 estende
InputMethodService
. Oltre a implementare il normale ciclo di vita del servizio, questa classe include callback per fornire l'interfaccia utente dell'IME, gestire l'input utente e consegnare 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 per la comunicazione con il campo di immissione attuale.
Sono importanti anche le seguenti classi:
BaseInputConnection
-
Definisce il canale di comunicazione da un
InputMethod
all'applicazione che riceve l'input. Puoi utilizzarlo per leggere il testo attorno al 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
View
che esegue il rendering di una tastiera e risponde agli eventi di input dell'utente. Il layout di tastiera è specificato da un'istanza diKeyboard
, che puoi definire in un file XML.
Progetta l'UI del metodo di inserimento
Esistono due elementi visivi principali per un IME: la vista input e la vista candidati. Devi implementare solo gli elementi pertinenti al metodo di inserimento che stai progettando.
Visualizzazione input
La visualizzazione di input è l'interfaccia utente in cui l'utente inserisce testo sotto forma di clic chiave, 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 da visualizzare nella finestra IME e ripristina il layout 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 candidati è l'interfaccia utente in cui l'IME mostra potenziali correzioni di parole o suggerimenti che l'utente può selezionare. Nel ciclo di vita dell'IME, il sistema chiama
onCreateCandidatesView()
quando è pronto per mostrare la visualizzazione candidati. Nell'implementazione di questo metodo, restituisci un layout che mostri suggerimenti di parole o restituisci null se non vuoi mostrare nulla. Una risposta nulla è il comportamento predefinito, quindi non è necessario implementarla se non fornisci suggerimenti.
Considerazioni sulla progettazione dell'interfaccia utente
In questa sezione vengono descritte alcune considerazioni sulla progettazione dell'interfaccia utente per gli IME.
Gestione di più dimensioni dello schermo
L'interfaccia utente del tuo IME deve essere in grado di adattarsi a diverse dimensioni dello schermo e gestire sia l'orientamento orizzontale che quello verticale. Nella modalità IME non a schermo intero, lascia spazio sufficiente affinché l'applicazione mostri il campo di testo e l'eventuale contesto associato, in modo che l'IME non occupi più della metà dello schermo. Nella modalità IME a schermo intero, non è un problema.
Gestisci 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 è necessario configurare l'IME per verificare se l'utente inserisce un testo valido per il tipo di input. Questa è la responsabilità dell'applicazione proprietario del campo di testo.
Ad esempio, ecco l'interfaccia fornita dall'IME latino per l'input del testo della piattaforma Android:
![Un'immagine che mostra un input di testo su un IME per l'alfabeto latino](https://developer.android.google.cn/static/images/ui/text_input.png?authuser=6&hl=it)
Ecco l'interfaccia fornita dall'IME latino per l'input numerico della piattaforma Android:
![Un'immagine che mostra un input numerico su un IME latino](https://developer.android.google.cn/static/images/ui/numeric_input.png?authuser=6&hl=it)
Quando un campo di immissione è attivo e l'IME viene avviato, il sistema chiama
onStartInputView()
,
passando in un
oggetto EditorInfo
contenente i dettagli sul tipo di input e 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 dei tipi di input. Per verificarlo in base al tipo di input del campo di testo, mascheralo con la costante TYPE_MASK_CLASS
in questo 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 per l'alfabeto 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 numeri di telefono.
TYPE_CLASS_TEXT
- Un campo di testo per inserire i caratteri supportati.
Queste costanti sono descritte in maggiore dettaglio nella documentazione di riferimento per InputType
.
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_TEXT
per l'inserimento delle password. Il metodo di input visualizza dingbats invece del testo effettivo. TYPE_TEXT_VARIATION_URI
- Una variante di
TYPE_CLASS_TEXT
per l'inserimento di URL web e altri URI (Uniform Resource Identifier). TYPE_TEXT_FLAG_AUTO_COMPLETE
- Una variante di
TYPE_CLASS_TEXT
per inserire il testo che l'applicazione completa automaticamente dal dizionario, da una ricerca o da un'altra struttura.
Maschera inputType
con la costante appropriata quando esegui il test per queste varianti. Le
costanti di maschera disponibili sono elencate nella documentazione di riferimento per InputType
.
Invia testo all'applicazione
Mentre l'utente inserisce del testo con il tuo IME, puoi inviare testo all'applicazione inviando singoli 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 inviare il testo. Per ottenere questa istanza, chiama
InputMethodService.getCurrentInputConnection()
.
Modifica il testo attorno al cursore
Quando gestisci la modifica del testo esistente, ecco alcuni metodi utili in BaseInputConnection
:
-
getTextBeforeCursor()
- Restituisci un valore
CharSequence
contenente il numero di caratteri richiesti prima della posizione attuale del cursore. -
getTextAfterCursor()
- Restituisci un
CharSequence
contenente 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()
- Impone un
CharSequence
nel 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 "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);
Supporta la scrittura del testo prima di eseguire il commit
Se l'IME prevede testo o richiede più passaggi per scrivere un glifo o una parola, puoi mostrare l'avanzamento nel campo di testo finché l'utente non esegue il commit della parola, quindi puoi sostituire la composizione parziale con il testo completo. Puoi dare un trattamento speciale al testo aggiungendo un
span quando lo passi a
setComposingText()
.
Lo snippet seguente 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);
Intercetta eventi chiave hardware
Anche se la finestra del metodo di input non ha uno stato attivo esplicito, riceve prima gli eventi chiave hardware e può utilizzarli o inoltrarli all'applicazione. Ad esempio, potresti voler utilizzare le chiavi direzionali per navigare all'interno della tua UI per la selezione dei candidati durante la composizione. Potresti anche voler bloccare il tasto Indietro per ignorare le finestre di dialogo che hanno origine dalla finestra del metodo di inserimento.
Per intercettare le chiavi hardware, esegui l'override di 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 immissione e lingue supportate da un IME. Un sottotipo può rappresentare:
- Un'impostazione internazionale, ad esempio en_US o fr_FR
- Una modalità di immissione, ad esempio vocale, tastiera o scrittura a mano libera
- Altri stili di input, moduli o proprietà specifici dell'IME, ad esempio layout di tastiera a 10 tasti o QWERTY
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 direttamente un sottotipo specifico di IME. Quando crei un IME, utilizza la funzionalità di sottotipo, che consente all'utente di identificare e passare da una lingua e da una modalità IME diverse.
Definisci i sottotipi in uno dei file di risorse XML del metodo di input, utilizzando l'elemento <subtype>
. Il seguente snippet di codice definisce un IME con due sottotipi: un sottotipo di tastiera per l'inglese americano e un altro sottotipo di tastiera per la 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 tuoi sottotipi siano etichettati correttamente nell'interfaccia utente, usa "%s" per ottenere un'etichetta di sottotipo uguale all'etichetta delle impostazioni internazionali del sottotipo. come dimostrato nei prossimi due snippet di codice. Il primo snippet mostra parte del file XML del metodo di input:
<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 input per impostare l'etichetta del sottotipo, è definita come segue:
<string name="label_subtype_generic">%s</string>
Con questa impostazione, il nome visualizzato del sottotipo corrisponde all'impostazione internazionale. Ad esempio, in tutte le impostazioni internazionali dell'inglese, il nome visualizzato è "Inglese (Stati Uniti)".
Scegli sottotipi di IME dalla barra delle notifiche
Il sistema Android gestisce tutti i sottotipi esposti da tutti gli IME. I sottotipi di IME sono considerati modalità dell'IME a cui appartengono. L'utente può accedere dalla barra delle notifiche o dall'app Impostazioni a un menu di sottotipi di IME disponibili, come mostrato nella figura seguente:
![Un'immagine che mostra il menu Lingue e sistema di immissione](https://developer.android.google.cn/static/images/ui/languages_and_input.png?authuser=6&hl=it)
Scegli sottotipi IME da Impostazioni di sistema
L'utente può anche controllare come vengono utilizzati i sottotipi nel riquadro delle impostazioni Lingua e immissione nelle impostazioni di sistema:
![Un'immagine che mostra il menu di selezione delle lingue](https://developer.android.google.cn/static/images/ui/languages.png?authuser=6&hl=it)
Passare da un sottotipi di IME a un altro
Puoi consentire agli utenti di passare facilmente da un sottotipo di IME all'altro fornendo un tasto di passaggio, ad esempio l'icona della lingua a forma di globo sulla tastiera. Ciò migliora l'usabilità della tastiera ed è pratico per l'utente. Per attivare questo passaggio, procedi nel seguente modo:
- Dichiara
supportsSwitchingToNextInputMethod = "true"
nei file di risorse XML del metodo di input. 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 metodo
shouldOfferSwitchingToNextInputMethod()
. - Se il metodo restituisce true, visualizza un tasto per il passaggio.
- Quando l'utente tocca il tasto per il passaggio, chiama
switchToNextInputMethod()
, passando false. Il valore false indica al sistema di trattare tutti i sottotipi in modo uguale, 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:
- 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 le risorse di grandi dimensioni in modo che gli utenti vedano l'IME non appena toccano un campo di testo. Memorizza nella cache le risorse e le viste per le chiamate successive del metodo di input.
- Rilascia allocazioni di memoria elevate subito dopo che la finestra del metodo di input è nascosta, in modo che le applicazioni abbiano memoria sufficiente per l'esecuzione. Utilizza un messaggio in ritardo per rilasciare risorse se l'IME viene nascosto 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, perciò l'IME deve fornire molti caratteri diversi per consentire agli utenti di inserire una password e accedere al dispositivo.