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

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.

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

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

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.

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

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.