Compatibilité avec les 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() {...})

Ajouter des écouteurs d'initialisation

Les classes EmojiCompat et EmojiCompat fournissent des méthodes registerInitCallback() et unregisterInitCallback() pour enregistrer un rappel d'initialisation. Pour utiliser ces méthodes, créez une instance de la classe EmojiCompat.InitCallback. Appelez ces méthodes et transmettez l'instance de la classe EmojiCompat.InitCallback. Lorsque l'initialisation de la bibliothèque Support EmojiCompat aboutit, la classe EmojiCompat appelle la méthode onInitialized(). Si l'initialisation de la bibliothèque échoue, la classe EmojiCompat appelle la méthode onFailed().

Pour vérifier l'état d'initialisation à tout moment, appelez la méthode getLoadState(). Il renvoie l'une des valeurs suivantes : LOAD_STATE_LOADING, LOAD_STATE_SUCCEEDED ou LOAD_STATE_FAILED.

Utiliser EmojiCompat avec les widgets AppCompat

Si vous utilisez AppCompat widgets, vous pouvez utiliser des widgets EmojiCompat qui s'étendent à partir de AppCompat widgets.

1. Ajoutez la bibliothèque d'assistance à la section "Dépendances".

   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. Utilisez des widgets EmojiCompat AppCompat Widget dans les fichiers XML de mise en page.

<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"/>

Configuration des polices groupées

La bibliothèque Support EmojiCompat est également disponible dans une version de police groupée. Ce package inclut la police avec les métadonnées intégrées. Le package comprend également un BundledEmojiCompatConfig qui utilise AssetManager pour charger les métadonnées et les polices.

Remarque:La taille de la police est exprimée en mégaoctets.

Ajouter une dépendance de bibliothèque Support

Pour utiliser la bibliothèque Support EmojiCompat avec une configuration de police groupée, vous devez modifier les dépendances de chemin de classe de votre projet d'application dans votre environnement de développement.

Pour ajouter une bibliothèque d'assistance à votre projet d'application:

1. Ouvrez le fichier build.gradle de votre application.
2. Ajoutez la bibliothèque d'assistance à la section dependencies.

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

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

Utiliser des polices groupées pour configurer EmojiCompat

Pour utiliser des polices groupées pour configurer EmojiCompat, procédez comme suit:

1. Utilisez BundledEmojiCompatConfig pour créer une instance de EmojiCompat et fournir une instance de Context.
2. Appelez la méthode init() pour initialiser EmojiCompat et transmettre l'instance de 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);
        ...
    }
}

Utiliser EmojiCompat sans widgets

EmojiCompat utilise EmojiSpan pour afficher les bonnes images. Par conséquent, il doit convertir tout CharSequence donné en instances Spanned avec EmojiSpans. La classe EmojiCompat fournit une méthode permettant de convertir CharSequences en instances Spanned avec EmojiSpans. Grâce à cette méthode, vous pouvez traiter et mettre en cache les instances traitées au lieu de la chaîne brute, ce qui améliore les performances de votre application.

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

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

Utiliser EmojiCompat pour les IME

À l'aide de la bibliothèque d'assistance EmojiCompat, les claviers peuvent afficher les emoji compatibles avec l'application avec laquelle ils interagissent. Les IME peuvent utiliser la méthode hasEmojiGlyph() pour vérifier si EmojiCompat est capable d'afficher un emoji. Cette méthode utilise l'CharSequence d'un emoji et renvoie true si EmojiCompat peut détecter et afficher l'emoji.

Le clavier peut également vérifier la version de la bibliothèque d'assistance EmojiCompat compatible avec l'application pour déterminer les emoji à afficher dans la palette. Pour vérifier la version, le clavier doit vérifier si les clés suivantes existent dans le bundle EditorInfo.extras:

• EDITOR_INFO_METAVERSION_KEY

Si la clé existe dans le bundle, la valeur représente la version des métadonnées d'emoji que l'application utilise. Si cette clé n'existe pas, l'application n'utilise pas EmojiCompat.

• EDITOR_INFO_REPLACE_ALL_KEY

Si la clé existe et qu'elle est définie sur true, cela signifie que l'application a appelé la méthode SetReplaceAll(). Pour en savoir plus sur la configuration de EmojiCompat, consultez la section Options de configuration.

Après avoir reçu les touches du bundle EditorInfo.extras, le clavier peut utiliser la méthode hasEmojiGlyph(), où metadataVersion est la valeur de EDITOR_INFO_METAVERSION_KEY, pour vérifier si l'application peut afficher un emoji spécifique.

Utiliser EmojiCompat avec des widgets personnalisés

Vous pouvez toujours utiliser la méthode process() pour prétraiter le CharSequence dans votre application et l'ajouter à n'importe quel widget pouvant afficher des instances Spanned, par exemple TextView. De plus, EmojiCompat fournit les classes d'assistance de widget suivantes pour vous permettre d'enrichir vos widgets personnalisés avec la prise en charge des emoji avec un minimum d'effort.

• EmojiTextViewHelper
• EmojiEditTextHelper

Exemple de TextView

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() {
       ...
   }
}

Exemple d'EditText

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() {
       ...
   }
}

Questions fréquentes

• Comment lancer le téléchargement de la police ?

Les polices d'emoji sont téléchargées à la première requête, si elles n'existent pas sur l'appareil. La planification des téléchargements est transparente pour l'application.

• Combien de temps faut-il pour l'initialiser ?

Une fois la police téléchargée, l'initialisation de EmojiCompat prend environ 150 millisecondes.

• Combien de mémoire la bibliothèque d'assistance EmojiCompat utilise-t-elle ?

Actuellement, la structure de données permettant de trouver l'emoji est chargée dans la mémoire de l'application et utilise environ 200 ko.

• Puis-je utiliser EmojiCompat pour un TextView personnalisé ?

Oui. EmojiCompat fournit des classes d'assistance pour les widgets personnalisés. Il est également possible de prétraiter une chaîne donnée et de la convertir en Spanned. Pour en savoir plus sur les classes d'aide des widgets, consultez la section Utiliser EmojiCompat avec des widgets personnalisés.

• Que se passe-t-il si j'ajoute des widgets dans des fichiers XML de mise en page sur des appareils équipés d'Android 4.4 (niveau d'API 19) ou version antérieure ?

Vous pouvez inclure la bibliothèque d'assistance EmojiCompat ou ses widgets dans vos applications compatibles avec les appareils exécutant Android 4.4 (niveau d'API 19) ou version antérieure. Toutefois, si un appareil exécute une version d'Android antérieure au niveau d'API 19, EmojiCompat et ses widgets sont à l'état "aucune opération". Cela signifie que EmojiTextView se comporte exactement comme un TextView standard. instance EmojiCompat. Elle passe immédiatement à l'état LOAD_STATE_SUCCEEDED lorsque vous appelez la méthode init().

Ressources supplémentaires

Pour en savoir plus sur l'utilisation de la bibliothèque EmojiCompat, regardez EmojiCompat.