Compatibilité avec les emoji

Attention:Depuis fin 2021, les androidx.emoji:emoji est obsolète et a été remplacé par androidx.emoji2:emoji2, qui permet une intégration dans androidx.appcompat.

Pour prendre en charge les emoji modernes et simplifier la rétrocompatibilité avec les emoji inférieurs d'Android, nous vous recommandons de migrer vers androidx.emoji2:emoji2 bibliothèque. Pour en savoir plus sur l'implémentation, consultez Assurer la compatibilité avec les emoji modernes.

La bibliothèque Support EmojiCompat vise à maintenir les appareils Android à jour avec les derniers emoji. Cela empêche votre application d'afficher les caractères emoji manquants : ☐, ce qui indique que votre appareil ne dispose pas d'une police pour afficher le texte. Par à l'aide de la bibliothèque Support EmojiCompat ; les utilisateurs de votre application n'ont pas besoin d'attendre la mise à jour de l'OS Android emoji.

Figure 1. Comparaison des emoji

Consultez les ressources associées suivantes :

• Exemple d'application de compatibilité avec les emoji <ph type="x-smartling-placeholder"></ph> Java | Kotlin

Comment fonctionne EmojiCompat ?

La bibliothèque Support EmojiCompat fournit pour implémenter la prise en charge des emoji rétrocompatibles sur les appareils exécutant Android 4.4 (niveau d'API 19) ou version ultérieure Vous pouvez configurer EmojiCompat avec des données groupées ou des polices téléchargeables. Pour en savoir plus sur la configuration, consultez les sections suivantes:

• Configuration des polices téléchargeables
• Configuration des polices groupées

EmojiCompat identifie l'emoji d'un élément donné CharSequence, les remplace par EmojiSpans, si nécessaire, et affiche enfin les glyphes emoji. La figure 2 illustre ce processus.

Figure 2. Processus EmojiCompat

Configuration des polices téléchargeables

La configuration des polices téléchargeables utilise la compatibilité avec les polices téléchargeables bibliothèque pour télécharger une police emoji. Il met également à jour métadonnées d'emoji que EmojiCompat doit disposer des dernières versions d'Unicode spécifique.

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 développement d'applications.

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

1. Ouvrez le fichier build.gradle de votre application.
2. 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 police téléchargeable configuration

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 en arrière-plan.

Pour initialiser EmojiCompat avec le configuration de police téléchargeable, procédez comme suit:

1. Créer une instance de FontRequest et fournissez 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 plus plus d'informations sur FontRequest, reportez-vous vers Utiliser des polices téléchargeables par programmation de la section Polices téléchargeables dans la documentation Google Cloud.
2. Créer une instance de FontRequestEmojiCompatConfig et fournir des instances de Context et FontRequest
3. Initialisez EmojiCompat en appelant la méthode init() et transmettre l'instance de FontRequestEmojiCompatConfig

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);
   }
}

4. Utiliser des widgets EmojiCompat dans la mise en page XML Si vous utilisez AppCompat, reportez-vous au Utiliser les widgets EmojiCompat avec AppCompat .

<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 en savoir plus sur la configuration EmojiCompat par la police téléchargeable. configuration, accédez à l'application exemple de compatibilité des emoji Java | Kotlin

Composants de la bibliothèque

Figure 3. Composants de la bibliothèque dans le processus EmojiCompat

<ph type="x-smartling-placeholder">

</ph>

Widgets: EmojiEditText, EmojiTextView, EmojiButton

Implémentations de widget par défaut à utiliser EmojiCompat avec TextView, EditText et Button

EmojiCompat

Surface publique principale pour la bibliothèque Support. Il effectue toutes les 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 les (séquences) et affiche le glyphe.

Police EmojiCompat

EmojiCompat utilise une police pour afficher emoji. Cette police est une version modifiée du Police des emoji Android. La police est modifiée comme suit: <ph type="x-smartling-placeholder">

</ph>
• Pour assurer la rétrocompatibilité afin d'afficher les emoji, tous les emoji les caractères sont représentés par un seul point de code Unicode Supplemental Private Use Area-A d'Unicode à partir de U+F0001.
• Les métadonnées d'emoji supplémentaires sont insérées dans un format binaire dans la police et est analysé au moment de l'exécution EmojiCompat Les données sont intégrées dans le tableau meta 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 si EmojiCompat doit remplacer tous les emoji qu'il trouve par EmojiSpans Par défaut, EmojiCompat fait de son mieux déterminer si le système peut afficher un emoji et ne le remplace pas emoji. Si défini sur true, EmojiCompat remplace tous les emoji trouvés avec EmojiSpans.
• setEmojiSpanIndicatorEnabled(): indique si EmojiCompat a remplacé un emoji par une EmojiSpan Si défini sur true, EmojiCompat dessine un arrière-plan pour EmojiSpan Cette méthode est principalement utilisée à des fins de débogage.
• setEmojiSpanIndicatorColor(): Définit la couleur pour indiquer une EmojiSpan. La valeur par défaut est GREEN.
• registerInitCallback: Informe l'application de l'état de la Initialisation de EmojiCompat.

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

EmojiCompat et EmojiCompat cours fournir registerInitCallback() et unregisterInitCallback() pour enregistrer un rappel d'initialisation. Pour utiliser ces méthodes, créez une instance de EmojiCompat.InitCallback. Appeler ces méthodes et transmettre l'instance EmojiCompat.InitCallback. Lorsque Initialisation de la compatibilité avec EmojiCompat bibliothèque est réussie, la EmojiCompat appelle la classe onInitialized() . Si la bibliothèque lors de l'échec de l'initialisation, EmojiCompat appelle la classe 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 peut utiliser des widgets EmojiCompat qui étendent de AppCompat widgets.

1. 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"
         }
         

2. Utiliser EmojiCompat Widgets AppCompat Widget dans la mise en page 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"/>

Configuration des polices groupées

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

Remarque:La taille de la police est définie en plusieurs mégaoctets.

Ajouter une dépendance de bibliothèque Support

Pour utiliser la bibliothèque Support EmojiCompat avec une configuration de police intégrée, vous devez modifier le fichier les dépendances classpath dans votre environnement de développement.

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

1. Ouvrez le fichier build.gradle de votre application.
2. 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 pour configurer EmojiCompat, procédez comme suit:

1. Utiliser 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

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 utilisations EmojiSpan pour afficher les bonnes images. Par conséquent, il doit convertir n'importe quelle CharSequence donnée en Spanned instances avec EmojiSpans La La classe EmojiCompat fournit une méthode pour convertir CharSequences en Spanned instances avec EmojiSpans Avec 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.

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

Avec la bibliothèque Support EmojiCompat, les claviers peuvent afficher les emoji compatibles avec l'application qu'ils avec lesquelles vous souhaitez interagir. Les éditeurs de mode de saisie peuvent utiliser hasEmojiGlyph() pour vérifier si EmojiCompat est compatible du rendu d'un emoji. Cette méthode prend un CharSequence de un emoji et renvoie true si EmojiCompat peut détecter et afficher emoji.

Le clavier peut également vérifier la version EmojiCompat Support que l'application pour déterminer l'emoji à afficher dans la palette. Pour vérifier version, si elle est disponible, le clavier doit vérifier si les éléments suivants clés existent dans EditorInfo.extras bundle:

• EDITOR_INFO_METAVERSION_KEY

Si la clé existe dans le bundle, cette valeur représente le des métadonnées de l'emoji que l'application utilise. Si cette clé n'est pas existe, 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é SetReplaceAll() . Pour en savoir plus sur Configuration EmojiCompat, reportez-vous à la section Options de configuration .

Après avoir reçu les clés dans Lot EditorInfo.extras, le clavier peut utiliser les 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 le process() pour prétraiter CharSequence dans votre application et ajouter à n'importe quel widget pouvant afficher les instances Spanned. pour exemple : TextView. De plus, EmojiCompat fournit le widget suivant pour vous permettre d'enrichir vos widgets personnalisés en prenant en charge les emoji avec avec un minimum d'efforts.

• 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 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.

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

Une fois la police téléchargée, le processus prend environ 150 millisecondes pour initialiser EmojiCompat.

• Quelle est la quantité de mémoire utilisée par la bibliothèque Support EmojiCompat ?

Actuellement, la structure de données permettant de trouver l'emoji est chargée dans le 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 de prétraiter une chaîne donnée et de la convertir en Spanned Pour en savoir plus sur l'outil d'aide de widget les classes, consultez la 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 exécuté sur Android 4.4 (niveau d'API 19) ou version antérieure ?

Vous pouvez inclure le EmojiCompat ou ses widgets dans les applications compatibles avec les appareils équipés d'Android 4.4 (niveau d'API 19) ou version antérieure. Toutefois, si un appareil exécute sur une version d'Android antérieure au niveau d'API 19, EmojiCompat et ses widgets se trouvent dans un "aucune opération" de l'état. Cela signifie que EmojiTextView se comporte exactement comme une TextView standard. EmojiCompat instance; immédiatement entre LOAD_STATE_SUCCEEDED lorsque vous appelez la fonction init() .

Ressources supplémentaires

Pour en savoir plus sur l'utilisation du EmojiCompat dans votre bibliothèque, regardez EmojiCompat.