שפת ההגדרה לבניית ממשק Android (AIDL) דומה לשפות IDL אחרות: היא מאפשרת להגדיר את ממשק התכנות שמוסכם על הלקוח ועל השירות כדי לתקשר זה עם זה באמצעות תקשורת בין תהליכים (IPC).
ב-Android, תהליך אחד לא יכול בדרך כלל לגשת לזיכרון של תהליך אחר. כדי לתקשר, הם צריכים לפרק את האובייקטים שלהם לפרימיטיבים שמערכת ההפעלה יכולה להבין, ולארגן את האובייקטים מעבר לגבול הזה בשבילכם. הקוד לביצוע המרשלינג הזה מייגע לכתיבה, ולכן Android מטפלת בו בשבילכם באמצעות AIDL.
הערה: צריך להשתמש ב-AIDL רק אם מאפשרים ללקוחות מאפליקציות שונות לגשת לשירות שלכם לצורך IPC, ואתם רוצים לטפל בריבוי הליכי משנה בשירות. אם אתם לא צריכים לבצע IPC בו-זמנית באפליקציות שונות, צרו את הממשק על ידי הטמעה של Binder.
אם אתם רוצים לבצע IPC אבל לא צריכים לטפל בריבוי תהליכים, הטמיעו את הממשק באמצעות Messenger.
בכל מקרה, חשוב להבין את השירותים המאוגדים לפני שמטמיעים AIDL.
לפני שמתחילים לתכנן את ממשק ה-AIDL, חשוב לדעת שהקריאות לממשק AIDL הן קריאות ישירות להפעלת פונקציות. אל תניחו הנחות לגבי השרשור שבו מתרחשת הקריאה. מה שקורה תלוי בשאלה אם הקריאה היא משרשור בתהליך המקומי או בתהליך מרוחק:
- שיחות שמתבצעות מהתהליך המקומי מופעלות באותו הליך שבו מתבצעת השיחה. אם זהו שרשור ה-UI הראשי, השרשור הזה ממשיך לפעול בממשק AIDL. אם זה שרשור אחר, הוא זה שמריץ את הקוד בשירות. לכן, אם רק שרשורים מקומיים ניגשים לשירות, אתם יכולים לשלוט באופן מלא בשרשורים שפועלים בו. אבל אם זה המצב, אל תשתמשו ב-AIDL בכלל. במקום זאת, צרו את הממשק על ידי הטמעה של
Binder. - קריאות מתהליך מרוחק נשלחות ממאגר שרשורים שהפלטפורמה מנהלת בתוך התהליך שלכם. חשוב להיות מוכנים לשיחות נכנסות משרשורים לא ידועים, ולכמה שיחות שמתרחשות בו-זמנית. במילים אחרות, הטמעה של ממשק AIDL חייבת להיות thread-safe לחלוטין. קריאות שמתבצעות משרשור אחד באותו אובייקט מרוחק מגיעות לפי הסדר בצד המקבל.
- מילת המפתח
onewayמשנה את ההתנהגות של קריאות מרחוק. כשמשתמשים בה, שיחה מרחוק לא נחסמת. הוא שולח את נתוני העסקה ומיד מחזיר אותם. ההטמעה של הממשק מקבלת את זה בסופו של דבר כקריאה רגילה ממאגר ה-threads שלBinder, כקריאה רגילה מרחוק. אם משתמשים ב-onewayעם קריאה מקומית, אין השפעה והקריאה עדיין סינכרונית.
הגדרה של ממשק AIDL
מגדירים את ממשק ה-AIDL בקובץ .aidl באמצעות התחביר של שפת התכנות Java, ואז שומרים אותו בקוד המקור, בספרייה src/, גם של האפליקציה שמארחת את השירות וגם של כל אפליקציה אחרת שמתחברת לשירות.
כשיוצרים כל אפליקציה שמכילה את הקובץ .aidl, הכלים של Android SDK יוצרים ממשק IBinder שמבוסס על הקובץ .aidl ושומרים אותו בספרייה gen/ של הפרויקט. השירות צריך להטמיע את הממשק IBinder בהתאם. לאחר מכן, אפליקציות הלקוח יכולות להתחבר לשירות ולהפעיל שיטות מ-IBinder כדי לבצע IPC.
כדי ליצור שירות מאוגד באמצעות AIDL, מבצעים את השלבים הבאים, שמתוארים בקטעים הבאים:
- יצירת הקובץ
.aidlהקובץ הזה מגדיר את ממשק התכנות עם חתימות של מתודות.
- הטמעת הממשק
הכלים של Android SDK יוצרים ממשק בשפת התכנות Java על סמך קובץ ה-
.aidl. לממשק הזה יש מחלקה מופשטת פנימית בשםStubשמרחיבה אתBinderומטמיעה שיטות מהממשק של AIDL. צריך להרחיב את המחלקהStubולהטמיע את ה-methods. - חשיפת הממשק ללקוחות
מטמיעים
Serviceומבטלים אתonBind()כדי להחזיר את ההטמעה של המחלקהStub.
זהירות: כל שינוי שתבצעו בממשק AIDL אחרי הגרסה הראשונה חייב להיות תואם לדורות קודמים, כדי לא לשבש אפליקציות אחרות שמשתמשות בשירות שלכם. כלומר, מכיוון שצריך להעתיק את קובץ ה-.aidl לאפליקציות אחרות כדי שהן יוכלו לגשת לממשק של השירות, צריך להמשיך לתמוך בממשק המקורי.
יצירת קובץ .aidl
ב-AIDL נעשה שימוש בתחביר פשוט שמאפשר להצהיר על ממשק עם שיטה אחת או יותר שיכולה לקבל פרמטרים ולהחזיר ערכים. הפרמטרים והערכים המוחזרים יכולים להיות מכל סוג, אפילו ממשקים אחרים שנוצרו על ידי AIDL.
צריך ליצור את הקובץ .aidl באמצעות שפת התכנות Java. כל קובץ .aidl צריך להגדיר ממשק אחד, ונדרשות רק הצהרת הממשק וחתימות השיטה.
כברירת מחדל, AIDL תומך בסוגי הנתונים הבאים:
- כל הסוגים הפרימיטיביים, למעט
short, בשפת התכנות Java (כמוint,long,char,booleanוכו') - מערכים מכל סוג, כמו
int[]אוMyParcelable[] StringCharSequenceListכל הרכיבים ב-
Listחייבים להיות אחד מסוגי הנתונים הנתמכים ברשימה הזו, או אחד מהממשקים האחרים שנוצרו על ידי AIDL או מהאובייקטים הניתנים להעברה (parcelable) שאתם מצהירים עליהם. אפשר להשתמש ב-Listכסוג של מחלקה עם פרמטרים, כמוList<String>. המחלקה הקונקרטית בפועל שהצד השני מקבל היא תמידArrayList, למרות שהשיטה נוצרת כדי להשתמש בממשקList.Mapכל הרכיבים ב-
Mapחייבים להיות אחד מסוגי הנתונים הנתמכים ברשימה הזו, או אחד מהממשקים האחרים שנוצרו על ידי AIDL או מהאובייקטים הניתנים להעברה (parcelable) שאתם מצהירים עליהם. אין תמיכה במפות מסוגים עם פרמטרים, כמו אלה בפורמטMap<String,Integer>. המחלקה הקונקרטית בפועל שהצד השני מקבל היא תמידHashMap, למרות שהשיטה נוצרת כדי להשתמש בממשקMap. כדאי להשתמש ב-Bundleבמקום ב-Map.
צריך לכלול הצהרת import לכל סוג נוסף שלא מופיע קודם, גם אם הוא מוגדר באותה חבילה כמו הממשק.
כשמגדירים את ממשק השירות, חשוב לשים לב לדברים הבאים:
- שיטות יכולות לקבל אפס פרמטרים או יותר, והן יכולות להחזיר ערך או void.
- כל הפרמטרים הלא פרימיטיביים דורשים תג כיוון שמציין לאן הנתונים עוברים:
in,outאוinout(ראו את הדוגמה בהמשך).פרימיטיבים,
String,IBinderוממשקים שנוצרו על ידי AIDL הםinכברירת מחדל, ואי אפשר לשנות את זה.זהירות: הגבילו את הכיוון למה שבאמת נחוץ, כי העברת פרמטרים היא פעולה יקרה.
- כל ההערות בקוד שנכללות בקובץ
.aidlנכללות בממשקIBinderשנוצר, חוץ מההערות שלפני הצהרות הייבוא והחבילה. - אפשר להגדיר קבועים של מחרוזות ושל מספרים שלמים בממשק AIDL, כמו
const int VERSION = 1;. - הפעלות של methods נשלחות על ידי קוד
transact(), שבדרך כלל מבוסס על אינדקס של methods בממשק. מכיוון שהדבר מקשה על ניהול הגרסאות, אפשר להקצות באופן ידני את קוד העסקה ל-method: void method() = 10;. - צריך להוסיף הערות לארגומנטים ולסוגי החזרה שניתן להגדיר כ-null באמצעות
@nullable.
קובץ .aidl לדוגמה:
// IRemoteService.aidl package com.example.android; // Declare any non-default types here with import statements. /** Example service interface. */ interface IRemoteService { /** Request the process ID of this service. */ int getPid(); /** Demonstrates some basic types that you can use as parameters * and return values in AIDL. */ void basicTypes(int anInt, long aLong, boolean aBoolean, float aFloat, double aDouble, String aString); }
שומרים את הקובץ .aidl בספרייה src/ של הפרויקט. כשמפתחים את האפליקציה, כלי ה-SDK יוצרים את קובץ הממשק IBinder בספרייה gen/ של הפרויקט. שם הקובץ שנוצר זהה לשם של קובץ ה-.aidl, אבל עם הסיומת .java. לדוגמה, IRemoteService.aidl יחזיר את התוצאה IRemoteService.java.
אם אתם משתמשים ב-Android Studio, ה-build המצטבר יוצר את מחלקת ה-binder כמעט באופן מיידי.
אם אתם לא משתמשים ב-Android Studio, הכלי Gradle יוצר את מחלקת ה-binder בפעם הבאה שאתם יוצרים את האפליקציה. בונים את הפרויקט באמצעות gradle assembleDebug או gradle assembleRelease מיד אחרי שמסיימים לכתוב את הקובץ .aidl, כדי שהקוד יוכל לקשר למחלקה שנוצרה.
הטמעת הממשק
כשיוצרים את האפליקציה, הכלים של Android SDK יוצרים קובץ ממשק .java שנקרא על שם קובץ ה-.aidl. הממשק שנוצר כולל מחלקת משנה בשם Stub, שהיא הטמעה מופשטת של ממשק ההורה שלה, כמו YourInterface.Stub, ומצהירה על כל השיטות מהקובץ .aidl.
הערה: Stub גם מגדיר כמה שיטות עזר, בעיקר asInterface(), שמקבלת IBinder, בדרך כלל זו שמועברת לשיטת הקריאה החוזרת (callback) onServiceConnected() של הלקוח, ומחזירה מופע של ממשק ה-stub. בקטע קריאה ל-method של IPC מוסבר איך לבצע את ההמרה הזו.
כדי להטמיע את הממשק שנוצר מה-.aidl, מרחיבים את הממשק Binder שנוצר, למשל YourInterface.Stub, ומטמיעים את השיטות שעברו בירושה מהקובץ .aidl.
הנה דוגמה להטמעה של ממשק שנקרא IRemoteService, שמוגדר בדוגמה הקודמת של IRemoteService.aidl, באמצעות מכונה אנונימית:
private val binder = object : IRemoteService.Stub() { override fun getPid(): Int = Process.myPid() override fun basicTypes( anInt: Int, aLong: Long, aBoolean: Boolean, aFloat: Float, aDouble: Double, aString: String ) { // Does nothing. } }
עכשיו binder הוא מופע של המחלקה Stub (Binder), שמגדירה את ממשק ה-IPC של השירות. בשלב הבא, המכונה הזו נחשפת ללקוחות כדי שהם יוכלו לקיים אינטראקציה עם השירות.
כשמטמיעים ממשק AIDL, חשוב לשים לב לכמה כללים:
- אין הבטחה שהשיחות הנכנסות יתבצעו ב-thread הראשי, לכן צריך לחשוב על ריבוי תהליכים (multithreading) מההתחלה ולבנות את השירות בצורה נכונה כך שיהיה thread-safe.
- כברירת מחדל, קריאות IPC הן סינכרוניות. אם אתם יודעים שלשירות לוקח יותר מכמה אלפיות השנייה להשלים בקשה, אל תקראו לו מה-thread הראשי של הפעילות. האפליקציה עלולה להיתקע, ובמערכת Android תוצג תיבת הדו-שיח "האפליקציה לא מגיבה". צריך להפעיל אותו משרשור נפרד בלקוח.
- רק סוגי החריגים שמפורטים במאמרי העזרה של
Parcel.writeException()נשלחים בחזרה למבצע הקריאה החוזרת.
חשיפת הממשק ללקוחות
אחרי שמטמיעים את הממשק של השירות, צריך לחשוף אותו ללקוחות כדי שהם יוכלו להתחבר אליו. כדי לחשוף את הממשק של השירות, מרחיבים את Service ומטמיעים את onBind() כדי להחזיר מופע של המחלקה שמטמיעה את ה-Stub שנוצר, כמו שמתואר בקטע הקודם. הנה דוגמה לשירות שחושף את הממשק לדוגמה IRemoteService ללקוחות.
class RemoteService : Service() { override fun onCreate() { super.onCreate() } override fun onBind(intent: Intent): IBinder { // Return the interface. return binder } private val binder = object : IRemoteService.Stub() { override fun getPid(): Int { return Process.myPid() } override fun basicTypes( anInt: Int, aLong: Long, aBoolean: Boolean, aFloat: Float, aDouble: Double, aString: String ) { // Does nothing. } } }
עכשיו, כשלקוח, כמו פעילות, קורא ל-bindService() כדי להתחבר לשירות הזה, פונקציית ה-callback onServiceConnected() של הלקוח מקבלת את המכונה binder שהוחזרה על ידי השיטה onBind() של השירות.
ללקוח צריכה להיות גם גישה למחלקת הממשק. לכן, אם הלקוח והשירות נמצאים באפליקציות נפרדות, באפליקציה של הלקוח צריך להיות עותק של קובץ ה-.aidl בספרייה src/, שיוצרת את הממשק android.os.Binder ומספקת ללקוח גישה לשיטות AIDL.
כשהלקוח מקבל את IBinder בקריאה החוזרת (callback) של onServiceConnected(), הוא צריך להפעיל את YourServiceInterface.Stub.asInterface(service) כדי להמיר את הפרמטר שהוחזר לסוג YourServiceInterface:
var iRemoteService: IRemoteService? = null val mConnection = object : ServiceConnection { // Called when the connection with the service is established. override fun onServiceConnected(className: ComponentName, service: IBinder) { // Following the preceding example for an AIDL interface, // this gets an instance of the IRemoteInterface, which we can use to call on the service. iRemoteService = IRemoteService.Stub.asInterface(service) } // Called when the connection with the service disconnects unexpectedly. override fun onServiceDisconnected(className: ComponentName) { Log.e(TAG, "Service has unexpectedly disconnected") iRemoteService = null } }
לדוגמאות קוד לדוגמה נוספות, עיינו במחלקה RemoteService.java ב-ApiDemos.
העברת אובייקטים דרך IPC
ב-Android 10 (רמת API 29 ומעלה), אפשר להגדיר אובייקטים של Parcelable ישירות ב-AIDL. גם סוגים שנתמכים כארגומנטים של ממשק AIDL וסוגים אחרים של parcelable נתמכים כאן. כך נחסכת העבודה הנוספת של כתיבה ידנית של קוד מרשלינג ומחלקה בהתאמה אישית. עם זאת, הפעולה הזו גם יוצרת מבנה ריק. אם רוצים להשתמש ב-accessors בהתאמה אישית או בפונקציונליות אחרת, צריך להטמיע את Parcelable במקום זאת.
package android.graphics;
// Declare Rect so AIDL can find it and knows that it implements
// the parcelable protocol.
parcelable Rect {
int left;
int top;
int right;
int bottom;
}
דוגמת הקוד שלמעלה יוצרת באופן אוטומטי מחלקת Java עם שדות של מספרים שלמים left, top, right ו-bottom. כל קוד המרשלינג הרלוונטי מוטמע באופן אוטומטי, ואפשר להשתמש באובייקט ישירות בלי להוסיף הטמעה.
אפשר גם לשלוח מחלקה בהתאמה אישית מתהליך אחד לאחר דרך ממשק IPC. עם זאת, ודאו שהקוד של המחלקה זמין לצד השני של ערוץ ה-IPC, ושהמחלקה תומכת בממשק Parcelable. חשוב לתמוך ב-Parcelable כי זה מאפשר למערכת Android לפרק אובייקטים לטיפוסים בסיסיים שאפשר להעביר בין תהליכים.
כדי ליצור מחלקה בהתאמה אישית שתומכת ב-Parcelable:
- מטמיעים במחלקה את הממשק של
Parcelable. - מטמיעים את
writeToParcel, שמקבל את המצב הנוכחי של האובייקט וכותב אותו ב-Parcel. - מוסיפים למחלקה שדה סטטי בשם
CREATOR, שהוא אובייקט שמטמיע את הממשק שלParcelable.Creator. - לבסוף, יוצרים קובץ
.aidlשמצהיר על המחלקה שניתנת להעברה, כמו שמוצג בקובץRect.aidlהבא.אם אתם משתמשים בתהליך build בהתאמה אישית, אל תוסיפו את הקובץ
.aidlל-build. בדומה לקובץ כותרת בשפת C, קובץ ה-.aidlהזה לא עובר קומפילציה.
AIDL משתמש בשיטות ובשדות האלה בקוד שהוא יוצר כדי לבצע מרשלינג וביטול מרשלינג של האובייקטים.
לדוגמה, הנה קובץ Rect.aidl ליצירת מחלקת Rect שניתן להעביר:
package android.graphics; // Declare Rect so AIDL can find it and knows that it implements // the parcelable protocol. parcelable Rect;
והנה דוגמה לאופן שבו המחלקה Rect מטמיעה את הפרוטוקול Parcelable.
// import android.os.Parcel // import android.os.Parcelable class Rect() : Parcelable { var left: Int = 0 var top: Int = 0 var right: Int = 0 var bottom: Int = 0 companion object CREATOR : Parcelable.Creator<Rect> { override fun createFromParcel(parcel: Parcel): Rect { return Rect(parcel) } override fun newArray(size: Int): Array<Rect?> { return Array(size) { null } } } private constructor(inParcel: Parcel) : this() { readFromParcel(inParcel) } override fun writeToParcel(outParcel: Parcel, flags: Int) { outParcel.writeInt(left) outParcel.writeInt(top) outParcel.writeInt(right) outParcel.writeInt(bottom) } private fun readFromParcel(inParcel: Parcel) { left = inParcel.readInt() top = inParcel.readInt() right = inParcel.readInt() bottom = inParcel.readInt() } override fun describeContents(): Int { return 0 } }
המרשלינג במחלקה Rect הוא פשוט. כדאי לעיין בשיטות האחרות ב-Parcel כדי לראות את סוגי הערכים האחרים שאפשר לכתוב ב-Parcel.
אזהרה: חשוב לזכור את ההשלכות האבטחתיות של קבלת נתונים מתהליכים אחרים. במקרה הזה, Rect קורא ארבעה מספרים מ-Parcel, אבל אתם צריכים לוודא שהם נמצאים בטווח הערכים הקבילים לכל מה שהמתקשר מנסה לעשות. מידע נוסף על אבטחת האפליקציה מפני תוכנות זדוניות זמין בטיפים לאבטחה.
שיטות עם ארגומנטים של Bundle שמכילים Parcelables
אם שיטה מקבלת אובייקטBundle שאמור להכיל אובייקטים מסוג parcelable, חשוב להגדיר את ה-classloader של ה-Bundle באמצעות קריאה ל-Bundle.setClassLoader(ClassLoader) לפני שמנסים לקרוא מה-Bundle. אחרת, תיתקלו ב-ClassNotFoundException למרות שה-parcelable מוגדר בצורה נכונה באפליקציה.
לדוגמה, נניח שיש לכם קובץ .aidl כזה:
// IRectInsideBundle.aidl package com.example.android; /** Example service interface. */ interface IRectInsideBundle { /** Rect parcelable is stored in the bundle with key "rect". */ void saveRect(in Bundle bundle); }
ClassLoader מוגדר באופן מפורש ב-Bundle לפני הקריאה של Rect:
private val binder = object : IRectInsideBundle.Stub() { override fun saveRect(bundle: Bundle) { bundle.classLoader = classLoader val rect = BundleCompat.getParcelable(bundle, "rect", Rect::class.java) process(rect) // Do more with the parcelable. } }
קריאה לשיטת IPC
כדי לקרוא לממשק מרוחק שמוגדר באמצעות AIDL, מבצעים את השלבים הבאים במחלקה שממנה מתבצעת הקריאה:
- כוללים את הקובץ
.aidlבספרייהsrc/של הפרויקט. - מצהירים על מופע של הממשק
IBinder, שנוצר על סמך ה-AIDL. - מטמיעים את
ServiceConnection. - מפעילים את
Context.bindService(), ומעבירים את ההטמעה שלServiceConnection. - בהטמעה של
onServiceConnected(), אתם מקבלים מופע שלIBinderשנקראservice. מפעילים אתYourInterfaceName.Stub.asInterface((IBinder)service)כדי להמיר את הפרמטר שהוחזר לסוגYourInterface. - מפעילים את השיטות שהגדרתם בממשק. תמיד צריך ללכוד חריגים מסוג
DeadObjectException, שנזרקים כשהחיבור מתנתק. בנוסף, צריך ללכוד חריגים מסוגSecurityException, שנזרקים כששני התהליכים שמעורבים בהפעלת ה-method של ה-IPC כוללים הגדרות AIDL סותרות. - כדי להתנתק, צריך להפעיל את
Context.unbindService()עם המכונה של הממשק.
כשמפעילים שירות IPC, חשוב לזכור את הנקודות הבאות:
- האובייקטים נספרים כהפניות בתהליכים שונים.
- אפשר לשלוח אובייקטים אנונימיים כארגומנטים של שיטות.
מידע נוסף על איגוד לשירות זמין בסקירה הכללית על שירותים מאוגדים.
הנה קוד לדוגמה שמדגים קריאה לשירות שנוצר באמצעות AIDL, שנלקח מהדוגמה של שירות מרוחק בפרויקט ApiDemos.
private const val BUMP_MSG = 1 class Binding : Activity() { /** The primary interface you call on the service. */ private var mService: IRemoteService? = null /** Another interface you use on the service. */ internal var secondaryService: ISecondary? = null private lateinit var killButton: Button private lateinit var callbackText: TextView private lateinit var handler: InternalHandler private var isBound: Boolean = false /** * Class for interacting with the main interface of the service. */ private val mConnection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // This is called when the connection with the service is // established, giving us the service object we can use to // interact with the service. We are communicating with our // service through an IDL interface, so get a client-side // representation of that from the raw service object. mService = IRemoteService.Stub.asInterface(service) killButton.isEnabled = true callbackText.text = "Attached." // We want to monitor the service for as long as we are // connected to it. try { mService?.registerCallback(mCallback) } catch (e: RemoteException) { // In this case, the service crashes before we can // do anything with it. We can count on soon being // disconnected (and then reconnected if it can be restarted) // so there is no need to do anything here. } // As part of the sample, tell the user what happened. Toast.makeText( this@Binding, R.string.remote_service_connected, Toast.LENGTH_SHORT ).show() } override fun onServiceDisconnected(className: ComponentName) { // This is called when the connection with the service is // unexpectedly disconnected—that is, its process crashed. mService = null killButton.isEnabled = false callbackText.text = "Disconnected." // As part of the sample, tell the user what happened. Toast.makeText( this@Binding, R.string.remote_service_disconnected, Toast.LENGTH_SHORT ).show() } } /** * Class for interacting with the secondary interface of the service. */ private val secondaryConnection = object : ServiceConnection { override fun onServiceConnected(className: ComponentName, service: IBinder) { // Connecting to a secondary interface is the same as any // other interface. secondaryService = ISecondary.Stub.asInterface(service) killButton.isEnabled = true } override fun onServiceDisconnected(className: ComponentName) { secondaryService = null killButton.isEnabled = false } } private val mBindListener = View.OnClickListener { // Establish a couple connections with the service, binding // by interface names. This lets other applications be // installed that replace the remote service by implementing // the same interface. val intent = Intent(this@Binding, RemoteService::class.java) intent.action = IRemoteService::class.java.name bindService(intent, mConnection, Context.BIND_AUTO_CREATE) intent.action = ISecondary::class.java.name bindService(intent, secondaryConnection, Context.BIND_AUTO_CREATE) isBound = true callbackText.text = "Binding." } private val unbindListener = View.OnClickListener { if (isBound) { // If we have received the service, and hence registered with // it, then now is the time to unregister. try { mService?.unregisterCallback(mCallback) } catch (e: RemoteException) { // There is nothing special we need to do if the service // crashes. } // Detach our existing connection. unbindService(mConnection) unbindService(secondaryConnection) killButton.isEnabled = false isBound = false callbackText.text = "Unbinding." } } private val killListener = View.OnClickListener { // To kill the process hosting the service, we need to know its // PID. Conveniently, the service has a call that returns // that information. try { secondaryService?.pid?.also { pid -> // Note that, though this API lets us request to // kill any process based on its PID, the kernel // still imposes standard restrictions on which PIDs you // can actually kill. Typically this means only // the process running your application and any additional // processes created by that app, as shown here. Packages // sharing a common UID are also able to kill each // other's processes. Process.killProcess(pid) callbackText.text = "Killed service process." } } catch (ex: RemoteException) { // Recover gracefully from the process hosting the // server dying. // For purposes of this sample, put up a notification. Toast.makeText(this@Binding, R.string.remote_call_failed, Toast.LENGTH_SHORT).show() } } // ---------------------------------------------------------------------- // Code showing how to deal with callbacks. // ---------------------------------------------------------------------- /** * This implementation is used to receive callbacks from the remote * service. */ private val mCallback = object : IRemoteServiceCallback.Stub() { /** * This is called by the remote service regularly to tell us about * new values. Note that IPC calls are dispatched through a thread * pool running in each process, so the code executing here is * NOT running in our main thread like most other things. So, * to update the UI, we need to use a Handler to hop over there. */ override fun valueChanged(value: Int) { handler.sendMessage(handler.obtainMessage(BUMP_MSG, value, 0)) } } /** * Standard initialization of this activity. Set up the UI, then wait * for the user to interact with it before doing anything. */ override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) setContentView(R.layout.remote_service_binding) // Watch for button taps. var button: Button = findViewById(R.id.bind) button.setOnClickListener(mBindListener) button = findViewById(R.id.unbind) button.setOnClickListener(unbindListener) killButton = findViewById(R.id.kill) killButton.setOnClickListener(killListener) killButton.isEnabled = false callbackText = findViewById(R.id.callback) callbackText.text = "Not attached." handler = InternalHandler(callbackText) } private class InternalHandler( textView: TextView, private val weakTextView: WeakReference<TextView> = WeakReference(textView) ) : Handler() { override fun handleMessage(msg: Message) { when (msg.what) { BUMP_MSG -> weakTextView.get()?.text = "Received from service: ${msg.arg1}" else -> super.handleMessage(msg) } } } }