لغة تعريف واجهة Android (AIDL)

تشبه لغة تعريف واجهة نظام Android‏ (AIDL) لغات تعريف الواجهة (IDL) الأخرى: فهي تتيح لك تحديد واجهة البرمجة التي يتفق عليها كل من العميل والخدمة من أجل التواصل مع بعضهما البعض باستخدام التواصل البيني للعمليات (IPC).

على Android، لا يمكن لعملية واحدة عادةً الوصول إلى ذاكرة عملية أخرى. للتواصل، يحتاجون إلى تحليل كائناتهم إلى عناصر أولية يمكن لنظام التشغيل فهمها وتجميع الكائنات عبر تلك الحدود نيابةً عنك. إنّ الرمز البرمجي الذي ينفّذ عملية التنظيم هذه مملّ في كتابته، لذا يعالج Android ذلك نيابةً عنك باستخدام AIDL.

ملاحظة: لغة AIDL ضرورية فقط إذا كنت تسمح للعملاء من تطبيقات مختلفة بالوصول إلى خدمتك من أجل الاتصال بين العمليات (IPC) وتريد التعامل مع سلاسل المحادثات المتعدّدة في خدمتك. إذا لم تكن بحاجة إلى إجراء اتصال بين العمليات (IPC) بشكل متزامن في تطبيقات مختلفة، يمكنك إنشاء واجهتك من خلال تنفيذ Binder. إذا أردت تنفيذ الاتصال بين العمليات ولكنك لا تحتاج إلى التعامل مع سلاسل التعليمات المتعددة، يمكنك تنفيذ واجهتك باستخدام Messenger. بغض النظر عن ذلك، تأكَّد من فهم خدمات الربط قبل تنفيذ لغة AIDL.

قبل البدء في تصميم واجهة AIDL، يجب أن تدرك أن الاستدعاءات لواجهة AIDL هي استدعاءات دالة مباشرة. لا تضع افتراضات حول سلسلة المحادثات التي يتم فيها إجراء المكالمة. يختلف ما يحدث اعتمادًا على ما إذا كان الاستدعاء من سلسلة عمليات في العملية المحلية أو عملية بعيدة:

  • يتم تنفيذ المكالمات التي يتم إجراؤها من العملية المحلية في سلسلة المحادثات نفسها التي تجري المكالمة. إذا كانت هذه هي سلسلة واجهة المستخدم الرئيسية، فستستمر هذه السلسلة في التنفيذ في واجهة AIDL. إذا كان مؤشر ترابط آخر، فهذا هو الذي ينفذ التعليمات البرمجية الخاصة بك في الخدمة. وبالتالي، إذا كانت سلاسل المحادثات المحلية فقط هي التي تصل إلى الخدمة، يمكنك التحكم بشكل كامل في سلاسل المحادثات التي يتم تنفيذها فيها. ولكن إذا كان الأمر كذلك، لا تستخدِم AIDL على الإطلاق، بل أنشئ الواجهة من خلال تنفيذ Binder.
  • يتم إرسال المكالمات من عملية عن بُعد من مجموعة سلاسل محادثات يحتفظ بها النظام الأساسي داخل العملية الخاصة بك. استعِدّ لتلقّي مكالمات واردة من سلاسل محادثات غير معروفة، مع إجراء مكالمات متعددة في الوقت نفسه. بمعنى آخر، يجب أن يكون تنفيذ واجهة AIDL آمنًا تمامًا من حيث سلاسل المحادثات. تصل المكالمات التي يتم إجراؤها من سلسلة محادثات واحدة على الكائن البعيد نفسه بالترتيب إلى الطرف المستلِم.
  • تعدّل الكلمة الرئيسية oneway سلوك الطلبات عن بُعد. عند استخدامها، لا يتم حظر المكالمة عن بُعد. يتم إرسال بيانات المعاملة والعودة فورًا. يتلقّى تنفيذ الواجهة في النهاية هذا الطلب كمكالمة عادية من مجموعة سلاسل المحادثات Binder كمكالمة عادية عن بُعد. إذا تم استخدام oneway مع استدعاء محلي، لن يكون هناك أي تأثير، وسيظل الاستدعاء متزامنًا.

تعريف واجهة AIDL

يمكنك تحديد واجهة AIDL في ملف .aidl باستخدام بنية لغة برمجة Java، ثم حفظها في الرمز المصدر، في دليل src/، لكل من التطبيق الذي يستضيف الخدمة وأي تطبيق آخر يرتبط بالخدمة.

عند إنشاء كل تطبيق يحتوي على ملف .aidl، تنشئ أدوات حزمة تطوير البرامج (SDK) لنظام التشغيل Android واجهة IBinder استنادًا إلى ملف .aidl وتحفظها في دليل gen/ الخاص بالمشروع. يجب أن تنفّذ الخدمة واجهة IBinder على النحو المناسب. ويمكن بعد ذلك لتطبيقات العميل الربط بالخدمة واستدعاء الطرق من IBinder لتنفيذ الاتصال بين العمليات (IPC).

لإنشاء خدمة مرتبطة باستخدام AIDL، اتّبِع الخطوات التالية الموضّحة في الأقسام التالية:

  1. إنشاء ملف .aidl

    يحدّد هذا الملف واجهة البرمجة مع توقيعات الطرق.

  2. تنفيذ الواجهة

    تُنشئ أدوات حزمة تطوير البرامج (SDK) لنظام التشغيل Android واجهة بلغة برمجة Java استنادًا إلى ملف .aidl. تحتوي هذه الواجهة على فئة مجرّدة داخلية باسم Stub تعمل على توسيع نطاق Binder وتنفيذ طرق من واجهة AIDL. يجب توسيع الفئة Stub وتنفيذ الطرق.

  3. عرض الواجهة للعملاء

    نفِّذ Service وتجاوز onBind() لإرجاع تنفيذك لفئة Stub.

تنبيه: أي تغييرات تجريها على واجهة AIDL بعد الإصدار الأول يجب أن تظل متوافقة مع الأنظمة القديمة لتجنُّب تعطُّل التطبيقات الأخرى التي تستخدم خدمتك. بمعنى آخر، بما أنّه يجب نسخ ملف .aidl إلى تطبيقات أخرى لكي تتمكّن من الوصول إلى واجهة الخدمة، عليك مواصلة إتاحة الواجهة الأصلية.

إنشاء ملف ‎ .aidl

تستخدم لغة AIDL بنية بسيطة تتيح لك تعريف واجهة باستخدام طريقة واحدة أو أكثر يمكنها استخدام المَعلمات وعرض القيم. يمكن أن تكون المَعلمات والقيم المعروضة من أي نوع، حتى الواجهات الأخرى التي تم إنشاؤها باستخدام AIDL.

يجب إنشاء ملف .aidl باستخدام لغة البرمجة Java. يجب أن يحدّد كل ملف .aidl واجهة واحدة، ويتطلّب فقط تعريف الواجهة وتوقيعات الطريقة.

By default, AIDL supports the following data types:

  • جميع الأنواع الأساسية، باستثناء short، في لغة برمجة Java (مثل int وlong وchar وboolean وما إلى ذلك)
  • مصفوفات من أي نوع، مثل int[] أو MyParcelable[]
  • String
  • CharSequence
  • List

    يجب أن تكون جميع العناصر في List أحد أنواع البيانات المتوافقة في هذه القائمة أو إحدى الواجهات الأخرى التي تم إنشاؤها من خلال AIDL أو العناصر القابلة للتقسيم التي تعلن عنها. يمكن استخدام List بشكل اختياري كفئة نوع ذات معلَمات، مثل List<String>. إنّ الفئة الملموسة الفعلية التي يتلقّاها الطرف الآخر هي دائمًا ArrayList، على الرغم من أنّ الطريقة يتم إنشاؤها لاستخدام واجهة List.

  • Map

    يجب أن تكون جميع العناصر في Map أحد أنواع البيانات المتوافقة في هذه القائمة أو إحدى الواجهات الأخرى التي تم إنشاؤها من خلال AIDL أو العناصر القابلة للتقسيم التي تعلن عنها. لا يمكن استخدام خرائط الأنواع ذات المَعلمات، مثل تلك التي تكون على شكل Map<String,Integer>. إنّ الفئة الملموسة الفعلية التي يتلقّاها الطرف الآخر هي دائمًا HashMap، على الرغم من أنّه يتم إنشاء الطريقة لاستخدام واجهة Map. ننصحك باستخدام Bundle كبديل لـ Map.

يجب تضمين عبارة import لكل نوع إضافي غير مدرَج سابقًا، حتى إذا تم تحديده في الحزمة نفسها مثل الواجهة.

عند تحديد واجهة الخدمة، يُرجى مراعاة ما يلي:

  • يمكن أن تأخذ الطرق صفرًا أو أكثر من المَعلمات ويمكن أن تعرض قيمة أو لا تعرض أي قيمة.
  • تتطلّب جميع المَعلمات غير الأساسية علامة اتجاهية تشير إلى اتجاه البيانات: in أو out أو inout (راجِع المثال أدناه).

    تكون العناصر الأساسية وString وIBinder والواجهات التي تم إنشاؤها باستخدام لغة AIDL in تلقائيًا ولا يمكن تغيير ذلك.

    تنبيه: يجب حصر الاتجاه على ما هو مطلوب حقًا، لأنّ معلمات التنظيم مكلفة.

  • يتم تضمين جميع تعليقات الرموز المضمّنة في ملف .aidl في واجهة IBinder التي تم إنشاؤها باستثناء التعليقات قبل عبارات الاستيراد والحزمة.
  • يمكن تحديد ثوابت السلسلة والأعداد الصحيحة في واجهة AIDL، مثل const int VERSION = 1;.
  • يتم إرسال طلبات الإجراءات من خلال transact() رمز، والذي يستند عادةً إلى فهرس الإجراءات في الواجهة. بما أنّ ذلك يجعل تحديد الإصدارات أمرًا صعبًا، يمكنك تخصيص رمز المعاملة يدويًا لإحدى الطرق: void method() = 10;.
  • يجب إضافة تعليقات توضيحية إلى الوسيطات وأنواع القيم التي تم إرجاعها والتي يمكن أن تكون فارغة باستخدام @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"، سيُنشئ الإصدار المتزايد فئة الربط على الفور تقريبًا. إذا لم تكن تستخدم "استوديو Android"، ستُنشئ أداة Gradle فئة الربط في المرة التالية التي تُنشئ فيها تطبيقك. يمكنك إنشاء مشروعك باستخدام gradle assembleDebug أو gradle assembleRelease فور الانتهاء من كتابة ملف .aidl، ليتمكّن الرمز البرمجي من الربط بالفئة التي تم إنشاؤها.

تنفيذ الواجهة

عند إنشاء تطبيقك، تنشئ أدوات حزمة تطوير البرامج (SDK) لنظام التشغيل Android ملف واجهة .java يحمل اسم ملف .aidl. تتضمّن الواجهة التي تم إنشاؤها فئة فرعية باسم Stub، وهي تنفيذ مجرّد لواجهتها الرئيسية، مثل YourInterface.Stub، وتُعلن عن جميع الطرق من ملف .aidl.

ملاحظة: يحدّد Stub أيضًا بعض الطرق المساعدة، وأبرزها asInterface()، التي تأخذ IBinder، عادةً ما يتم تمريرها إلى طريقة رد الاتصال onServiceConnected() للعميل، وتعرض مثيلاً لواجهة stub. لمزيد من التفاصيل حول كيفية إجراء هذا التحويل، يُرجى الاطّلاع على قسم استدعاء طريقة 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:

  • لا نضمن تنفيذ المكالمات الواردة في سلسلة التعليمات الرئيسية، لذا عليك التفكير في تعدد سلاسل التعليمات من البداية وإنشاء الخدمة بشكل صحيح لتكون آمنة لسلاسل التعليمات.
  • By default, IPC calls are synchronous. إذا كنت تعلم أنّ الخدمة تستغرق أكثر من بضع مللي ثانية لإكمال طلب، لا تستدعيها من سلسلة المحادثات الرئيسية للنشاط. قد يؤدي ذلك إلى توقّف التطبيق عن العمل، ما يؤدي إلى عرض 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() للاتصال بهذه الخدمة، يتلقّى رد الاتصال onServiceConnected() الخاص بالعميل مثيل binder الذي تعرضه طريقة onBind() للخدمة.

يجب أن يكون لدى العميل أيضًا إذن وصول إلى فئة الواجهة. لذلك، إذا كان العميل والخدمة في تطبيقَين منفصلَين، يجب أن يحتوي تطبيق العميل على نسخة من ملف .aidl في دليل src/، ما يؤدي إلى إنشاء واجهة android.os.Binder، ما يتيح للعميل الوصول إلى طرق AIDL.

عندما يتلقّى العميل IBinder في ردّ الاتصال 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 (مستوى واجهة برمجة التطبيقات 29 أو مستوى أعلى)، يمكنك تحديد عناصر Parcelable مباشرةً في AIDL. ويمكن أيضًا استخدام الأنواع المتوافقة كوسيطات لواجهة AIDL وغيرها من الأنواع القابلة للتقسيم. يؤدي ذلك إلى تجنُّب العمل الإضافي لكتابة رمز التنظيم يدويًا وفئة مخصّصة. ومع ذلك، يؤدي هذا أيضًا إلى إنشاء بنية فارغة. إذا أردت استخدام دوال استرداد القيمة المخصّصة أو وظائف أخرى، يمكنك استخدام 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، اتّبِع الخطوات التالية:

  1. اجعل صفك ينفّذ واجهة Parcelable.
  2. نفِّذ writeToParcel، الذي يأخذ الحالة الحالية للكائن ويكتبها في Parcel.
  3. أضِف حقلاً ثابتًا باسم CREATOR إلى فئتك، وهو عنصر ينفّذ واجهة Parcelable.Creator.
  4. أخيرًا، أنشِئ ملف .aidl يعرّف فئة parcelable، كما هو موضّح في ملف Rect.aidl التالي.

    إذا كنت تستخدم عملية إنشاء مخصّصة، لا تُضِف ملف .aidl إلى الإصدار. على غرار ملف العنوان في لغة 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 من المتوقّع أن يحتوي على عناصر قابلة للتقسيم، تأكَّد من ضبط أداة تحميل الفئات في Bundle من خلال استدعاء Bundle.setClassLoader(ClassLoader) قبل محاولة القراءة من Bundle. وإلا، فستواجه ClassNotFoundException على الرغم من تحديد العنصر القابل للتجزئة بشكل صحيح في تطبيقك.

على سبيل المثال، إليك نموذج ملف .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، اتّبِع الخطوات التالية في فئة الاستدعاء:

  1. أدرِج ملف .aidl في دليل المشروع src/.
  2. يجب الإعلان عن مثيل لواجهة IBinder، والتي يتم إنشاؤها استنادًا إلى AIDL.
  3. تنفيذ ServiceConnection
  4. استدعِ Context.bindService()، مع تمرير تنفيذ ServiceConnection.
  5. في عملية تنفيذ onServiceConnected()، ستتلقّى مثيل IBinder يُسمى service. يُرجى استدعاء YourInterfaceName.Stub.asInterface((IBinder)service) لتحويل المَعلمة المعروضة إلى النوع YourInterface.
  6. استدعِ الطرق التي حدّدتها في الواجهة. يجب دائمًا رصد استثناءات DeadObjectException التي يتم طرحها عند انقطاع الاتصال. يمكنك أيضًا رصد استثناءات SecurityException التي يتم طرحها عندما يكون للعمليتين المتعلقتين بطلب إجراء IPC تعريفات AIDL متعارضة.
  7. لإلغاء الربط، يمكنك استدعاء 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&mdash;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)
            }
        }
    }
}