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

Le classi EmojiCompat e EmojiCompat forniscono i metodi registerInitCallback() e unregisterInitCallback() per registrare un callback di inizializzazione. Per utilizzare questi metodi, crea un'istanza della classe EmojiCompat.InitCallback. Richiama questi metodi e passa l'istanza della classe EmojiCompat.InitCallback. Se l'inizializzazione della libreria di assistenza EmojiCompat ha esito positivo, la classe EmojiCompat chiama il metodo onInitialized(). Se la libreria non viene inizializzata, 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 usi AppCompat widgets, puoi usare i widget EmojiCompat che si 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. 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 dei caratteri in bundle. Questo pacchetto include il carattere con i metadati incorporati. Il pacchetto include anche un elemento BundledEmojiCompatConfig che utilizza AssetManager per caricare metadati e caratteri.

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

Aggiunta della dipendenza dalla libreria di supporto

Per utilizzare la libreria di supporto EmojiCompat con la configurazione dei caratteri in bundle, devi modificare le dipendenze classpath del progetto dell'app all'interno dell'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 raggruppati per configurare EmojiCompat, svolgi i seguenti 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 passare 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 delle immagini corrette. Di conseguenza, deve convertire ogni dato CharSequence in Spanned istanza 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, migliorando 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 l'emoji supportata dall'applicazione con cui stanno interagendo. Gli IME possono utilizzare il metodo hasEmojiGlyph() per verificare se EmojiCompat è in grado di visualizzare 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 libreria di supporto EmojiCompat supportata dall'app per determinare quale emoji visualizzare nella tavolozza. Per verificare la versione, se disponibile, la tastiera deve controllare se i seguenti tasti esistono nel bundle EditorInfo.extras:

• EDITOR_INFO_METAVERSION_KEY

Se la chiave esiste nel bundle, il valore rappresenta la versione dei metadati delle emoji utilizzate 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, questo 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 i tasti 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.

Utilizzare EmojiCompat con widget personalizzati

Puoi sempre utilizzare il metodo process() per pre-elaborare CharSequence nella tua app e aggiungerlo a qualsiasi widget in grado di visualizzare le istanze Spanned, ad esempio TextView. Inoltre, EmojiCompat fornisce le seguenti classi helper per i widget per consentirti di arricchire i tuoi widget personalizzati con il supporto delle emoji con 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 sono presenti sul dispositivo. La pianificazione dei download è trasparente per l'app.

• Quanto tempo richiede l'inizializzazione?

Una volta 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 viene caricata nella memoria dell'app e utilizza circa 200 kB.

• Posso utilizzare EmojiCompat per una visualizzazione di testo personalizzata?

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

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

Puoi includere la libreria di supporto EmojiCompat 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 viene eseguito su una versione di Android precedente al livello API 19, EmojiCompat e i suoi widget sono in "nessuna operazione". Ciò significa che EmojiTextView si comporta esattamente come un normale TextView. EmojiCompat; passa immediatamente allo stato LOAD_STATE_SUCCEEDED quando chiami il metodo init().

Risorse aggiuntive

Per ulteriori informazioni sull'uso della raccolta EmojiCompat, guarda EmojiCompat.