סקירה כללית של השירותים

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

זהירות: שירות פועל ב-thread הראשי של התהליך המארח שלו. השירות לא יוצר thread משלו ולא פועל בתהליך נפרד, אלא אם ציינתם אחרת. כדי למנוע שגיאות מסוג "האפליקציה לא מגיבה" (ANR), צריך להריץ את כל פעולות החסימה בשרשור נפרד בתוך השירות.

סוגי השירותים

אלה שלושת סוגי השירותים:

חזית

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

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

מידע נוסף על הגדרת שירותים שפועלים בחזית במסגרת אפליקציות

הערה: ה-API של WorkManager מאפשר לתזמן משימות בצורה גמישה, ולהריץ את המשימות האלה כשירותים שפועלים בחזית במקרה הצורך. במקרים רבים, עדיף להשתמש ב-WorkManager מאשר להשתמש ישירות בשירותים שפועלים בחזית.

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

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

כבול
שירות מקושר כשמבצעים קישור של רכיב באפליקציה לשירות באמצעות קריאה ל-bindService(). שירות מאוגד מציע ממשק לקוח-שרת שמאפשר לרכיבים לתקשר עם השירות, לשלוח בקשות, לקבל תוצאות ואפילו לעשות את זה בין תהליכים באמצעות תקשורת בין תהליכים (IPC). שירות מאוגד פועל רק כל עוד רכיב באפליקציה אחר מאוגד אליו. כמה רכיבים יכולים להתחבר לשירות בו-זמנית, אבל כשהם מתנתקים, השירות מושמד.

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

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

בחירה בין שירות לבין שרשור

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

אם אתם צריכים לבצע עבודה מחוץ לשרשור הראשי, אבל רק כשהמשתמש יוצר אינטראקציה עם האפליקציה, אתם צריכים ליצור שרשור חדש בהקשר של רכיב אחר באפליקציה. לדוגמה, אם רוצים להשמיע מוזיקה, אבל רק בזמן שהפעילות פועלת, אפשר ליצור שרשור ב-onCreate(), להתחיל להפעיל אותו ב-onStart() ולעצור אותו ב-onStop(). כדאי גם להשתמש במאגרי שרשורים ובמבצעים מהחבילה java.util.concurrent או בקורוטינות של Kotlin במקום במחלקה המסורתית Thread. במסמך Threading on Android מוסבר איך להעביר את ההפעלה לשרשורים ברקע.

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

העקרונות הבסיסיים

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

onStartCommand()
המערכת מפעילה את השיטה הזו באמצעות קריאה ל-startService() כשמגיע מרכיב אחר (כמו פעילות) בקשה להפעלת השירות. כשהשיטה הזו מופעלת, השירות מתחיל לפעול ויכול להמשיך לפעול ברקע ללא הגבלת זמן. אם אתם מטמיעים את זה, אתם צריכים להפסיק את השירות כשהעבודה שלו מסתיימת, על ידי קריאה ל-stopSelf() או ל-stopService(). אם אתם רוצים לספק רק קישור, אתם לא צריכים להטמיע את השיטה הזו.
onBind()
המערכת מפעילה את ה-method הזה על ידי קריאה ל-bindService() כשמרכיב אחר רוצה להתחבר לשירות (למשל, כדי לבצע RPC). בהטמעה של ה-method הזה, צריך לספק ממשק שבו הלקוחות משתמשים כדי לתקשר עם השירות על ידי החזרת IBinder. תמיד צריך להטמיע את השיטה הזו, אבל אם אתם לא רוצים לאפשר קישור, צריך להחזיר ערך null.
onCreate()
המערכת מפעילה את ה-method הזו כדי לבצע תהליכי הגדרה חד-פעמיים כשהשירות נוצר בפעם הראשונה (לפני שהיא מפעילה את onStartCommand() או את onBind()). אם השירות כבר פועל, המערכת לא מפעילה את ה-method הזו.
onDestroy()
המערכת מפעילה את השיטה הזו כשהשירות כבר לא בשימוש ומושמד. השירות שלכם צריך להטמיע את זה כדי לנקות משאבים כמו שרשורים, מאזינים רשומים או מקלטים. זו הקריאה האחרונה שהשירות מקבל.

אם רכיב מפעיל את השירות באמצעות קריאה ל-startService() (שגורמת לקריאה ל-onStartCommand()), השירות ממשיך לפעול עד שהוא מפסיק את עצמו באמצעות stopSelf() או שרכיב אחר מפסיק אותו באמצעות קריאה ל-stopService().

אם רכיב קורא ל-bindService() כדי ליצור את השירות, ו-onStartCommand() לא נקרא, השירות פועל רק כל עוד הרכיב מקושר אליו. אחרי שהשירות מנותק מכל הלקוחות שלו, המערכת משמידה אותו.

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

בקטעים הבאים נסביר איך ליצור את השיטות startService() ו-bindService() של השירות, ואיך להשתמש בהן מרכיבים אחרים באפליקציה.

הצהרה על שירות במניפסט

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

כדי להצהיר על השירות, מוסיפים רכיב <service> כרכיב צאצא של הרכיב <application>. לדוגמה:

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

למידע נוסף על הצהרה על השירות במניפסט, עיינו במאמר העזר בנושא הרכיב <service>.

יש מאפיינים אחרים שאפשר לכלול ברכיב <service> כדי להגדיר מאפיינים כמו ההרשאות שנדרשות כדי להפעיל את השירות והתהליך שבו השירות צריך לפעול. המאפיין android:name הוא המאפיין היחיד שנדרש, והוא מציין את שם המחלקה של השירות. אחרי פרסום האפליקציה, אל תשנו את השם הזה כדי להימנע מהסיכון של שיבוש הקוד בגלל תלות ב-intent מפורש להפעלה או לקישור של השירות (קראו את הפוסט בבלוג, Things That Cannot Change).

זהירות: כדי לוודא שהאפליקציה מאובטחת, צריך תמיד להשתמש ב-Intent מפורש כשמפעילים Service, ולא להצהיר על מסנני Intent לשירותים. שימוש ב-Intent מרומז כדי להפעיל שירות הוא סיכון אבטחה, כי אי אפשר לדעת בוודאות איזה שירות יגיב ל-Intent, והמשתמש לא יכול לראות איזה שירות מופעל. החל מ-Android 5.0 (רמת API‏ 21), המערכת זורקת חריגה אם קוראים ל-bindService() עם Intent משתמע.

כדי לוודא שהשירות זמין רק לאפליקציה שלכם, צריך לכלול את המאפיין android:exported ולהגדיר אותו כ-false. הפעולה הזו מונעת מאפליקציות אחרות להפעיל את השירות, גם כשמשתמשים ב-Intent מפורש.

הערה: המשתמשים יכולים לראות אילו שירותים פועלים במכשיר שלהם. אם הם רואים שירות שהם לא מזהים או לא סומכים עליו, הם יכולים להפסיק את השירות. כדי למנוע מצב שבו המשתמשים יפסיקו את השירות בטעות, צריך להוסיף את המאפיין android:description לאלמנט <service> בקובץ המניפסט של האפליקציה. בתיאור, הוסיפו משפט קצר שמסביר מה השירות עושה ומה היתרונות שלו.

יצירת שירות שהופעל

שירות מופעל הוא שירות שרכיב אחר מפעיל באמצעות קריאה ל-startService(), שגורמת לקריאה ל-method‏ onStartCommand() של השירות.

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

רכיב באפליקציה, כמו פעילות, יכול להפעיל את השירות באמצעות קריאה ל-startService() והעברת Intent שמציין את השירות וכולל את כל הנתונים שהשירות צריך להשתמש בהם. השירות מקבל את הערך של Intent ב-method‏ onStartCommand().

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

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

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

ב-Android Framework יש גם את מחלקת המשנה IntentService של Service, שמשתמשת ב-Thread עובד כדי לטפל בכל בקשות ההתחלה, אחת בכל פעם. לא מומלץ להשתמש במחלקה הזו באפליקציות חדשות, כי היא לא תפעל כמו שצריך החל מ-Android 8 Oreo, בגלל הוספת מגבלות ההפעלה ברקע. בנוסף, הוא הוצא משימוש החל מ-Android 11. אפשר להשתמש ב-JobIntentService כתחליף ל-IntentService שתואם לגרסאות חדשות יותר של Android.

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

הרחבת המחלקה Service

אפשר להרחיב את המחלקה Service כדי לטפל בכל Intent נכנס. כך נראית הטמעה בסיסית:

class HelloService : Service() {

    private var serviceLooper: Looper? = null
    private var serviceHandler: ServiceHandler? = null

    // Handler that receives messages from the thread.
    private inner class ServiceHandler(looper: Looper) : Handler(looper) {

        override fun handleMessage(msg: Message) {
            // Normally we would do some work here, like download a file.
            // For our sample, we just sleep for 5 seconds.
            try {
                Thread.sleep(5000)
            } catch (e: InterruptedException) {
                // Restore interrupt status.
                Thread.currentThread().interrupt()
            }

            // Stop the service using the startId, so that we don't stop
            // the service in the middle of handling another job.
            stopSelf(msg.arg1)
        }
    }

    override fun onCreate() {
        // Start up the thread running the service.  Note that we create a
        // separate thread because the service normally runs in the process's
        // main thread, which we don't want to block.  We also make it
        // background priority so CPU-intensive work will not disrupt our UI.
        HandlerThread("ServiceStartArguments", Process.THREAD_PRIORITY_BACKGROUND).apply {
            start()

            // Get the HandlerThread's Looper and use it for our Handler.
            serviceLooper = looper
            serviceHandler = ServiceHandler(looper)
        }
    }

    override fun onStartCommand(intent: Intent, flags: Int, startId: Int): Int {
        Toast.makeText(this, "service starting", Toast.LENGTH_SHORT).show()

        // For each start request, send a message to start a job and deliver the
        // start ID so we know which request we're stopping when we finish the job.
        serviceHandler?.obtainMessage()?.also { msg ->
            msg.arg1 = startId
            serviceHandler?.sendMessage(msg)
        }

        // If we get killed, after returning from here, restart.
        return START_STICKY
    }

    override fun onBind(intent: Intent): IBinder? {
        // We don't provide binding, so return null.
        return null
    }

    override fun onDestroy() {
        Toast.makeText(this, "service done", Toast.LENGTH_SHORT).show()
    }
}

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

שימו לב שה-method onStartCommand() צריך להחזיר מספר שלם. המספר השלם הוא ערך שמתאר איך המערכת צריכה להמשיך את השירות במקרה שהמערכת סוגרת אותו. ערך ההחזרה מ-onStartCommand() חייב להיות אחד מהקבועים הבאים:

START_NOT_STICKY
אם המערכת סוגרת את השירות אחרי ש-onStartCommand() מחזיר ערך, אין ליצור מחדש את השירות אלא אם יש אינטנטים בהמתנה שצריך להעביר. זו האפשרות הבטוחה ביותר כדי להימנע מהפעלת השירות כשאין צורך, וכשהאפליקציה יכולה פשוט להפעיל מחדש משימות שלא הסתיימו.
START_STICKY
אם המערכת סוגרת את השירות אחרי ש-onStartCommand() מחזיר ערך, צריך ליצור מחדש את השירות ולקרוא ל-onStartCommand(), אבל לא להעביר מחדש את ה-Intent האחרון. במקום זאת, המערכת קוראת ל-onStartCommand() עם Intent ריק, אלא אם יש Intent בהמתנה להפעלת השירות. במקרה כזה, ה-intent האלה נשלחים. האפשרות הזו מתאימה לנגני מדיה (או שירותים דומים) שלא מריצים פקודות, אלא פועלים ללא הגבלת זמן וממתינים למשימה.
START_REDELIVER_INTENT
אם המערכת מפסיקה את השירות אחרי ש-onStartCommand() מחזיר ערך, צריך ליצור מחדש את השירות ולקרוא ל-onStartCommand() עם ה-intent האחרון שנשלח לשירות. כל ה-intent בהמתנה מועברים בתורם. האפשרות הזו מתאימה לשירותים שמבצעים באופן פעיל משימה שצריך להמשיך מיד, כמו הורדת קובץ.

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

הפעלת שירות

אפשר להפעיל שירות מפעילות או מרכיב אחר באפליקציה על ידי העברת Intent אל startService() או אל startForegroundService(). מערכת Android מפעילה את השיטה onStartCommand() של השירות ומעבירה אליה את ה-Intent, שמציין איזה שירות להפעיל.

הערה: אם האפליקציה מטרגטת לרמת ה-API המיועדת 26 ומעלה, המערכת מטילה הגבלות על השימוש בשירותים שפועלים ברקע או על היצירה שלהם, אלא אם האפליקציה עצמה פועלת בחזית. אם אפליקציה צריכה ליצור שירות שפועל בחזית, היא צריכה להפעיל את startForegroundService(). ה-method הזו יוצרת שירות שפועל ברקע, אבל ה-method מאותתת למערכת שהשירות יקדם את עצמו לחזית. אחרי שהשירות נוצר, הוא צריך להפעיל את השיטה startForeground() תוך חמש שניות.

לדוגמה, פעילות יכולה להפעיל את השירות לדוגמה מהקטע הקודם (HelloService) באמצעות Intent מפורש עם startService(), כמו שמוצג כאן:

startService(Intent(this, HelloService::class.java))

ה-method‏ startService() מחזירה תשובה באופן מיידי, ומערכת Android קוראת ל-method‏ onStartCommand() של השירות. אם השירות עדיין לא פועל, המערכת קוראת קודם ל-onCreate() ואז ל-onStartCommand().

אם השירות לא מספק גם קישור, ה-Intent שמועבר עם startService() הוא מצב התקשורת היחיד בין הרכיב באפליקציה לבין השירות. עם זאת, אם רוצים שהשירות יחזיר תוצאה, הלקוח שמפעיל את השירות יכול ליצור PendingIntent לשידור (באמצעות getBroadcast()) ולהעביר אותו לשירות ב-Intent שמפעיל את השירות. לאחר מכן, השירות יכול להשתמש בשידור כדי להציג תוצאה.

אם יש כמה בקשות להפעלת השירות, יהיו כמה קריאות תואמות ל-onStartCommand() של השירות. עם זאת, נדרשת רק בקשה אחת להפסקת השירות (באמצעות stopSelf() או stopService()) כדי להפסיק אותו.

הפסקת שירות

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

אחרי ששולחים בקשה לעצירה באמצעות stopSelf() או stopService(), המערכת משמידה את השירות בהקדם האפשרי.

אם השירות שלכם מטפל בכמה בקשות ל-onStartCommand() בו-זמנית, אל תפסיקו את השירות כשתסיימו לעבד בקשת התחלה, כי יכול להיות שקיבלתם בקשת התחלה חדשה (הפסקה בסוף הבקשה הראשונה תסיים את הבקשה השנייה). כדי למנוע את הבעיה הזו, אתם יכולים להשתמש ב-stopSelf(int) כדי לוודא שהבקשה להפסקת השירות תמיד מבוססת על בקשת ההפעלה האחרונה. כלומר, כשקוראים ל-stopSelf(int), מעבירים את המזהה של בקשת ההתחלה (ה-startId שנשלח אל onStartCommand()) שאליו מתאימה בקשת העצירה. אם השירות מקבל בקשת הפעלה חדשה לפני שאתם יכולים להפעיל את stopSelf(int), המזהה לא תואם והשירות לא מפסיק.

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

מידע נוסף על מחזור החיים של שירות מופיע בקטע ניהול מחזור החיים של שירות שבהמשך.

יצירת שירות מאוגד (bound service)

שרת מאגד (bound service) מאפשר לרכיבים באפליקציה להתאגד אליו באמצעות קריאה ל-bindService() כדי ליצור חיבור לטווח ארוך. באופן כללי, היא לא מאפשרת לרכיבים להפעיל אותה באמצעות קריאה ל-startService().

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

כדי ליצור שירות מאוגד, צריך להטמיע את שיטת הקריאה החוזרת onBind() כדי להחזיר IBinder שמגדיר את הממשק לתקשורת עם השירות. רכיבים אחרים באפליקציה יכולים לקרוא ל-bindService() כדי לאחזר את הממשק ולהתחיל לקרוא לשיטות בשירות. השירות פועל רק כדי לשרת את רכיב האפליקציה שמקושר אליו, כך שכאשר אין רכיבים שמקושרים לשירות, המערכת משמידה אותו. לא צריך לעצור שרת מאגד באותו אופן שבו עוצרים שירות שמופעל באמצעות onStartCommand().

כדי ליצור שרת מאגד, צריך להגדיר את הממשק שמציין איך הלקוח יכול לתקשר עם השירות. הממשק הזה בין השירות לבין הלקוח חייב להיות הטמעה של IBinder, וזה מה שהשירות צריך להחזיר משיטת הקריאה החוזרת (callback) של onBind(). אחרי שהלקוח מקבל את ה-IBinder, הוא יכול להתחיל לתקשר עם השירות דרך הממשק הזה.

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

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

שליחת התראות למשתמש

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

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

בדרך כלל, התראה בשורת הסטטוס היא השיטה הכי טובה לשימוש כשפעולה ברקע, כמו הורדת קובץ, הסתיימה, והמשתמש יכול עכשיו לפעול בהתאם. כשהמשתמש בוחר את ההתראה מהתצוגה המורחבת, ההתראה יכולה להתחיל פעילות (למשל, להציג את הקובץ שהורד).

ניהול מחזור החיים של שירות

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

מחזור החיים של השירות – מהיצירה ועד להשמדה – יכול להתנהל באחת משתי הדרכים הבאות:

  • שירות שהופעל

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

  • שרת מאגד (bound service)

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

שני הנתיבים האלה לא נפרדים לגמרי. אפשר לקשר לשירות שכבר הופעל באמצעות startService(). לדוגמה, אפשר להפעיל שירות מוזיקה ברקע על ידי קריאה ל-startService() עם Intent שמזהה את המוזיקה שרוצים להשמיע. מאוחר יותר, אולי כשהמשתמש ירצה לשלוט בנגן או לקבל מידע על השיר הנוכחי, פעילות יכולה להתחבר לשירות באמצעות קריאה ל-bindService(). במקרים כאלה, stopService() או stopSelf() לא באמת עוצרים את השירות עד שכל הלקוחות מבטלים את הקישור.

הטמעת הקריאות החוזרות במחזור החיים

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

class ExampleService : Service() {
    private var startMode: Int = 0             // indicates how to behave if the service is killed
    private var binder: IBinder? = null        // interface for clients that bind
    private var allowRebind: Boolean = false   // indicates whether onRebind should be used

    override fun onCreate() {
        // The service is being created
    }

    override fun onStartCommand(intent: Intent?, flags: Int, startId: Int): Int {
        // The service is starting, due to a call to startService()
        return startMode
    }

    override fun onBind(intent: Intent): IBinder? {
        // A client is binding to the service with bindService()
        return binder
    }

    override fun onUnbind(intent: Intent): Boolean {
        // All clients have unbound with unbindService()
        return allowRebind
    }

    override fun onRebind(intent: Intent) {
        // A client is binding to the service with bindService(),
        // after onUnbind() has already been called
    }

    override fun onDestroy() {
        // The service is no longer used and is being destroyed
    }
}

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

איור 2. מחזור החיים של השירות. התרשים מימין מציג את מחזור החיים כשהשירות נוצר באמצעות startService(), והתרשים משמאל מציג את מחזור החיים כשהשירות נוצר באמצעות bindService().

איור 2 ממחיש את שיטות הקריאה החוזרת האופייניות לשירות. למרות שהתרשים מפריד בין שירותים שנוצרו על ידי startService() לבין שירותים שנוצרו על ידי bindService(), חשוב לזכור שכל שירות, לא משנה איך הוא מופעל, יכול לאפשר ללקוחות להתחבר אליו. שירות שהופעל בהתחלה באמצעות onStartCommand() (על ידי לקוח שקורא ל-startService()) עדיין יכול לקבל קריאה ל-onBind() (כשלקוח קורא ל-bindService()).

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

  • כל משך החיים של שירות מתרחש בין הזמן שבו מתבצעת קריאה ל-onCreate() לבין הזמן שבו onDestroy() מחזיר ערך. בדומה לפעילות, שירות מבצע את ההגדרה הראשונית שלו ב-onCreate() ומשחרר את כל המשאבים שנותרו ב-onDestroy(). לדוגמה, שירות להפעלת מוזיקה יכול ליצור את ה-thread שבו המוזיקה מופעלת ב-onCreate(), ואז לעצור את ה-thread ב-onDestroy().

    הערה: השיטות onCreate() ו-onDestroy() נקראות לכל השירותים, בין אם הם נוצרו על ידי startService() או על ידי bindService().

  • משך החיים הפעיל של שירות מתחיל בקריאה ל-onStartCommand() או ל-onBind(). כל שיטה מקבלת את ה-Intent שהועבר אל startService() או אל bindService().

    אם השירות מופעל, משך החיים הפעיל מסתיים באותו זמן שבו מסתיים משך החיים כולו (השירות עדיין פעיל גם אחרי ש-onStartCommand() מחזיר ערך). אם השירות מקושר, משך החיים הפעיל מסתיים כשמוחזר הערך onUnbind().

הערה: למרות ששירות שהופעל נעצר על ידי קריאה ל-stopSelf() או ל-stopService(), אין קריאה חוזרת (callback) תואמת לשירות (אין קריאה חוזרת של onStop()). אם השירות לא מקושר ללקוח, המערכת משמידה אותו כשהשירות נעצר – onDestroy() היא הקריאה החוזרת היחידה שמתקבלת.

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