תאימות לאמוג'י

כדאי לנסות את הדרך של כתיבת אימייל

‫Jetpack Compose היא ערכת הכלים המומלצת לבניית ממשק משתמש ל-Android. איך מוסיפים תמיכה באמוג'י בכתיבה.

תמיכה באמוג'י →

שימו לב: החל מסוף 2021, ספריית androidx.emoji:emoji הוצאה משימוש לטובת androidx.emoji2:emoji2, שמספקת שילוב עם androidx.appcompat.

כדי לתמוך בסמלי אמוג'י מודרניים ולפשט את התאימות לאחור לגרסאות ישנות יותר של Android, מומלץ לעבור לספרייה androidx.emoji2:emoji2. פרטים על ההטמעה מופיעים במאמר בנושא תמיכה בסמלי אמוג'י מודרניים.

מטרת ספריית התמיכה של EmojiCompat היא לוודא שמכשירי Android יהיו מעודכנים בסמלי האמוג'י העדכניים ביותר. היא מונעת מהאפליקציה להציג תווים של אמוג'י חסרים בצורה של ☐, שמציינת שלמכשיר אין גופן להצגת הטקסט. באמצעות ספריית התמיכה של EmojiCompat, משתמשי האפליקציה לא צריכים לחכות לעדכונים של מערכת ההפעלה Android כדי לקבל את האימוג'י העדכני ביותר.

איור 1. השוואת אמוג'י

כדאי לעיין במקורות המידע הבאים שקשורים לנושא:

• אפליקציית דוגמה לתאימות אמוג'י Java | Kotlin

איך פועל EmojiCompat?

ספריית התמיכה EmojiCompat מספקת מחלקות להטמעת תמיכה באמוג'י עם תאימות לאחור במכשירים עם Android מגרסה 4.4 (API ברמה 19) ואילך. אפשר להגדיר את EmojiCompat עם גופנים שכלולים בחבילה או עם גופנים שאפשר להוריד. מידע נוסף על הגדרות זמין בקטעים הבאים:

• הגדרת גופנים להורדה
• הגדרת גופנים בחבילה

‫EmojiCompat מזהה אמוג'י ב-CharSequence, מחליף אותם ב-EmojiSpans אם צריך, ובסוף מעבד את גליפי האמוג'י. איור 2 מציג את התהליך.

איור 2. תהליך EmojiCompat

הגדרת גופנים שאפשר להוריד

ההגדרה של גופנים להורדה משתמשת בתכונה של ספריית התמיכה בגופנים להורדה כדי להוריד גופן אמוג'י. העדכון כולל גם את המטא-נתונים של סמלי האמוג'י שספריית התמיכה של EmojiCompat צריכה כדי להתעדכן בגרסאות האחרונות של מפרט Unicode.

הוספת תלות בספריית תמיכה

כדי להשתמש בספריית התמיכה של EmojiCompat, צריך לשנות את יחסי התלות של נתיב המחלקה בפרויקט האפליקציה בסביבת הפיתוח.

כדי להוסיף ספריית תמיכה לפרויקט האפליקציה:

1. פותחים את קובץ build.gradle של האפליקציה.
2. מוסיפים את ספריית התמיכה לקטע dependencies.

גרוב

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

Kotlin

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

אתחול ההגדרות של הגופן שאפשר להוריד

צריך להפעיל את EmojiCompat כדי לטעון את המטא-נתונים ואת הגופן. תהליך האתחול יכול להימשך זמן מה, ולכן הוא מתבצע בשרשור ברקע.

כדי לאתחל את EmojiCompat עם הגדרת הגופן להורדה, מבצעים את השלבים הבאים:

1. יוצרים מופע של המחלקה FontRequest ומספקים את הרשות של ספק הגופנים, את חבילת ספק הגופנים, את שאילתת הגופנים ואת רשימת קבוצות הגיבוב של האישור. מידע נוסף על FontRequest זמין בקטע שימוש בפונטים להורדה באופן פרוגרמטי במסמכי התיעוד של פונטים להורדה.
2. צור מופע של FontRequestEmojiCompatConfig ותן מופעים של Context ושל FontRequest.
3. מאתחלים את EmojiCompat על ידי קריאה לשיטה init() ומעבירים את המופע של 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. משתמשים בווידג'טים של EmojiCompat בפריסת XML. אם אתם משתמשים ב-AppCompat, אפשר לעיין בקטע שימוש בווידג'טים של EmojiCompat עם 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"/>

מידע נוסף על אופן ההגדרה של EmojiCompat באמצעות הגדרת הגופן להורדה זמין באפליקציית הדוגמה של תאימות אמוג'י Java | Kotlin.

רכיבים בספרייה

איור 3. רכיבי הספרייה בתהליך EmojiCompat

ווידג'טים: EmojiEditText, EmojiTextView, EmojiButton

‫

Default widget implementations to use EmojiCompat with TextView, EditText, and Button.

EmojiCompat

הפלטפורמה הציבורית העיקרית של ספריית התמיכה. הוא מבצע את כל הקריאות החיצוניות ומתאם עם שאר חלקי המערכת.

EmojiCompat.Config

הגדרת המכונה ב-singleton שתיצור.

EmojiSpan

‫

A ReplacementSpan subclass that replaces the character (sequences) and renders the glyph.

EmojiCompat גופן

‫

EmojiCompat משתמש בגופן כדי להציג אמוג'י. הגופן הזה הוא גרסה שעברה שינוי של גופן האמוג'י של Android. הגופן ישתנה באופן הבא:

• כדי לספק תאימות לאחור לעיבוד אמוג'י, כל תווי האמוג'י מיוצגים באמצעות נקודת קוד יחידה של Unicode באזור השימוש הפרטי הנוסף A של Unicode, החל מ-U+F0001.
• מטא-נתונים נוספים של אמוג'י מוכנסים בפורמט בינארי לגופן, והם מנותחים בזמן הריצה על ידי EmojiCompat. הנתונים מוטמעים בטבלת meta של הגופן, עם התג הפרטי Emji.

אפשרויות הגדרה

אפשר להשתמש במופע EmojiCompat כדי לשנות את ההתנהגות של EmojiCompat. אפשר להשתמש בשיטות הבאות ממחלקת הבסיס כדי להגדיר את ההגדרות:

• setReplaceAll(): קובע אם EmojiCompat צריך להחליף את כל האמוג'י שהוא מוצא ב-EmojiSpans. כברירת מחדל, ‫EmojiCompat מנסה להבין אם המערכת יכולה לעבד אמוג'י, ולא מחליפה את האמוג'ים האלה. אם בוחרים באפשרות true, כל סמלי האמוג'י שיימצאו ב-EmojiCompat יוחלפו ב-EmojiSpans.
• ‫setEmojiSpanIndicatorEnabled(): מציין אם EmojiCompat החליף אמוג'י ב-EmojiSpan. כשמגדירים את הערך true,‏ EmojiCompat מצייר רקע עבור EmojiSpan. השיטה הזו משמשת בעיקר למטרות ניפוי באגים.
• setEmojiSpanIndicatorColor(): מגדיר את הצבע לציון EmojiSpan. ערך ברירת המחדל הוא GREEN.
• ‫registerInitCallback: מודיע לאפליקציה על מצב ההפעלה של 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() {...})

הוספת פונקציות event listener לאתחול

המחלקות EmojiCompat ו-EmojiCompat מספקות את השיטות registerInitCallback() ו-unregisterInitCallback() לרישום של קריאה חוזרת לאתחול. כדי להשתמש בשיטות האלה, צריך ליצור מופע של מחלקת EmojiCompat.InitCallback. קוראים לשיטות האלה ומעבירים את המופע של המחלקה EmojiCompat.InitCallback. כשאתחול ספריית התמיכה EmojiCompat מצליח, המחלקה EmojiCompat קוראת לשיטה onInitialized(). אם לא ניתן לאתחל את הספרייה, המחלקה EmojiCompat קוראת ל-method‏ onFailed().

כדי לבדוק את מצב האתחול בכל שלב, קוראים לשיטה getLoadState(). הפונקציה מחזירה אחד מהערכים הבאים: LOAD_STATE_LOADING, LOAD_STATE_SUCCEEDED, או LOAD_STATE_FAILED.

שימוש ב-EmojiCompat עם ווידג'טים של AppCompat

אם אתם משתמשים ב-AppCompat widgets, אתם יכולים להשתמש בווידג'טים של EmojiCompat שמתבססים על AppCompat widgets.

1. מוסיפים את ספריית התמיכה לקטע dependencies (תלויות).

   גרוב

   dependencies {
       ...
       implementation "androidx.emoji:emoji-bundled:$version"
   }

   Kotlin

         dependencies {
             implementation("androidx.emoji:emoji-appcompat:$version")
         }
         

   גרוב

         dependencies {
             implementation "androidx.emoji:emoji-appcompat:$version"
         }
         

2. משתמשים בווידג'טים EmojiCompat AppCompat Widget בפריסות של קובצי 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"/>

הגדרת גופנים בחבילה

ספריית התמיכה EmojiCompat זמינה גם בגרסת גופן מאוגדת. החבילה הזו כוללת את הגופן עם המטא-נתונים המוטמעים. החבילה כוללת גם BundledEmojiCompatConfig שמשתמש ב-AssetManager כדי לטעון את המטא-נתונים ואת הגופנים.

הערה: גודל הגופן הוא כמה מגה-בייט.

הוספת תלות בספריית תמיכה

כדי להשתמש בספריית התמיכה EmojiCompat עם הגדרת גופנים בחבילה, חייבים לשנות את יחסי התלות של נתיב המחלקה בפרויקט האפליקציה בסביבת הפיתוח.

כדי להוסיף ספריית תמיכה לפרויקט האפליקציה:

1. פותחים את קובץ build.gradle של האפליקציה.
2. מוסיפים את ספריית התמיכה לקטע dependencies.

גרוב

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

Kotlin

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

שימוש בגופנים כלולים כדי להגדיר את EmojiCompat

כדי להשתמש בגופנים בחבילה להגדרת EmojiCompat, פועלים לפי השלבים הבאים:

1. משתמשים ב-BundledEmojiCompatConfig כדי ליצור מופע של EmojiCompat ולספק מופע של Context.
2. מבצעים קריאה ל-method‏ init() כדי לאתחל את EmojiCompat ומעבירים את המופע של 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);
        ...
    }
}

שימוש ב-EmojiCompat ללא ווידג'טים

‫EmojiCompat משתמש ב-EmojiSpan כדי לעבד תמונות בצורה נכונה. לכן, היא צריכה להמיר כל CharSequence נתון למופעים של Spanned עם EmojiSpans. המחלקת EmojiCompat מספקת שיטה להמרה של מופעים של CharSequences למופעים של Spanned עם EmojiSpans. באמצעות השיטה הזו, אפשר לעבד את המופעים המעובדים ולשמור אותם במטמון במקום את המחרוזת הגולמית, וכך לשפר את הביצועים של האפליקציה.

Kotlin

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

Java

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

שימוש ב-EmojiCompat עבור IME

באמצעות ספריית התמיכה EmojiCompat, המקלדות יכולות להציג את האמוג'י שהאפליקציה תומכת בהם. ממשקי IME יכולים להשתמש בשיטה hasEmojiGlyph() כדי לבדוק אם EmojiCompat יכול להציג אמוג'י. השיטה הזו מקבלת CharSequence של אמוג'י ומחזירה true אם EmojiCompat יכול לזהות את האמוג'י ולהציג אותו.

המקלדת יכולה גם לבדוק את הגרסה של ספריית התמיכה של EmojiCompat שהאפליקציה תומכת בה, כדי לקבוע אילו סמלי אמוג'י יוצגו בלוח. כדי לבדוק את הגרסה, אם היא זמינה, המקלדת צריכה לבדוק אם המקשים הבאים קיימים בחבילה EditorInfo.extras:

• EDITOR_INFO_METAVERSION_KEY

אם המפתח קיים בחבילה, הערך מייצג את גרסת המטא-נתונים של האימוג'י שבה האפליקציה משתמשת. אם המפתח הזה לא קיים, האפליקציה לא משתמשת ב-EmojiCompat.

• EDITOR_INFO_REPLACE_ALL_KEY

אם המפתח קיים והערך שלו הוא true, זה מצביע על כך שהאפליקציה קראה את השיטה SetReplaceAll(). מידע נוסף על הגדרת EmojiCompat זמין בקטע אפשרויות הגדרה.

אחרי קבלת המפתחות בחבילה EditorInfo.extras, המקלדת יכולה להשתמש ב-method‏ hasEmojiGlyph(), כאשר metadataVersion הוא הערך של EDITOR_INFO_METAVERSION_KEY, כדי לבדוק אם האפליקציה יכולה להציג אמוג'י ספציפי.

שימוש ב-EmojiCompat עם ווידג'טים בהתאמה אישית

תמיד אפשר להשתמש בשיטה process() כדי לבצע עיבוד מקדים של CharSequence באפליקציה ולהוסיף אותו לכל ווידג'ט שיכול לעבד מופעים של Spanned, לדוגמה, TextView. בנוסף, ספריית EmojiCompat מספקת את מחלקות העזר לווידג'טים הבאות, כדי שתוכלו להוסיף תמיכה בסמלי אמוג'י לווידג'טים בהתאמה אישית במינימום מאמץ.

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

דוגמה ל-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() {
       ...
   }
}

שאלות נפוצות

• איך מתחילים את ההורדה של הגופן?

גופני האימוג'י יורדים בפעם הראשונה שמבקשים אותם, אם הם לא קיימים במכשיר. התזמון של ההורדה שקוף לאפליקציה.

• כמה זמן נמשך תהליך האתחול?

אחרי שהגופן יורד, לוקח בערך 150 אלפיות השנייה עד ש-EmojiCompat מאותחל.

• כמה זיכרון משתמשת ספריית התמיכה EmojiCompat?

בשלב הזה, מבנה הנתונים של האמוג'י נטען בזיכרון של האפליקציה ומשתמש בכ-200KB.

• האם אפשר להשתמש ב-EmojiCompat עבור TextView בהתאמה אישית?

כן. ‫EmojiCompat מספקת מחלקות עזר לווידג'טים בהתאמה אישית. אפשר גם לבצע עיבוד מקדים למחרוזת נתונה ולהמיר אותה ל-Spanned. מידע נוסף על מחלקות העזר של הווידג'טים זמין בקטע שימוש ב-EmojiCompat עם ווידג'טים בהתאמה אישית.

• מה קורה אם מוסיפים ווידג'טים בקובצי XML של פריסות במכשירים שפועלת בהם מערכת Android מגרסה 4.4 (API ברמה 19) ומטה?

אפשר לכלול את ספריית התמיכה EmojiCompat או את הווידג'טים שלה באפליקציות שתומכות במכשירים עם Android 4.4 (רמת API‏ 19) או גרסאות מוקדמות יותר. עם זאת, אם במכשיר פועלת גרסת Android שקודמת לרמת API‏ 19,‏ EmojiCompat הווידג'טים שלו יהיו במצב 'ללא פעולה'. המשמעות היא ש-EmojiTextView מתנהג בדיוק כמו TextView רגיל. ‫EmojiCompat; הוא עובר באופן מיידי למצב LOAD_STATE_SUCCEEDED כשמתקשרים לשיטה init().

מקורות מידע נוספים

למידע נוסף על השימוש בספרייה EmojiCompat אפשר לצפות בסרטון EmojiCompat.