יצירה של שיטת קלט

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

כדי להוסיף IME למערכת Android, צריך ליצור אפליקציה ל-Android שמכילה כיתה נמשך InputMethodService בנוסף, בדרך כלל יוצרים פעילות 'הגדרות' שמעבירה אפשרויות לשירות ה-IME. אפשר גם להגדיר ממשק משתמש של הגדרות שיוצג כחלק מהגדרות המערכת.

בדף הזה מפורטים הנושאים הבאים:

אם לא עד עכשיו עבדתם עם IME, אתם יכולים לקרוא את מאמר המבוא. שיטות קלט במסך קודם.

מחזור החיים של IME

בתרשים הבא מתוארים שלבי מחזור החיים של IME:

תמונה שמראה את מחזור החיים של IME.
איור 1. מחזור החיים של IME.

הקטעים הבאים מתארים כיצד ליישם את ממשק המשתמש והקוד המשויכים ל-IME עוקב אחרי מחזור החיים הזה.

הצהרה על רכיבי IME במניפסט

במערכת Android, IME הוא אפליקציה ל-Android שמכילה שירות IME מיוחד. קובץ המניפסט של האפליקציה צריך להצהיר על השירות, לבקש את ההרשאות הנדרשות, לספק מסנן Intent שתואם לפעולה action.view.InputMethod ולספק מטא-נתונים שמגדירים את המאפיינים של ה-IME. בנוסף, כדי לספק ממשק הגדרות שמאפשר משתמש לשנות את ההתנהגות של ה-IME, אפשר להגדיר 'הגדרות' פעילות שאפשר להפעיל מתוך הגדרות המערכת.

קטע הקוד הבא מכריז על שירות IME. הוא מבקש את ההרשאה BIND_INPUT_METHOD כדי לאפשר לשירות לחבר את ה-IME למערכת, מגדיר מסנן כוונה שתואמת לפעולה android.view.InputMethod ומגדיר מטא-נתונים ל-IME:

<!-- Declares the input method service. -->
<service android:name="FastInputIME"
    android:label="@string/fast_input_label"
    android:permission="android.permission.BIND_INPUT_METHOD">
    <intent-filter>
        <action android:name="android.view.InputMethod" />
    </intent-filter>
    <meta-data android:name="android.view.im"
               android:resource="@xml/method" />
</service>

קטע הקוד הבא מצהיר על פעילות ההגדרות עבור ה-IME. יש לו מסנן Intent עבור ACTION_MAIN שמציין שהפעילות הזו היא נקודת הכניסה הראשית לאפליקציית ה-IME:

<!-- Optional: an activity for controlling the IME settings. -->
<activity android:name="FastInputIMESettings"
    android:label="@string/fast_input_settings">
    <intent-filter>
        <action android:name="android.intent.action.MAIN"/>
    </intent-filter>
</activity>

אפשר גם לספק גישה להגדרות ה-IME ישירות מממשק המשתמש שלו.

ה-API של שיטת הקלט

כיתות שספציפיות ל-IME נמצאות android.inputmethodservice וגם android.view.inputmethod חבילות. הכיתה KeyEvent חשובה לטיפול בתווים במקלדת.

החלק המרכזי של IME הוא רכיב שירות – כיתה שמרחיבה את InputMethodService. נוסף על הטמעת מחזור החיים הרגיל של השירות, יש קריאות חוזרות (callbacks) של הזנה של ממשק המשתמש של ה-IME, טיפול בקלט של משתמשים והעברת טקסט שדה שמתמקד. כברירת מחדל, הכיתה InputMethodService מספקת את רוב ההטמעה לניהול המצב והחשיפה של ה-IME ולתקשורת עם שדה הקלט הנוכחי.

גם המחלקות הבאות חשובות:

BaseInputConnection
הגדרת ערוץ התקשורת מ-InputMethod חזרה לאפליקציה שמקבלת את הקלט שלה. אתם משתמשים בו כדי לקרוא טקסט מסביב הסמן, לשמור טקסט לתיבת הטקסט ולשלוח אירועים מרכזיים גולמיים לאפליקציה. אפליקציות חייבות להרחיב את המחלקה הזו במקום להטמיע את הממשק הבסיסי InputConnection
KeyboardView
תוסף של View לעיבוד מקלדת ולתגובה לאירועי קלט של משתמשים. פריסת המקלדת מצוינת על ידי מופע של Keyboard, שאפשר להגדיר בקובץ XML.

עיצוב ממשק המשתמש של שיטת הקלט

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

תצוגת הקלט

תצוגת הקלט היא ממשק המשתמש שבו המשתמש מזין טקסט באמצעות הקשות על מקש, כתב יד או תנועות. כאשר ה-IME מוצג בפעם הראשונה, המערכת קוראת לרכיב onCreateInputView() קריאה חוזרת. ביישום של השיטה הזו, צור את הפריסה שברצונך להציג ב-IME חלון ולהחזיר את הפריסה למערכת. קטע הקוד הבא מציג דוגמה להטמעה השיטה onCreateInputView():

Kotlin

override fun onCreateInputView(): View {
    return layoutInflater.inflate(R.layout.input, null).apply {
        if (this is MyKeyboardView) {
            setOnKeyboardActionListener(this@MyInputMethod)
            keyboard = latinKeyboard
        }
    }
}

Java

@Override
public View onCreateInputView() {
    MyKeyboardView inputView =
        (MyKeyboardView) getLayoutInflater().inflate(R.layout.input, null);

    inputView.setOnKeyboardActionListener(this);
    inputView.setKeyboard(latinKeyboard);

    return inputView;
}

בדוגמה הזו, MyKeyboardView הוא מופע של הטמעה מותאמת אישית של KeyboardView שמפיק Keyboard.

תצוגת המועמדים

תצוגת המועמדים היא ממשק המשתמש שבו מוצגות תיקונים אפשריים של מילים או הצעות למילים ב-IME, והמשתמש יכול לבחור מתוכן. במהלך מחזור החיים של ה-IME, המערכת קוראת ל-onCreateCandidatesView() כשהיא מוכנה להציג את תצוגת המועמדים. בהטמעה של השיטה הזו, צריך להחזיר פריסה שמציגה הצעות למילים, או להחזיר null אם לא רוצים להציג שום דבר. תגובה null היא התנהגות ברירת המחדל, כך שאין צורך להטמיע אותה אם לא מספקים הצעות.

שיקולים בתכנון ממשק המשתמש

בקטע הזה מתוארים כמה משיקולים לגבי עיצוב ממשק המשתמש ברכיבי IME.

טיפול במספר גדלים של מסכים

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

טיפול בסוגי קלט שונים

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

לדוגמה, זהו הממשק ש-IME הלטיני מספק להזנת הטקסט בפלטפורמת Android:

תמונה שבה מוצג קלט טקסט ב-IME לטיני
איור 2. קלט טקסט של IME לטינית.

וכאן זהו הממשק שה-IME הלטיני מספק לפלטפורמת Android קלט מספרי:

תמונה שמציגה קלט מספרי ב-IME לטיני
איור 3. קלט מספרי ב-IME לטיני.

כששדה קלט מקבל את המיקוד וה-IME מתחיל לפעול, המערכת קוראת ל-onStartInputView() ומעבירה אובייקט EditorInfo שמכיל פרטים על סוג הקלט ומאפיינים אחרים של שדה הטקסט. באובייקט הזה, השדה inputType מכיל את סוג הקלט של שדה הטקסט.

השדה inputType הוא int שמכיל תבניות ביטים שונים הגדרות של סוג הקלט. כדי לבדוק את סוג הקלט של שדה הטקסט, מסתירים אותו בעזרת הקבוע TYPE_MASK_CLASS, כך:

Kotlin

inputType and InputType.TYPE_MASK_CLASS

Java

inputType & InputType.TYPE_MASK_CLASS

תבנית הביטים של סוג הקלט יכולה להיות אחת מכמה ערכים, כולל:

TYPE_CLASS_NUMBER
שדה טקסט להזנת מספרים. כפי שמוצג באיור 3, ב-IME הלטיני מוצג מקלדת מספרים בשדות מהסוג הזה.
TYPE_CLASS_DATETIME
שדה טקסט להזנת תאריך ושעה.
TYPE_CLASS_PHONE
שדה טקסט להזנת מספרי טלפון.
TYPE_CLASS_TEXT
שדה טקסט להזנת תווים נתמכים.

הקבועים האלה מתוארים בפירוט רב יותר במסמכי העזרה של InputType.

השדה inputType יכול להכיל ביטים אחרים שמציינים וריאנט של סוג שדה הטקסט, כמו:

TYPE_TEXT_VARIATION_PASSWORD
גרסה של TYPE_CLASS_TEXT להזנת סיסמאות. שיטת הקלט מציגה סמלי דינגו במקום את הטקסט בפועל.
TYPE_TEXT_VARIATION_URI
וריאנט של TYPE_CLASS_TEXT להזנת כתובות URL של אתרים ומזהי משאבים אחידים (URI) אחרים.
TYPE_TEXT_FLAG_AUTO_COMPLETE
וריאנט של TYPE_CLASS_TEXT להזנה של טקסט שהאפליקציה השלמה אוטומטית ממילון, מחיפוש או ממתקן אחר.

כשבודקים את הווריאציות האלה, יש להסוות את inputType עם הערך הקבוע המתאים. קבועי המסכות הזמינים מפורטים במסמכי העזר של InputType.

שליחת טקסט לאפליקציה

כשהמשתמש מזין טקסט באמצעות ה-IME, אפשר לשלוח טקסט לאפליקציה על ידי שליחת אירועי מקש בודדים או על ידי עריכת הטקסט סביב הסמן בשדה הטקסט של האפליקציה. בכל מקרה, צריך להשתמש במכונה של InputConnection כדי להעביר את הטקסט. כדי לקבל את המופע הזה, צריך InputMethodService.getCurrentInputConnection()

עורכים את הטקסט שמסביב לסמן העכבר

כשאתם עורכים טקסט קיים, הנה כמה שיטות שימושיות BaseInputConnection הם:

getTextBeforeCursor()
מחזיר CharSequence שמכיל את מספר התווים המבוקשים לפני מיקום הסמן הנוכחי.
getTextAfterCursor()
מחזירה CharSequence שמכיל את מספר התווים המבוקשים שעוקבים אחריה את המיקום הנוכחי של הסמן.
deleteSurroundingText()
מחיקת מספר התווים שצוין לפני מיקום הסמן הנוכחי ואחריו.
commitText()
מקיפה CharSequence לשדה הטקסט ומגדיר מיקום סמן חדש.

לדוגמה, קטע הקוד הבא מראה איך להחליף את ארבעת התווים שמימין סמן עם הטקסט "שלום!":

Kotlin

currentInputConnection.also { ic: InputConnection ->
    ic.deleteSurroundingText(4, 0)
    ic.commitText("Hello", 1)
    ic.commitText("!", 1)
}

Java

InputConnection ic = getCurrentInputConnection();
ic.deleteSurroundingText(4, 0);
ic.commitText("Hello", 1);
ic.commitText("!", 1);

תמיכה בכתיבת טקסט לפני אישור

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

קטע הקוד הבא מדגים איך להציג את ההתקדמות בשדה טקסט:

Kotlin

currentInputConnection.also { ic: InputConnection ->
    ic.setComposingText("Composi", 1)
    ic.setComposingText("Composin", 1)
    ic.commitText("Composing ", 1)
}

Java

InputConnection ic = getCurrentInputConnection();
ic.setComposingText("Composi", 1);
ic.setComposingText("Composin", 1);
ic.commitText("Composing ", 1);

תיעוד אירועים מרכזיים של חומרה

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

כדי ליירט מפתחות חומרה, יש לעקוף את הבעיה onKeyDown() וגם onKeyUp().

מפעילים את השיטה super() למפתחות שלא רוצים לטפל בעצמך.

יצירת סוג משנה של IME

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

  • מקום, כמו en_US או fr_FR
  • שיטת קלט, כמו קול, מקלדת או כתב יד
  • סגנונות קלט, טפסים או מאפיינים אחרים שהם ספציפיים ל-IME, כגון 10 מקשים או QWERTY פריסות מקלדת

המצב יכול להיות כל טקסט, כמו 'מקלדת' או 'קול'. סוג משנה יכול גם לחשוף שילוב כאלה.

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

להגדיר סוגי משנה באחד מקובצי המשאבים של XML של שיטת הקלט, באמצעות הפונקציה רכיב <subtype>. קטע הקוד הבא מגדיר IME עם שני תת-סוגים: תת-סוג של מקלדת לאזור הלשוני אנגלית (ארה"ב) ותת-סוג אחר של מקלדת לאזור הלשוני צרפתית (צרפת):

<input-method xmlns:android="http://schemas.android.com/apk/res/android"
        android:settingsActivity="com.example.softkeyboard.Settings"
        android:icon="@drawable/ime_icon">
    <subtype android:name="@string/display_name_english_keyboard_ime"
            android:icon="@drawable/subtype_icon_english_keyboard_ime"
            android:languageTag="en-US"
            android:imeSubtypeMode="keyboard"
            android:imeSubtypeExtraValue="somePrivateOption=true" />
    <subtype android:name="@string/display_name_french_keyboard_ime"
            android:icon="@drawable/subtype_icon_french_keyboard_ime"
            android:languageTag="fr-FR"
            android:imeSubtypeMode="keyboard"
            android:imeSubtypeExtraValue="someVariable=30,someInternalOption=false" />
    <subtype android:name="@string/display_name_german_keyboard_ime" ... />
</input-method>

כדי לוודא שסוגי המשנה מסומנים בצורה נכונה בממשק המשתמש, צריך להשתמש ב-‎%s כדי לקבל תווית של סוג משנה זהה לתווית הלוקאל של סוג המשנה. כך זה עובד בשני קטעי הקוד הבאים. בקטע הקוד הראשון מוצג חלק מקובץ ה-XML של שיטת הקלט:

<subtype
    android:label="@string/label_subtype_generic"
    android:imeSubtypeLocale="en_US"
    android:icon="@drawable/icon_en_us"
    android:imeSubtypeMode="keyboard" />

קטע הקוד הבא הוא חלק מקובץ strings.xml של ה-IME. משאב המחרוזת label_subtype_generic, שמשמש בהגדרה של ממשק המשתמש של שיטת הקלט כדי להגדיר תווית סוג המשנה מוגדרת כך:

<string name="label_subtype_generic">%s</string>

הגדרה זו גורמת שהשם המוצג של סוג המשנה תואם להגדרת הלוקאל. לדוגמה, בכל השפה המקומית באנגלית, השם המוצג הוא "אנגלית (ארצות הברית)".

בחירת סוגי משנה של IME מסרגל ההתראות

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

תמונה שמציגה את השפות תפריט מערכת קלט
איור 4. הדף שפות תפריט המערכת של הקלט.

בחירת סוגי משנה של IME מההגדרות המערכת

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

תמונה שמוצג בה התפריט של בחירת שפות
איור 5. תפריט המערכת שפות

מעבר בין סוגי משנה של IME

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

  1. מגדירים את supportsSwitchingToNextInputMethod = "true" בקובצי המשאבים של שיטת הקלט בפורמט XML. ההצהרה צריכה להיראות כמו קטע הקוד הבא: 
    <input-method xmlns:android="http://schemas.android.com/apk/res/android"
        android:settingsActivity="com.example.softkeyboard.Settings"
        android:icon="@drawable/ime_icon"
        android:supportsSwitchingToNextInputMethod="true">
  2. קוראים ל-method‏ shouldOfferSwitchingToNextInputMethod().
  3. אם השיטה מחזירה את הערך true, מציגים מפתח החלפה.
  4. כשהמשתמש יקיש על מקש ההחלפה, התקשר switchToNextInputMethod(), העברת FALSE. הערך False מורה למערכת להתייחס לכל סוגי המשנה באופן שווה, ללא קשר לאיזה IME הם שייכים. כדי לציין True, המערכת צריכה לעבור בין סוגי משנה ה-IME הנוכחי.

שיקולים כלליים לגבי IME

יש עוד נקודות שכדאי להביא בחשבון במהלך הטמעת ה-IME:

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