Compatibilità con emoji

val config = FontRequestEmojiCompatConfig(...)
        .setReplaceAll(true)
        .setEmojiSpanIndicatorEnabled(true)
        .setEmojiSpanIndicatorColor(Color.GREEN)
        .registerInitCallback(object: EmojiCompat.InitCallback() {
            ...
        })

EmojiCompat.Config config = new FontRequestEmojiCompatConfig(...)
       .setReplaceAll(true)
       .setEmojiSpanIndicatorEnabled(true)
       .setEmojiSpanIndicatorColor(Color.GREEN)
       .registerInitCallback(new InitCallback() {...})

Aggiunta di ascoltatori di inizializzazione

Le classi EmojiCompat e EmojiCompat forniscono metodi registerInitCallback() e unregisterInitCallback() per registrare un callback di inizializzazione. Per utilizzare questi metodi, crea un'istanza della classe EmojiCompat.InitCallback. Chiama questi metodi e passa l'istanza della classe EmojiCompat.InitCallback. Quando l'inizializzazione della libreria di supporto EmojiCompat è andata a buon fine, la classe EmojiCompat chiama il metodo onInitialized(). Se l'inizializzazione della libreria non va a buon fine, la classe EmojiCompat chiama il metodo onFailed().

Per controllare lo stato di inizializzazione in qualsiasi momento, chiama il metodo getLoadState(). Restituisce uno dei seguenti valori: LOAD_STATE_LOADING, LOAD_STATE_SUCCEEDED o LOAD_STATE_FAILED.

Utilizzare EmojiCompat con i widget AppCompat

Se utilizzi AppCompat widgets, puoi utilizzare i widget EmojiCompat che si estendono da AppCompat widgets.

1. Aggiungi la libreria di supporto alla sezione delle dipendenze.

   Groovy

   dependencies {
       ...
       implementation "androidx.emoji:emoji-bundled:$version"
   }
   

   Kotlin

         dependencies {
             implementation("androidx.emoji:emoji-appcompat:$version")
         }
         

   Groovy

         dependencies {
             implementation "androidx.emoji:emoji-appcompat:$version"
         }
         

2. Utilizza i widget EmojiCompat AppCompat Widget nei file XML di layout.

<android.support.text.emoji.widget.EmojiAppCompatTextView
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

<android.support.text.emoji.widget.EmojiAppCompatEditText
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

<android.support.text.emoji.widget.EmojiAppCompatButton
   android:layout_width="wrap_content"
   android:layout_height="wrap_content"/>

Configurazione dei caratteri in bundle

La libreria di supporto EmojiCompat è disponibile anche in una versione del carattere in bundle. Questo pacchetto include il carattere con i metadati incorporati. Il pacchetto include anche un BundledEmojiCompatConfig che utilizza AssetManager per caricare i metadati e i caratteri.

Nota: le dimensioni del carattere sono espresse in più megabyte.

Aggiunta della dipendenza dalla libreria di supporto

Per utilizzare la EmojiCompat libreria di supporto con la configurazione dei caratteri in bundle, devi modificare le dipendenze del percorso di classe del progetto dell'app nell'ambiente di sviluppo.

Per aggiungere una libreria di supporto al progetto dell'applicazione:

1. Apri il file build.gradle della tua applicazione.
2. Aggiungi la libreria di supporto alla sezione dependencies.

dependencies {
    ...
    implementation "androidx.emoji:emoji:28.0.0"
}

dependencies {
    ...
    implementation("androidx.emoji:emoji:28.0.0")
}

Utilizzo dei caratteri in bundle per configurare EmojiCompat

Per utilizzare i caratteri in bundle per configurare EmojiCompat, segui questi passaggi:

1. Utilizza BundledEmojiCompatConfig per creare un'istanza di EmojiCompat e fornire un'istanza di Context.
2. Chiama il metodo init() per inizializzare EmojiCompat e passa l'istanza di BundledEmojiCompatConfig.

class MyApplication : Application() {

    override fun onCreate() {
        super.onCreate()
        val config = BundledEmojiCompatConfig(this)
        EmojiCompat.init(config)
    }
}

public class MyApplication extends Application {
    @Override
    public void onCreate() {
        super.onCreate();
        EmojiCompat.Config config = new BundledEmojiCompatConfig(this);
        EmojiCompat.init(config);
        ...
    }
}

Utilizzare EmojiCompat senza widget

EmojiCompat utilizza EmojiSpan per eseguire il rendering di immagini corrette. Pertanto, deve convertire qualsiasi CharSequence in istanze Spanned con EmojiSpans. La classe EmojiCompat fornisce un metodo per convertire CharSequences in istanze Spanned con EmojiSpans. Con questo metodo, puoi elaborare e memorizzare nella cache le istanze elaborate anziché la stringa non elaborata, il che migliora le prestazioni dell'applicazione.

val processed = EmojiCompat.get().process("neutral face \uD83D\uDE10")

CharSequence processed = EmojiCompat.get().process("neutral face \uD83D\uDE10");

Utilizzo di EmojiCompat per gli IME

Utilizzando la libreria di supporto EmojiCompat, le tastiere possono visualizzare le emoji supportate dall'applicazione con cui interagiscono. Gli IME possono utilizzare il metodo hasEmojiGlyph() per verificare se EmojiCompat è in grado di eseguire il rendering di un'emoji. Questo metodo prende un CharSequence di un'emoji e restituisce true se EmojiCompat può rilevare e visualizzare l'emoji.

La tastiera può anche controllare la versione della biblioteca di supporto EmojiCompat supportata dall'app per determinare quali emoji visualizzare nella tavolozza. Per controllare la versione, se disponibile, la tastiera deve verificare se le seguenti chiavi esistono nel EditorInfo.extras bundle:

• EDITOR_INFO_METAVERSION_KEY

Se la chiave esiste nel bundle, il valore rappresenta la versione dei metadati delle emoji utilizzata dall'app. Se questa chiave non esiste, l'app non utilizza EmojiCompat.

• EDITOR_INFO_REPLACE_ALL_KEY

Se la chiave esiste ed è impostata su true, indica che l'app ha chiamato il metodo SetReplaceAll(). Per ulteriori informazioni sulla configurazione di EmojiCompat, consulta la sezione Opzioni di configurazione.

Dopo aver ricevuto le chiavi nel bundle EditorInfo.extras, la tastiera può utilizzare il metodo hasEmojiGlyph(), dove metadataVersion è il valore di EDITOR_INFO_METAVERSION_KEY, per verificare se l'app può visualizzare un'emoji specifica.

Utilizzo di EmojiCompat con widget personalizzati

Puoi sempre utilizzare il metodo process() per eseguire la preelaborazione del CharSequence nella tua app e aggiungerlo ad qualsiasi widget in grado di eseguire il rendering di istanze Spanned, ad esempioTextView. Inoltre, EmojiCompat fornisce le seguenti classi di helper per i widget per consentirti di arricchire i widget personalizzati con il supporto delle emoji con minimo sforzo.

• EmojiTextViewHelper
• EmojiEditTextHelper

TextView di esempio

Kotlin

class MyTextView(context: Context) : AppCompatTextView(context) {

    private val emojiTextViewHelper: EmojiTextViewHelper by lazy(LazyThreadSafetyMode.NONE) {
        EmojiTextViewHelper(this).apply {
            updateTransformationMethod()
        }
    }

    override fun setFilters(filters: Array<InputFilter>) {
        super.setFilters(emojiTextViewHelper.getFilters(filters))
    }

    override fun setAllCaps(allCaps: Boolean) {
        super.setAllCaps(allCaps)
        emojiTextViewHelper.setAllCaps(allCaps)
    }
}

Java

public class MyTextView extends AppCompatTextView {
   ...
   public MyTextView(Context context) {
       super(context);
       init();
   }
   ...
   private void init() {
       getEmojiTextViewHelper().updateTransformationMethod();
   }

   @Override
   public void setFilters(InputFilter[] filters) {
       super.setFilters(getEmojiTextViewHelper().getFilters(filters));
   }

   @Override
   public void setAllCaps(boolean allCaps) {
       super.setAllCaps(allCaps);
       getEmojiTextViewHelper().setAllCaps(allCaps);
   }

   private EmojiTextViewHelper getEmojiTextViewHelper() {
       ...
   }
}

EditText di esempio

Kotlin

class MyEditText(context: Context) : AppCompatEditText(context) {

    private val emojiEditTextHelper: EmojiEditTextHelper by lazy(LazyThreadSafetyMode.NONE) {
        EmojiEditTextHelper(this).also {
            super.setKeyListener(it.getKeyListener(keyListener))
        }
    }

    override fun setKeyListener(input: KeyListener?) {
        input?.also {
            super.setKeyListener(emojiEditTextHelper.getKeyListener(it))
        }
    }

    override fun onCreateInputConnection(outAttrs: EditorInfo): InputConnection {
        val inputConnection: InputConnection = super.onCreateInputConnection(outAttrs)
        return emojiEditTextHelper.onCreateInputConnection(
                inputConnection,
                outAttrs
        ) as InputConnection
    }
}

Java

public class MyEditText extends AppCompatEditText {
   ...
   public MyEditText(Context context) {
       super(context);
       init();
   }
   ...
   private void init() {
       super.setKeyListener(getEmojiEditTextHelper().getKeyListener(getKeyListener()));
   }

   @Override
   public void setKeyListener(android.text.method.KeyListener keyListener) {
       super.setKeyListener(getEmojiEditTextHelper().getKeyListener(keyListener));
   }

   @Override
   public InputConnection onCreateInputConnection(EditorInfo outAttrs) {
       InputConnection inputConnection = super.onCreateInputConnection(outAttrs);
       return getEmojiEditTextHelper().onCreateInputConnection(inputConnection, outAttrs);
   }

   private EmojiEditTextHelper getEmojiEditTextHelper() {
       ...
   }
}

Domande frequenti

• Come faccio ad avviare il download dei caratteri?

I caratteri emoji vengono scaricati alla prima richiesta, se non esistono sul dispositivo. La pianificazione dei download è trasparente per l'app.

• Quanto tempo è necessario per l'inizializzazione?

Dopo aver scaricato il carattere, sono necessari circa 150 millisecondi per inizializzare EmojiCompat.

• Quanta memoria utilizza la libreria di supporto EmojiCompat?

Attualmente, la struttura di dati per trovare l'emoji viene caricata nella memoria dell'app e utilizza circa 200 KB.

• Posso utilizzare EmojiCompat per un TextView personalizzato?

Sì. EmojiCompat fornisce classi di assistenza per i widget personalizzati. È anche possibile eseguire la preelaborazione di una determinata stringa e convertirla in Spanned. Per ulteriori informazioni sulle classi di helper per i widget, consulta la sezione Utilizzare EmojiCompat con i widget personalizzati.

• Cosa succede se aggiungo widget nei file XML di layout su dispositivi che girano su Android 4.4 (livello API 19) o versioni precedenti?

Puoi includere la EmojiCompat libreria di supporto o i relativi widget nelle tue applicazioni che supportano i dispositivi con Android 4.4 (livello API 19) o versioni precedenti. Tuttavia, se un dispositivo funziona su una versione di Android precedente al livello API 19, EmojiCompat e i relativi widget sono in stato "Nessuna operazione". Ciò significa che EmojiTextView si comporta esattamente come un normale TextView. EmojiCompat. Immediatamente assume uno stato LOAD_STATE_SUCCEEDED quando chiami il metodo init().

Risorse aggiuntive

Per ulteriori informazioni sull'utilizzo della libreria EmojiCompat, guarda EmojiCompat.