La bibliothèque Support EmojiCompat
vise à maintenir les appareils Android à jour avec les derniers emoji. Elle empêche votre application d'afficher les caractères emoji manquants au format ☐, ce qui indique que votre appareil ne dispose pas d'une police pour afficher le texte. Grâce à la bibliothèque Support EmojiCompat
, les utilisateurs de votre application n'ont pas besoin d'attendre la mise à jour de l'OS Android pour obtenir les derniers emoji.
Consultez les ressources associées suivantes :
Comment fonctionne EmojiCompat ?
La bibliothèque Support EmojiCompat
fournit des classes permettant d'implémenter la prise en charge des emoji rétrocompatibles sur les appareils équipés d'Android 4.4 (niveau d'API 19) ou version ultérieure. Vous pouvez configurer EmojiCompat
avec des polices groupées ou téléchargeables. Pour en savoir plus sur la configuration, consultez les sections suivantes:
EmojiCompat
identifie les emoji pour un élément CharSequence
donné, les remplace par EmojiSpans
si nécessaire, puis affiche les glyphes de l'emoji. La figure 2 illustre ce processus.
Configuration des polices téléchargeables
La configuration des polices téléchargeables utilise la fonctionnalité de bibliothèque Support Fonts téléchargeable pour télécharger une police emoji. Elle met également à jour les métadonnées d'emoji nécessaires dont la bibliothèque Support EmojiCompat
a besoin pour suivre les dernières versions de la spécification Unicode.
Ajouter une dépendance de bibliothèque Support
Pour utiliser la bibliothèque Support EmojiCompat
, vous devez modifier les dépendances classpath de votre projet d'application dans votre environnement de développement.
Pour ajouter une bibliothèque Support à votre projet d'application:
- Ouvrez le fichier
build.gradle
de votre application. - Ajoutez la bibliothèque Support à la section
dependencies
.
Groovy
dependencies { ... implementation "androidx.emoji:emoji:28.0.0" }
Kotlin
dependencies { ... implementation("androidx.emoji:emoji:28.0.0") }
Initialiser la configuration de la police téléchargeable
Vous devez initialiser EmojiCompat
pour charger les métadonnées et la police de caractères. L'initialisation pouvant prendre un certain temps, le processus d'initialisation s'exécute sur un thread d'arrière-plan.
Pour initialiser EmojiCompat
avec la configuration de police téléchargeable, procédez comme suit:
- Créez une instance de la classe
FontRequest
et indiquez l'autorité du fournisseur de polices, le package du fournisseur de polices, la requête de police et une liste d'ensembles de hachages pour le certificat. Pour en savoir plus surFontRequest
, consultez la section Utiliser des polices téléchargeables par programmation dans la documentation Polices téléchargeables. - Créez une instance de
FontRequestEmojiCompatConfig
, puis fournissez des instances deContext
etFontRequest
. - Initialisez
EmojiCompat
en appelant la méthodeinit()
et en transmettant l'instance deFontRequestEmojiCompatConfig
. - Utilisez des widgets
EmojiCompat
dans les fichiers XML de mise en page. Si vous utilisezAppCompat
, reportez-vous à la section Utiliser les widgets EmojiCompat avec AppCompat.
Kotlin
class MyApplication : Application() { override fun onCreate() { super.onCreate() val fontRequest = FontRequest( "com.example.fontprovider", "com.example", "emoji compat Font Query", CERTIFICATES ) val config = FontRequestEmojiCompatConfig(this, fontRequest) EmojiCompat.init(config) } }
Java
public class MyApplication extends Application { @Override public void onCreate() { super.onCreate(); FontRequest fontRequest = new FontRequest( "com.example.fontprovider", "com.example", "emoji compat Font Query", CERTIFICATES); EmojiCompat.Config config = new FontRequestEmojiCompatConfig(this, fontRequest); EmojiCompat.init(config); } }
<android.support.text.emoji.widget.EmojiTextView android:layout_width="wrap_content" android:layout_height="wrap_content"/> <android.support.text.emoji.widget.EmojiEditText android:layout_width="wrap_content" android:layout_height="wrap_content"/> <android.support.text.emoji.widget.EmojiButton android:layout_width="wrap_content" android:layout_height="wrap_content"/>
Pour savoir comment configurer EmojiCompat
avec la configuration de police téléchargeable, consultez l'application exemple de compatibilité des emoji Java
| Kotlin.
Composants de la bibliothèque
- Widgets:
EmojiEditText
,EmojiTextView
,EmojiButton
- Implémentations de widget par défaut pour utiliser
EmojiCompat
avecTextView
,EditText
etButton
. EmojiCompat
- Surface publique principale pour la bibliothèque Support. Il effectue tous les appels externes et se coordonne avec les autres parties du système.
EmojiCompat.Config
- Configure l'instance du singleton à créer.
EmojiSpan
- : sous-classe
ReplacementSpan
qui remplace le caractère (les séquences) et affiche le glyphe. - Police
EmojiCompat
EmojiCompat
utilise une police pour afficher les emoji. Cette police est une version modifiée de la police Emoji Android. La police est modifiée comme suit :- Pour assurer la rétrocompatibilité pour l'affichage des emoji, tous les caractères emoji sont représentés par un seul point de code Unicode dans la zone A complémentaire d'utilisation privée d'Unicode commençant par U+F0001.
-
Les métadonnées d'emoji supplémentaires sont insérées dans la police au format binaire et analysées par
EmojiCompat
au moment de l'exécution. Les données sont intégrées dans la tablemeta
de la police, avec la balise privée Emji.
Options de configuration
Vous pouvez utiliser l'instance EmojiCompat
pour modifier le comportement de EmojiCompat
. Vous pouvez utiliser les méthodes suivantes à partir de la classe de base pour définir la configuration:
setReplaceAll()
: détermine siEmojiCompat
doit remplacer tous les emoji trouvés parEmojiSpans
. Par défaut,EmojiCompat
essaie de comprendre si le système peut afficher un emoji et ne le remplace pas. Lorsque ce paramètre est défini surtrue
,EmojiCompat
remplace tous les emoji trouvés parEmojiSpans
.setEmojiSpanIndicatorEnabled()
: indique siEmojiCompat
a remplacé un emoji par unEmojiSpan
. Lorsque ce paramètre est défini surtrue
,EmojiCompat
dessine un arrière-plan pour l'élémentEmojiSpan
. Cette méthode est principalement utilisée à des fins de débogage.setEmojiSpanIndicatorColor()
: définit la couleur pour indiquer uneEmojiSpan
. La valeur par défaut estGREEN
.registerInitCallback
: informe l'application de l'état d'initialisation deEmojiCompat
.
Kotlin
val config = FontRequestEmojiCompatConfig(...) .setReplaceAll(true) .setEmojiSpanIndicatorEnabled(true) .setEmojiSpanIndicatorColor(Color.GREEN) .registerInitCallback(object: EmojiCompat.InitCallback() { ... })
Java
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 les 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()
. Elle 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
.
- Ajoutez la bibliothèque Support à la section des 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" }
- 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 inclut é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 plusieurs 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 Support à votre projet d'application:
- Ouvrez le fichier
build.gradle
de votre application. - Ajoutez la bibliothèque Support à la section
dependencies
.
Groovy
dependencies { ... implementation "androidx.emoji:emoji:28.0.0" }
Kotlin
dependencies { ... implementation("androidx.emoji:emoji:28.0.0") }
Utiliser des polices groupées pour configurer EmojiCompat
Pour utiliser des polices groupées afin de configurer EmojiCompat
, procédez comme suit:
- Utilisez
BundledEmojiCompatConfig
pour créer une instance deEmojiCompat
et fournir une instance deContext
. - Appelez la méthode
init()
pour initialiserEmojiCompat
et transmettre l'instance deBundledEmojiCompatConfig
.
Kotlin
class MyApplication : Application() { override fun onCreate() { super.onCreate() val config = BundledEmojiCompatConfig(this) EmojiCompat.init(config) } }
Java
public class MyApplication extends Application { @Override public void onCreate() { super.onCreate(); EmojiCompat.Config config = new BundledEmojiCompatConfig(this); EmojiCompat.init(config); ... } }
Utilisation d'EmojiCompat sans widgets
EmojiCompat
utilise EmojiSpan
pour afficher les bonnes images.
Par conséquent, il doit convertir toute valeur CharSequence
donnée en instances Spanned
avec EmojiSpans
. La classe EmojiCompat
fournit une méthode permettant de convertir CharSequences
en instances Spanned
avec EmojiSpans
. Cette méthode vous permet de traiter et de mettre en cache les instances traitées au lieu de la chaîne brute, ce qui améliore les performances de votre application.
Kotlin
val processed = EmojiCompat.get().process("neutral face \uD83D\uDE10")
Java
CharSequence processed = EmojiCompat.get().process("neutral face \uD83D\uDE10");
Utiliser EmojiCompat pour les IME
À l'aide de la bibliothèque Support EmojiCompat
, les claviers peuvent afficher les emoji compatibles avec l'application avec laquelle ils interagissent. Les éditeurs de mode de saisie peuvent utiliser la méthode hasEmojiGlyph()
pour vérifier si EmojiCompat
peut 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 Support EmojiCompat
compatible avec l'application pour déterminer l'emoji à afficher dans la palette. Pour vérifier la version (le cas échéant), le clavier doit vérifier si les touches suivantes existent dans le bundle EditorInfo.extras
:
EDITOR_INFO_METAVERSION_KEY
EDITOR_INFO_REPLACE_ALL_KEY
Si la clé existe dans le bundle, la valeur représente la version des métadonnées des emoji utilisées par l'application. Si cette clé n'existe pas, l'application n'utilise pas EmojiCompat
.
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.
Utilisation d'EmojiCompat avec des widgets personnalisés
Vous pouvez toujours utiliser la méthode process()
pour prétraiter l'élément CharSequence
dans votre application et l'ajouter à n'importe quel widget pouvant afficher les 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 sans effort.
- Exemple de TextView
- Exemple d'EditText
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() { ... } }
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 ?
- Combien de temps faut-il pour s'initialiser ?
- Quelle est la quantité de mémoire utilisée par la bibliothèque Support EmojiCompat ?
- Puis-je utiliser EmojiCompat pour un TextView personnalisé ?
- 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 ?
Les polices emoji sont téléchargées à la première demande, si elles n'existent pas sur l'appareil. La planification des téléchargements est transparente pour l'application.
Une fois la police téléchargée, l'initialisation de EmojiCompat
prend environ 150 millisecondes.
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.
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'assistance de widget, consultez la section Utiliser EmojiCompat avec des widgets personnalisés.
Vous pouvez inclure la bibliothèque Support EmojiCompat
ou ses widgets dans vos applications compatibles avec les appareils équipés d'Android 4.4 (niveau d'API 19) ou version antérieure. Toutefois, si un appareil s'exécute sur 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.
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.