نظرة عامة حول الخدمات

Service هو مكوّن تطبيق يمكنه تنفيذ عمليات طويلة في الخلفية. ولا يوفّر واجهة مستخدم. بعد بدء الخدمة، قد يستمر تشغيلها لبعض الوقت، حتى بعد انتقال المستخدم إلى تطبيق آخر. بالإضافة إلى ذلك، يمكن ربط مكوّن بخدمة للتفاعل معها وحتى إجراء التواصل البيني للعمليات (IPC). على سبيل المثال، يمكن للخدمة معالجة معاملات الشبكة أو تشغيل الموسيقى أو إجراء عمليات الإدخال/الإخراج للملفات أو التفاعل مع أداة توفير المحتوى، وكل ذلك في الخلفية.

تنبيه: يتم تشغيل الخدمة في سلسلة التعليمات الرئيسية لعملية الاستضافة ، ولا تنشئ الخدمة سلسلة تعليمات خاصة بها ولا يتم تشغيلها في عملية منفصلة ما لم تحدد خلاف ذلك. يجب تنفيذ أي عمليات حظر على سلسلة محادثات منفصلة داخل الخدمة لتجنُّب أخطاء "التطبيق لا يستجيب" (ANR).

أنواع الخدمات

في ما يلي الأنواع الثلاثة المختلفة من الخدمات:

واجهة

تنفّذ الخدمة التي تعمل في المقدّمة بعض العمليات التي يلاحظها المستخدم. على سبيل المثال، يستخدم تطبيق صوتي خدمة تعمل في المقدّمة لتشغيل مقطع صوتي. يجب أن تعرض الخدمات التي تعمل في المقدّمة إشعارًا. تستمر الخدمات التي تعمل في المقدّمة في العمل حتى عندما لا يتفاعل المستخدم مع التطبيق.

عند استخدام خدمة تعمل في المقدّمة، يجب عرض إشعار لكي يدرك المستخدمون أنّ الخدمة قيد التشغيل. لا يمكن إغلاق هذا الإشعار إلا إذا تم إيقاف الخدمة أو إزالتها من المقدّمة.

مزيد من المعلومات حول كيفية ضبط الخدمات التي تعمل في المقدّمة في تطبيقك

ملاحظة: توفّر واجهة برمجة التطبيقات WorkManager طريقة مرنة لجدولة المهام، ويمكنها تشغيل هذه المهام كخدمات تعمل في المقدّمة إذا لزم الأمر. في كثير من الحالات، يُفضَّل استخدام WorkManager بدلاً من استخدام الخدمات التي تعمل في المقدّمة مباشرةً.

خلفية
تنفِّذ خدمة تُشغَّل في الخلفية عملية لا يلاحظها المستخدم مباشرةً. على سبيل المثال، إذا استخدم أحد التطبيقات خدمة لضغط مساحة التخزين، ستكون هذه الخدمة عادةً خدمة تُشغَّل في الخلفية.

ملاحظة: إذا كان تطبيقك يستهدف المستوى 26 أو أعلى لواجهة برمجة التطبيقات، يفرض النظام قيودًا على تشغيل الخدمات في الخلفية عندما لا يكون التطبيق نفسه قيد التشغيل في المقدّمة. في معظم الحالات، على سبيل المثال، يجب عدم الوصول إلى معلومات عن الموقع الجغرافي للجهاز من الخلفية. بدلاً من ذلك، يمكنك جدولة المهام باستخدام WorkManager.

مربوطة
تكون الخدمة مرتبطة عندما يرتبط بها مكوّن تطبيق من خلال استدعاء bindService(). توفّر خدمة الربط واجهة بين العميل والخادم تتيح للمكوّنات التفاعل مع الخدمة وإرسال الطلبات وتلقّي النتائج، وحتى إجراء ذلك على مستوى العمليات من خلال التواصل البيني للعمليات (IPC). لا تعمل خدمة الربط إلا طالما أنّ هناك مكوّن تطبيق آخر مرتبطًا بها. يمكن ربط مكوّنات متعددة بالخدمة في الوقت نفسه، ولكن عند إلغاء ربطها جميعًا، يتم إنهاء الخدمة.

على الرغم من أنّ هذه المستندات تناقش بشكل عام الخدمات التي تم تشغيلها والخدمات المرتبطة بشكل منفصل، يمكن أن تعمل خدمتك في كلا الاتجاهين، فيمكن تشغيلها (لتعمل إلى أجل غير مسمى) وتسمح أيضًا بالربط. يتعلّق الأمر ببساطة بما إذا كنت ستنفّذ طريقتَي رد اتصال: onStartCommand() للسماح للمكوّنات ببدء الخدمة وonBind() للسماح بالربط.

بغض النظر عما إذا كانت الخدمة قد بدأت أو تم ربطها أو كليهما، يمكن لأي مكوّن تطبيق استخدام الخدمة (حتى من تطبيق منفصل) بالطريقة نفسها التي يمكن لأي مكوّن استخدام نشاط بها، وذلك من خلال بدئها باستخدام Intent. ومع ذلك، يمكنك الإعلان عن الخدمة على أنّها خاصة في ملف البيان وحظر الوصول إليها من التطبيقات الأخرى. يمكنك الاطّلاع على مزيد من المعلومات في القسم حول تعريف الخدمة في ملف البيان.

الاختيار بين الخدمة والمؤشر

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

إذا كان عليك تنفيذ عمل خارج سلسلة التعليمات الرئيسية، ولكن فقط أثناء تفاعل المستخدم مع تطبيقك، عليك بدلاً من ذلك إنشاء سلسلة تعليمات جديدة في سياق مكوّن تطبيق آخر. على سبيل المثال، إذا أردت تشغيل بعض الموسيقى، ولكن فقط أثناء تشغيل نشاطك، يمكنك إنشاء سلسلة محادثات في onCreate()، وبدء تشغيلها في onStart()، وإيقافها في onStop(). ننصحك أيضًا باستخدام مجموعات سلاسل المحادثات والمنفّذين من حزمة java.util.concurrent أو روتينات Kotlin المشتركة بدلاً من فئة Thread التقليدية. يُرجى الاطّلاع على مستند Threading on Android (المعالجة على Android) لمزيد من المعلومات حول نقل التنفيذ إلى سلاسل مهام في الخلفية.

يُرجى العِلم أنّه في حال استخدام خدمة، ستظلّ تعمل في سلسلة التعليمات الرئيسية لتطبيقك بشكل تلقائي، لذا عليك إنشاء سلسلة تعليمات جديدة ضمن الخدمة إذا كانت تنفّذ عمليات مكثّفة أو عمليات حظر.

الأساسيات

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

onStartCommand()
يستدعي النظام هذه الطريقة من خلال استدعاء startService() عندما يطلب مكوّن آخر (مثل نشاط) بدء الخدمة. عند تنفيذ هذه الطريقة، يتم بدء الخدمة ويمكن تشغيلها في الخلفية إلى أجل غير مسمى. إذا نفّذت ذلك، تقع على عاتقك مسؤولية إيقاف الخدمة عند اكتمال عملها من خلال استدعاء stopSelf() أو stopService(). إذا أردت توفير الربط فقط، لن تحتاج إلى تنفيذ هذه الطريقة.
onBind()
يستدعي النظام هذه الطريقة من خلال استدعاء bindService() عندما يريد مكوّن آخر الربط بالخدمة (مثل تنفيذ استدعاء الإجراء عن بُعد). في عملية تنفيذ هذه الطريقة، يجب توفير واجهة يستخدمها العملاء للتواصل مع الخدمة من خلال عرض IBinder. يجب دائمًا تنفيذ هذه الطريقة، ولكن إذا كنت لا تريد السماح بالربط، يجب عرض قيمة فارغة.
onCreate()
يستدعي النظام هذه الطريقة لتنفيذ إجراءات الإعداد لمرة واحدة عند إنشاء الخدمة في البداية (قبل استدعاء onStartCommand() أو onBind()). إذا كانت الخدمة قيد التشغيل، لن يتم استدعاء هذه الطريقة.
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 هي السمة الوحيدة المطلوبة، وهي تحدّد اسم فئة الخدمة. بعد نشر تطبيقك، اترك هذا الاسم بدون تغيير لتجنُّب خطر تعطُّل الرمز البرمجي بسبب الاعتماد على الأهداف الصريحة لبدء الخدمة أو ربطها (اقرأ منشور المدوّنة، الأمور التي لا يمكن تغييرها).

تنبيه: لضمان أمان تطبيقك، استخدِم دائمًا explicit intent عند بدء Service ولا تُعلن عن intent filter لخدماتك. يُعدّ استخدام هدف ضمني لبدء خدمة خطرًا أمنيًا لأنّه لا يمكنك التأكّد من الخدمة التي تستجيب للهدف، ولا يمكن للمستخدم معرفة الخدمة التي تبدأ. اعتبارًا من الإصدار 5.0 من نظام التشغيل Android (المستوى 21 لواجهة برمجة التطبيقات)، يعرض النظام استثناءً إذا طلبت bindService() باستخدام نية ضمنية.

يمكنك التأكّد من أنّ خدمتك متاحة لتطبيقك فقط من خلال تضمين السمة android:exported وضبطها على false. يؤدي ذلك إلى منع التطبيقات الأخرى من بدء خدمتك، حتى عند استخدام نية صريحة.

ملاحظة: يمكن للمستخدمين الاطّلاع على الخدمات التي يتم تشغيلها على أجهزتهم. وإذا ظهرت لهم خدمة لا يعرفونها أو لا يثقون بها، يمكنهم إيقافها. لتجنُّب إيقاف الخدمة عن طريق الخطأ من قِبل المستخدمين، عليك إضافة السمة android:description إلى العنصر <service> في بيان التطبيق. في الوصف، يُرجى تقديم جملة قصيرة توضّح وظيفة الخدمة والمزايا التي توفّرها.

إنشاء خدمة قيد التشغيل

الخدمة التي تم تشغيلها هي خدمة يبدأها مكوّن آخر من خلال استدعاء startService()، ما يؤدي إلى استدعاء طريقة onStartCommand() للخدمة.

عند بدء خدمة، يكون لها دورة حياة مستقلة عن المكوّن الذي بدأها. يمكن تشغيل الخدمة في الخلفية إلى أجل غير مسمى، حتى إذا تم تدمير المكون الذي بدأها. لذلك، يجب أن تتوقف الخدمة من تلقاء نفسها عند اكتمال مهمتها من خلال استدعاء stopSelf()، أو يمكن لمكوّن آخر إيقافها من خلال استدعاء stopService().

يمكن لأحد مكوّنات التطبيق، مثل نشاط معيّن، بدء الخدمة من خلال استدعاء startService() وتمرير Intent يحدّد الخدمة ويتضمّن أي بيانات لتستخدمها الخدمة. تتلقّى الخدمة هذا الـ Intent في طريقة onStartCommand().

على سبيل المثال، لنفترض أن نشاطًا ما يحتاج إلى حفظ بعض البيانات في قاعدة بيانات على الإنترنت. يمكن أن يبدأ النشاط خدمة مصاحبة وينقل إليها البيانات لحفظها من خلال تمرير نية إلى startService(). تتلقّى الخدمة الطلب في onStartCommand()، وتتصل بالإنترنت، وتنفّذ معاملة قاعدة البيانات. عند اكتمال المعاملة، تتوقف الخدمة من تلقاء نفسها ويتم تدميرها.

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

صنف Service هو الصنف الأساسي لجميع الخدمات. عند توسيع هذه الفئة، من المهم إنشاء سلسلة محادثات جديدة يمكن للخدمة من خلالها إكمال جميع أعمالها، حيث تستخدم الخدمة سلسلة المحادثات الرئيسية لتطبيقك بشكل تلقائي، ما قد يؤدي إلى إبطاء أداء أي نشاط يشغّله تطبيقك.

يوفّر إطار عمل Android أيضًا الفئة الفرعية IntentService من Service التي تستخدم سلسلة الوحدات العاملة (worker thread) لمعالجة جميع طلبات البدء، واحدًا تلو الآخر. لا يُنصح باستخدام هذه الفئة في التطبيقات الجديدة لأنّها لن تعمل بشكل جيد بدءًا من الإصدار Android 8 Oreo، وذلك بسبب طرح حدود التنفيذ في الخلفية. بالإضافة إلى ذلك، تم إيقافها نهائيًا اعتبارًا من Android 11. يمكنك استخدام JobIntentService كبديل لـ IntentService المتوافق مع الإصدارات الأحدث من Android.

توضّح الأقسام التالية كيفية تنفيذ الخدمة المخصّصة، ولكن ننصحك بشدة باستخدام WorkManager في معظم حالات الاستخدام. يمكنك الرجوع إلى دليل المعالجة في الخلفية على Android لمعرفة ما إذا كان هناك حلّ يناسب احتياجاتك.

توسيع فئة الخدمة

يمكنك توسيع فئة Service للتعامل مع كل طلب وارد. في ما يلي مثال على عملية تنفيذ أساسية:

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 وتعالج جميع الطلبات بشكل تسلسلي، واحدًا تلو الآخر. يمكنك تغيير الرمز لتنفيذ العمل على مجموعة سلاسل محادثات، على سبيل المثال، إذا أردت تنفيذ طلبات متعددة في الوقت نفسه.

لاحظ أن طريقة onStartCommand() يجب أن ترجع عددًا صحيحًا. العدد الصحيح هو قيمة تصف كيف يجب أن يواصل النظام الخدمة في حال إنهاء النظام لها. يجب أن تكون القيمة المعروضة من onStartCommand() إحدى الثوابت التالية:

START_NOT_STICKY
إذا أنهى النظام الخدمة بعد عرض onStartCommand()، لا تُعِد إنشاء الخدمة ما لم تكن هناك intent مؤجّلة يجب عرضها. هذا الخيار هو الأكثر أمانًا لتجنُّب تشغيل الخدمة عندما لا يكون ذلك ضروريًا وعندما يتمكّن تطبيقك من إعادة تشغيل أي مهام غير مكتملة.
START_STICKY
إذا أنهى النظام الخدمة بعد عرض onStartCommand()، أعِد إنشاء الخدمة واستدعِ onStartCommand()، ولكن لا تُعِد تسليم آخر intent. بدلاً من ذلك، يستدعي النظام onStartCommand() باستخدام intent فارغ ما لم تكن هناك intent مؤجّلة لبدء الخدمة. في هذه الحالة، يتم تسليم هذه الأهداف. هذا الإجراء مناسب لمشغّلات الوسائط (أو الخدمات المشابهة) التي لا تنفّذ الأوامر ولكنّها تعمل إلى أجل غير مسمى وتنتظر مهمة.
START_REDELIVER_INTENT
إذا أنهى النظام الخدمة بعد عرض onStartCommand()، أعِد إنشاء الخدمة واستدعِ onStartCommand() باستخدام آخر intent تم تسليمه إلى الخدمة. ويتم إرسال أي intent مؤجّلة بالترتيب. هذا الخيار مناسب للخدمات التي تؤدي مهمة بشكل نشط يجب استئنافها على الفور، مثل تنزيل ملف.

لمزيد من التفاصيل حول قيم الإرجاع هذه، يُرجى الاطّلاع على مستندات المراجع المرتبطة لكل ثابت.

بدء خدمة

يمكنك بدء خدمة من نشاط أو مكوّن تطبيق آخر من خلال تمرير Intent إلى startService() أو startForegroundService(). يستدعي نظام Android طريقة onStartCommand() للخدمة ويمرّر إليها Intent، الذي يحدّد الخدمة التي يجب بدء تشغيلها.

ملاحظة: إذا كان تطبيقك يستهدف المستوى 26 من واجهة برمجة التطبيقات أو مستوى أعلى، يفرض النظام قيودًا على استخدام الخدمات التي تُشغَّل في الخلفية أو إنشائها ما لم يكن التطبيق نفسه قيد التشغيل في المقدّمة. إذا كان أحد التطبيقات بحاجة إلى إنشاء خدمة تعمل في المقدّمة، يجب أن يطلب التطبيق startForegroundService(). تنشئ هذه الطريقة خدمة تُشغَّل في الخلفية، ولكنّها تُرسل إشارة إلى النظام بأنّ الخدمة ستتم ترقيتها إلى المقدّمة. بعد إنشاء الخدمة، يجب أن تستدعي الخدمة الإجراء startForeground() في غضون خمس ثوانٍ.

على سبيل المثال، يمكن أن يبدأ نشاط ما الخدمة النموذجية في القسم السابق (HelloService) باستخدام نية صريحة مع startService()، كما هو موضّح هنا:

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

يتم عرض طريقة startService() على الفور، ويستدعي نظام Android طريقة onStartCommand() للخدمة. إذا لم تكن الخدمة قيد التشغيل، يستدعي النظام أولاً onCreate()، ثم يستدعي onStartCommand().

إذا لم توفّر الخدمة أيضًا الربط، يكون الغرض الذي يتم تسليمه مع startService() هو وضع الاتصال الوحيد بين مكوّن التطبيق والخدمة. ومع ذلك، إذا أردت أن ترسل الخدمة نتيجة، يمكن للعميل الذي يبدأ الخدمة إنشاء PendingIntent للبث (باستخدام getBroadcast()) وتسليمه إلى الخدمة في Intent الذي يبدأ الخدمة. يمكن للخدمة بعد ذلك استخدام البث لتقديم نتيجة.

تؤدي الطلبات المتعددة لبدء الخدمة إلى مكالمات متعددة مقابلة إلى onStartCommand() الخاصة بالخدمة. ومع ذلك، لإيقاف الخدمة، يجب إرسال طلب واحد فقط (باستخدام stopSelf() أو stopService()).

إيقاف خدمة

يجب أن تدير الخدمة التي تم تشغيلها مراحل نشاطها الخاصة. وهذا يعني أنّ النظام لا يوقف الخدمة أو يتلفها إلا إذا كان عليه استرداد ذاكرة النظام، وتستمر الخدمة في العمل بعد عرض onStartCommand(). يجب أن توقف الخدمة نفسها من خلال استدعاء stopSelf()، أو يمكن لمكوّن آخر إيقافها من خلال استدعاء stopService().

Once requested to stop with stopSelf() or stopService(), the system destroys the service as soon as possible.

إذا كانت خدمتك تعالج طلبات متعددة إلى onStartCommand() في الوقت نفسه، يجب عدم إيقاف الخدمة عند الانتهاء من معالجة طلب بدء، لأنّه من المحتمل أن تكون قد تلقّيت طلب بدء جديدًا (سيؤدي الإيقاف في نهاية الطلب الأول إلى إنهاء الطلب الثاني). لتجنُّب هذه المشكلة، يمكنك استخدام stopSelf(int) لضمان أن يكون طلبك لإيقاف الخدمة مستندًا دائمًا إلى أحدث طلب بدء. أي أنّه عند استدعاء stopSelf(int)، يتم تمرير معرّف طلب البدء (startId الذي تم تسليمه إلى onStartCommand()) الذي يتوافق معه طلب الإيقاف. بعد ذلك، إذا تلقت الخدمة طلب بدء جديدًا قبل أن تتمكن من استدعاء stopSelf(int)، فلن يتطابق المعرّف ولن تتوقف الخدمة.

تنبيه: لتجنُّب إهدار موارد النظام واستهلاك طاقة البطارية، تأكَّد من أنّ تطبيقك يوقف خدماته عند الانتهاء من العمل. إذا لزم الأمر، يمكن للمكوّنات الأخرى إيقاف الخدمة من خلال استدعاء stopService(). حتى إذا فعّلت الربط للخدمة، عليك دائمًا إيقاف الخدمة بنفسك إذا تلقّت مكالمة إلى onStartCommand().

لمزيد من المعلومات حول دورة حياة الخدمة، يُرجى الاطّلاع على القسم أدناه حول إدارة دورة حياة الخدمة.

إنشاء خدمة ربط

خدمة الربط هي خدمة تتيح لمكوّنات التطبيق الربط بها من خلال طلب bindService() لإنشاء اتصال طويل الأمد. ولا يسمح عادةً للمكوّنات ببدء تشغيله من خلال استدعاء startService().

يمكنك إنشاء خدمة ربط عندما تريد التفاعل مع الخدمة من الأنشطة والمكوّنات الأخرى في تطبيقك أو لعرض بعض وظائف تطبيقك للتطبيقات الأخرى من خلال التواصل البيني للعمليات (IPC).

لإنشاء خدمة ربط، يجب تنفيذ طريقة ردّ الاتصال onBind() لعرض IBinder يحدّد واجهة الاتصال بالخدمة. يمكن لمكوّنات التطبيق الأخرى بعد ذلك استدعاء bindService() لاسترداد الواجهة و بدء استدعاء الطرق في الخدمة. تستمر الخدمة فقط لخدمة مكوّن التطبيق المرتبط بها، لذلك عندما لا تكون هناك مكوّنات مرتبطة بالخدمة، يقوم النظام بتدميرها. لا تحتاج إلى إيقاف خدمة ربط بالطريقة نفسها التي يجب اتّباعها عند بدء الخدمة من خلال onStartCommand().

لإنشاء خدمة ربط، يجب تحديد الواجهة التي تحدّد كيفية تواصل العميل مع الخدمة. يجب أن تكون هذه الواجهة بين الخدمة والعميل تنفيذًا لـ IBinder، وهي ما يجب أن تعرضه الخدمة من طريقة رد الاتصال onBind(). بعد أن يتلقّى العميل IBinder، يمكنه بدء التفاعل مع الخدمة من خلال هذه الواجهة.

يمكن لعدة برامج ربط بالخدمة في الوقت نفسه. عندما ينتهي العميل من التفاعل مع الخدمة، يستدعي unbindService() لإلغاء الربط. وعندما لا يكون هناك عملاء مرتبطون بالخدمة، يتلف النظام الخدمة.

هناك عدة طرق لتنفيذ خدمة ربط، ويكون التنفيذ أكثر تعقيدًا من خدمة تم تشغيلها. لهذه الأسباب، تظهر مناقشة خدمة الربط في مستند منفصل حول خدمات الربط.

إرسال الإشعارات إلى المستخدم

عندما تكون الخدمة قيد التشغيل، يمكنها إرسال إشعارات للمستخدم بالأحداث باستخدام إشعارات شريط الإعلام المنبثق أو إشعارات شريط الحالة.

إشعار شريط الوجبات الخفيفة هو رسالة تظهر على سطح النافذة الحالية للحظة فقط قبل أن تختفي. يوفّر إشعار شريط الحالة رمزًا في شريط الحالة مع رسالة يمكن للمستخدم اختيارها من أجل اتخاذ إجراء (مثل بدء نشاط).

عادةً ما يكون إشعار شريط الحالة هو أفضل أسلوب يمكن استخدامه عند اكتمال العمل في الخلفية، مثل تنزيل ملف، ويمكن للمستخدم الآن اتخاذ إجراء بشأنه. عندما يختار المستخدم الإشعار من العرض الموسّع، يمكن أن يبدأ الإشعار نشاطًا (مثل عرض الملف الذي تم تنزيله).

إدارة دورة حياة الخدمة

دورة حياة الخدمة أبسط بكثير من دورة حياة النشاط. ومع ذلك، من المهم جدًا الانتباه إلى كيفية إنشاء الخدمة وإنهائها، لأنّ الخدمة يمكن أن تعمل في الخلفية بدون علم المستخدم.

يمكن أن تتبع دورة حياة الخدمة، من وقت إنشائها إلى وقت تدميرها، أحد هذين المسارين:

  • خدمة قيد التشغيل

    يتم إنشاء الخدمة عندما يستدعي مكوّن آخر startService(). بعد ذلك، يتم تشغيل الخدمة إلى أجل غير مسمى ويجب إيقافها من خلال استدعاء stopSelf(). ويمكن لمكوّن آخر أيضًا إيقاف الخدمة من خلال استدعاء stopService(). عند إيقاف الخدمة، يتلفها النظام.

  • خدمة ربط

    يتم إنشاء الخدمة عندما يستدعي مكوّن آخر (عميل) 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(). على سبيل المثال، يمكن لخدمة تشغيل الموسيقى إنشاء سلسلة المحادثات التي يتم تشغيل الموسيقى فيها في onCreate()، ثم يمكنها إيقاف سلسلة المحادثات في onDestroy().

    ملاحظة: يتم استدعاء الطريقتَين onCreate() وonDestroy() لجميع الخدمات، سواء تم إنشاؤها من خلال startService() أو bindService().

  • تبدأ مدة الخدمة النشطة باستدعاء onStartCommand() أو onBind(). يتم تسليم كل طريقة Intent التي تم تمريرها إلى startService() أو bindService().

    إذا تم بدء الخدمة، تنتهي مدة النشاط في الوقت نفسه الذي تنتهي فيه مدة الخدمة بالكامل (تظل الخدمة نشطة حتى بعد عرض onStartCommand()). إذا كانت الخدمة مرتبطة، تنتهي مدة النشاط عند عرض onUnbind().

ملاحظة: على الرغم من أنّ الخدمة التي تم تشغيلها يتم إيقافها من خلال استدعاء stopSelf() أو stopService()، لا تتوفّر دالة ردّ نداء للخدمة (لا تتوفّر دالة ردّ نداء onStop()). ما لم تكن الخدمة مرتبطة بعميل، سيتلفها النظام عند إيقاف الخدمة، ويكون onDestroy() هو رد الاتصال الوحيد الذي يتم تلقّيه.

لمزيد من المعلومات حول إنشاء خدمة توفّر الربط، يُرجى الاطّلاع على مستند خدمات الربط الذي يتضمّن مزيدًا من المعلومات حول طريقة ردّ الاتصال onRebind() في القسم المتعلّق بإدارة دورة حياة خدمة الربط.