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 listener di inizializzazione

EmojiCompat e EmojiCompat corso fornire registerInitCallback() e unregisterInitCallback() per registrare un callback di inizializzazione. Per utilizzare questi metodi, crea un'istanza EmojiCompat.InitCallback corso. Chiama questi metodi e passare l'istanza EmojiCompat.InitCallback corso. Quando inizializzazione del supporto EmojiCompat che ha successo, EmojiCompat chiama onInitialized() . Se la libreria non viene inizializzato, EmojiCompat chiama onFailed() .

Per controllare lo stato di inizializzazione in qualsiasi momento, richiama 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, possono usare EmojiCompat widget che estendono da AppCompat widgets.

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

   Alla moda

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

   Kotlin

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

   Alla moda

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

2. Usa EmojiCompat Widget AppCompat Widget nel layout XML.

<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

È disponibile anche la libreria di assistenza EmojiCompat disponibili in una versione integrata dei caratteri. Questo pacchetto include il font con metadati incorporati. Il pacchetto include anche BundledEmojiCompatConfig che utilizza AssetManager per caricare i metadati e i caratteri.

Nota: le dimensioni del carattere possono essere megabyte.

Aggiunta della dipendenza dalla libreria di supporto

Per utilizzare la libreria di assistenza EmojiCompat con la configurazione dei caratteri in bundle, devi modificare il codice delle dipendenze classpath 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")
}

Utilizzare i caratteri raggruppati per configurare EmojiCompat

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

1. Usa BundledEmojiCompatConfig per creare un'istanza di EmojiCompat e fornire un'istanza di Context.
2. Chiama il init() di inizializzazione EmojiCompat e passiamo l'istanza 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 usi EmojiSpan per eseguire il rendering delle immagini corrette. Di conseguenza, deve convertire ogni dato CharSequence in Spanned istanze con EmojiSpans. La La classe EmojiCompat fornisce un metodo per converti CharSequences in Spanned istanze con EmojiSpans. Utilizzando questo metodo, puoi elaborare e memorizzare nella cache le istanze elaborate anziché la stringa non elaborata, migliorando così le prestazioni della tua 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

Tramite la libreria di assistenza di EmojiCompat, le tastiere possono mostrare l'emoji supportata dall'applicazione che stanno a interagire con loro. Gli IME possono utilizzare hasEmojiGlyph() per verificare se EmojiCompat è in grado di rendering di un'emoji. Questo metodo richiede un valore CharSequence un'emoji e restituisce true se EmojiCompat può rilevare e visualizzare emoji.

La tastiera può anche controllare la versione EmojiCompat supporta la raccolta che l'app consente di stabilire quali emoji visualizzare nella tavolozza. Per controllare dell'app, se disponibile, la tastiera deve controllare se quanto segue esistono EditorInfo.extras gruppo:

• EDITOR_INFO_METAVERSION_KEY

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

• EDITOR_INFO_REPLACE_ALL_KEY

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

Dopo aver ricevuto i tasti nella EditorInfo.extras cofanetto, la tastiera può utilizzare hasEmojiGlyph() dove metadataVersion è il valore per EDITOR_INFO_METAVERSION_KEY, per verificare se l'app può visualizzare un'emoji specifica.

Utilizzare EmojiCompat con widget personalizzati

Puoi sempre usare l'process() per pre-elaborare CharSequence nella tua app e aggiungere a qualsiasi widget in grado di eseguire il rendering di istanze Spanned; della esempio, TextView. Inoltre, EmojiCompat fornisce il seguente widget per arricchire i tuoi widget personalizzati con il supporto delle emoji il minimo sforzo.

• EmojiTextViewHelper
• EmojiEditTextHelper

Visualizzazione di testo 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 si avvia il download del carattere?

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

• Quanto tempo richiede l'inizializzazione? .

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

• Quanta memoria supporta la libreria EmojiCompat?

Al momento, la struttura dei dati per trovare l'emoji è caricata nell'app memoria e utilizza circa 200 kB.

• Posso utilizzare EmojiCompat per una visualizzazione di testo personalizzata?

Sì. EmojiCompat fornisce classi di supporto per widget personalizzati. È inoltre possibile possibile pre-elaborare una determinata stringa e convertirla in Spanned. Per ulteriori informazioni sull'helper per i widget consulta le Utilizzare EmojiCompat con i widget personalizzati .

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

Puoi includere EmojiCompat supportano la libreria o i relativi widget nelle applicazioni che supportano i dispositivi con Android 4.4 (livello API 19) o versioni precedenti. Tuttavia, se un dispositivo esegue su una versione di Android precedente al livello API 19, EmojiCompat e i suoi widget si trovano in un "nessuna operazione" stato. Ciò significa che Il comportamento di EmojiTextView è esatto come un normale TextView. EmojiCompat istanza; immediatamente entra in un LOAD_STATE_SUCCEEDED lo stato desiderato quando richiami init() .

Risorse aggiuntive

Per ulteriori informazioni sull'uso del EmojiCompat nella raccolta, guarda EmojiCompat.