Emoji Compatibility

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

Adding initialization listeners

EmojiCompat and EmojiCompat classes provide registerInitCallback() and unregisterInitCallback() methods to register an initialization callback. To use these methods, create an instance of the EmojiCompat.InitCallback class. Call these methods and pass the instance of the EmojiCompat.InitCallback class. When the initialization of the EmojiCompat support library is successful, the EmojiCompat class calls the onInitialized() method. If the library fails to initialize, the EmojiCompat class calls the onFailed() method.

To check the initialization state at any point, call the getLoadState() method. It returns one of the following values: LOAD_STATE_LOADING, LOAD_STATE_SUCCEEDED, or LOAD_STATE_FAILED.

Using EmojiCompat with AppCompat widgets

If you are using AppCompat widgets, you can use EmojiCompat widgets that extend from AppCompat widgets.

1. Add the support library to the dependencies section.

   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. Use EmojiCompat AppCompat Widget widgets in layout XMLs.

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

Bundled fonts configuration

The EmojiCompat support library is also available in a bundled font version. This package includes the font with the embedded metadata. The package also includes a BundledEmojiCompatConfig that uses the AssetManager to load the metadata and fonts.

Note: The size of the font is in multiple megabytes.

Adding support library dependency

To use the EmojiCompat support library with bundled font configuration, you must modify your app project's classpath dependencies within your development environment.

To add a support library to your application project:

1. Open the build.gradle file of your application.
2. Add the support library to the dependencies section.

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

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

Using bundled fonts to configure EmojiCompat

To use bundled fonts to configure EmojiCompat, perform the following steps:

1. Use BundledEmojiCompatConfig to create an instance of EmojiCompat and provide an instance of Context.
2. Call the init() method to initialize EmojiCompat and pass the instance of 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);
        ...
    }
}

Using EmojiCompat without widgets

EmojiCompat uses EmojiSpan to render correct images. Therefore, it has to convert any given CharSequence into Spanned instances with EmojiSpans. The EmojiCompat class provides a method to convert CharSequences into Spanned instances with EmojiSpans. Using this method, you can process and cache the processed instances instead of the raw string, which improves the performance of your application.

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

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

Using EmojiCompat for IMEs

Using the EmojiCompat support library, keyboards can render the emoji supported by the application they are interacting with. IMEs can use the hasEmojiGlyph() method to check if EmojiCompat is capable of rendering an emoji. This method takes a CharSequence of an emoji and returns true if EmojiCompat can detect and render the emoji.

The keyboard can also check the version of the EmojiCompat support library that the app supports to determine which emoji to render in the palette. To check the version, if available, the keyboard needs to check whether the following keys exist in the EditorInfo.extras bundle:

• EDITOR_INFO_METAVERSION_KEY

If the key exists in the bundle, the value represents the version of the emoji metadata that the app uses. If this key does not exist, the app is not using EmojiCompat.

• EDITOR_INFO_REPLACE_ALL_KEY

If the key exists and is set to true, this indicates that the app has called the SetReplaceAll() method. For more information about EmojiCompat configuration, refer to the Configuration options section.

After receiving the keys in the EditorInfo.extras bundle, the keyboard can use the hasEmojiGlyph() method, where metadataVersion is the value for EDITOR_INFO_METAVERSION_KEY, to check whether the app can render a specific emoji.

Using EmojiCompat with custom widgets

You can always use the process() method to preprocess the CharSequence in your app and add it to any widget that can render Spanned instances; for example, TextView. In addition, EmojiCompat provides the following widget helper classes to let you enrich your custom widgets with emoji support with minimum effort.

• EmojiTextViewHelper
• EmojiEditTextHelper

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

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

Frequently asked questions

• How do I initiate the font download?

The emoji fonts are downloaded on first request, if they do not exist on the device. The download scheduling is transparent to the app.

• How much time does it take to initialize?

After the font is downloaded, it takes approximately 150 milliseconds to initialize EmojiCompat.

• How much memory does the EmojiCompat support library use?

Currently, the data structure to find the emoji is loaded in the app’s memory and uses around 200KB.

• Can I use EmojiCompat for a custom TextView?

Yes. EmojiCompat provides helper classes for custom widgets. It is also possible to preprocess a given string and convert it to Spanned. For more information about widget helper classes, refer to the Using EmojiCompat with custom widgets section.

• What happens if I add widgets in layout XMLs on devices that run on Android 4.4 (API level 19) or lower?

You can include the EmojiCompat support library or its widgets in your applications that support devices running Android 4.4 (API level 19) or lower. However, if a device runs on an Android version prior to API level 19, EmojiCompat and its widgets are in a "no operation" state. This means that EmojiTextView behaves exactly like a regular TextView. EmojiCompat instance; it immediately gets into a LOAD_STATE_SUCCEEDED state when you call the init() method.

Additional resources

For additional information on using the EmojiCompat library, watch EmojiCompat.