Service یک
مؤلفه برنامه است که میتواند
عملیات طولانیمدت را در پسزمینه اجرا کند. این برنامه میانای کاربر ارائه نمیدهد. پساز شروع، سرویس ممکن است برای مدتی به اجرا ادامه دهد، حتی پساز اینکه کاربر به برنامه دیگری برود. علاوهبراین، یک مؤلفه میتواند به سرویسی متصل شود تا با آن تعامل داشته باشد و حتی ارتباط میان پردازشی (IPC) برقرار کند. برای مثال، یک سرویس میتواند تراکنشهای شبکه را مدیریت کند، موسیقی پخش کند، ورودی/خروجی فایل را انجام دهد، یا با ارائهدهنده محتوا تعامل داشته باشد، همه اینها از پسزمینه انجام میشود.
احتیاط: سرویس در رشته اصلی فرایند میزبان خود اجرا میشود؛ سرویس رشته خودش را ایجاد نمیکند و در فرایند جداگانهای اجرا نمیشود، مگراینکه شما طور دیگری مشخص کنید. باید هرگونه عملیات مسدودسازی را در رشتهای جداگانه در سرویس اجرا کنید تا از خطاهای «برنامه پاسخ نمیدهد» (ANR) جلوگیری شود.
انواع خدمات
این سه نوع مختلف خدمات عبارتاند از:
- پیشنما
-
سرویس پیشزمینهای عملیاتی را انجام میدهد که برای کاربر محسوس است. برای مثال، یک برنامه صوتی از سرویس پیشزمینهای برای پخش قطعه صوتی استفاده میکند. سرویسهای پیشزمینهای باید اعلان نمایش دهند. سرویسهای پیشزمینهای حتی زمانی که کاربر با برنامه تعامل ندارد، به اجرا ادامه میدهند.
وقتی از سرویس پیشزمینهای استفاده میکنید، باید اعلانی نمایش دهید تا کاربران بهطور فعال از اجرای سرویس مطلع شوند. این اعلان را نمیتوان بست مگراینکه سرویس متوقف شود یا از پیشزمینه برداشته شود.
درباره نحوه پیکربندی سرویسهای پیشزمینهای در برنامهتان بیشتر بدانید.
توجه: میانای برنامهسازی کاربردی WorkManager روشی انعطافپذیر برای زمانبندی تکالیف ارائه میدهد و درصورت نیاز میتواند این کارها را بهعنوان سرویسهای پیشزمینهای اجرا کند. در بسیاری از موارد، استفاده از WorkManager بر استفاده مستقیم از سرویسهای پیشزمینهای ترجیح دارد.
- پسزمینه
- سرویس پسزمینهای عملیاتی را انجام میدهد که مستقیماً توسط کاربر مشاهده نمیشود. برای مثال، اگر برنامهای از سرویسی برای فشردهسازی فضای ذخیرهسازیاش استفاده کند،
این سرویس معمولاً سرویس پسزمینهای است.
توجه: اگر برنامه شما سطح میانای برنامهسازی کاربردی ۲۶ یا بالاتر را هدف قرار دهد، سیستم محدودیتهایی را برای اجرای سرویسهای پسزمینهای زمانی که خود برنامه در پیشزمینه نیست، اعمال میکند. برای مثال، در اکثر شرایط نباید از پسزمینه به اطلاعات مکان دسترسی داشته باشید. درعوض، تکالیف را بااستفاده از WorkManager زمانبندی کنید.
- محدود
- سرویس زمانی محدود میشود که مؤلفه برنامه با فراخوانی
bindService()به آن محدود شود. سرویس محدودکننده یک میانای مشتری-سرور ارائه میدهد که به مؤلفهها اجازه میدهد با سرویس تعامل داشته باشند، درخواست ارسال کنند، نتایج را دریافت کنند، و حتی این کار را در بین فرایندها با ارتباط میانفرایندی (IPC) انجام دهند. خدمات محدودکننده فقط تا زمانی اجرا میشود که مؤلفه برنامه دیگری به آن محدود شده باشد. چند مؤلفه میتوانند بهطور همزمان به سرویس متصل شوند، اما وقتی همه آنها اتصالشان را قطع کنند، سرویس ازبین میرود.
اگرچه این مستندات بهطور کلی خدمات شروعشده و محدودکننده را بهطور جداگانه مورد بحث قرار میدهد،
سرویس شما میتواند به هر دو روش کار کند—میتواند شروع شود (تا بهطور نامحدود اجرا شود) و همچنین اجازه دهد
اتصال. این موضوع صرفاً به این بستگی دارد که آیا چند روش callback را پیادهسازی میکنید یا نه: onStartCommand() برای اینکه به مؤلفهها اجازه دهید آن را شروع کنند و onBind() برای اینکه اجازه اتصال دهید.
صرفنظر از اینکه سرویس شما شروع شده، مقید شده، یا هر دو، هر مؤلفه برنامه
میتواند از سرویس (حتی از یک برنامه جداگانه) به همان روشی که هر مؤلفه میتواند از
یک فعالیت استفاده کند، استفاده کند—با شروع آن با یک Intent. بااینحال، میتوانید
سرویس را در فایل مانیفست بهعنوان خصوصی اعلام کنید و دسترسی برنامههای دیگر را مسدود کنید.
این موضوع در بخش مربوط به اعلام سرویس در مانیفست بیشتر مورد بحث قرار گرفته است.
انتخاب بین سرویس و رشته
سرویس صرفاً مؤلفهای است که میتواند در پسزمینه اجرا شود، حتی زمانی که کاربر با برنامه شما تعامل ندارد، بنابراین فقط درصورتی باید سرویس ایجاد کنید که به آن نیاز داشته باشید.
اگر باید کاری را خارج از رشته اصلیتان انجام دهید، اما فقط زمانیکه کاربر با برنامهتان تعامل دارد، باید بهجای آن رشته جدیدی در زمینه مؤلفه برنامه دیگری ایجاد کنید. برای مثال، اگر میخواهید موسیقی پخش کنید، اما فقط زمانیکه فعالیتتان درحال اجرا است،
میتوانید رشتهای در onCreate() ایجاد کنید،
اجرای آن را در onStart() شروع کنید،
و آن را در onStop() متوقف کنید.
همچنین، استفاده از استخرهای رشته و اجراکنندهها از بسته java.util.concurrent
یا روالهای همزمان Kotlin را بهجای کلاس سنتی
Thread درنظر بگیرید. برای کسب اطلاعات بیشتر درباره انتقال اجرا به رشتههای پسزمینه، به سند
رشتهبندی در Android مراجعه کنید.
بهیاد داشته باشید که اگر از سرویسی استفاده میکنید، این سرویس همچنان بهطور پیشفرض در رشته اصلی برنامه شما اجرا میشود، بنابراین اگر سرویس عملیات فشرده یا مسدودکننده انجام میدهد، باید همچنان رشته جدیدی در سرویس ایجاد کنید.
اصول اولیه
برای ایجاد سرویس، باید زیرکلاسی از Service ایجاد کنید یا از یکی از زیرکلاسهای موجود آن استفاده کنید. در پیادهسازیتان، باید برخیاز روشهای بازگشت تماس را که
جنبههای کلیدی چرخه حیات سرویس را مدیریت میکنند لغو کنید و سازوکاری ارائه دهید که به مؤلفهها اجازه دهد
درصورت لزوم به سرویس متصل شوند. اینها مهمترین روشهای فراخوانی هستند که باید
لغو کنید:
onStartCommand()- وقتی مؤلفه دیگری (مثل فعالیت) درخواست شروع سرویس را میدهد، سیستم این روش را با فراخوانی
startService()اجرا میکند. وقتی این روش اجرا میشود، سرویس شروع میشود و میتواند بهطور نامحدود در پسزمینه اجرا شود. اگر این را پیادهسازی کنید، مسئولیت توقف سرویس پساز تکمیل کار آن با فراخوانیstopSelf()یاstopService()برعهده شما است. اگر فقط میخواهید اتصال را ارائه دهید، نیازی نیست این روش را پیادهسازی کنید. onBind()- وقتی مؤلفه دیگری میخواهد به سرویس متصل شود (مثلاً برای اجرای RPC)، سیستم این روش را با فراخوانی
bindService()اجرا میکند. در پیادهسازی این روش، باید واسطی ارائه دهید که مشتریان با برگرداندنIBinderاز آن برای برقراری ارتباط با سرویس استفاده کنند. همیشه باید این روش را پیادهسازی کنید؛ اما اگر نمیخواهید اتصال را مجاز کنید، باید null را برگردانید. 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 تنها مشخصه الزامی است—این مشخصه نام کلاس سرویس را تعیین میکند. پساز
انتشار برنامهتان، این نام را تغییر ندهید تا از خطر خراب شدن
کد بهدلیل وابستگی به هدفهای صریح برای شروع یا مقید کردن سرویس جلوگیری شود (پست وبلاگ مواردی
که نمیتوانند تغییر کنند را بخوانید).
احتیاط: برای اطمینان از ایمن بودن برنامهتان، همیشه هنگام شروع Service از قصد صریح استفاده کنید و فیلترهای قصد را برای سرویسهایتان اعلام نکنید. استفاده از هدف غیرصریح برای شروع سرویس خطری امنیتی است زیرا نمیتوانید
از سرویسی که به هدف پاسخ میدهد مطمئن باشید و کاربر نمیتواند ببیند کدام سرویس
شروع میشود. از Android 5.0 (سطح میانای برنامهسازی کاربردی ۲۱)، اگر
bindService() را با هدف ضمنی فراخوانی کنید، سیستم استثنایی را ایجاد میکند.
با گنجاندن مشخصه android:exported و تنظیم آن روی false میتوانید مطمئن شوید که سرویس شما فقط برای برنامه شما دردسترس است. این کار بهطور مؤثری مانع میشود برنامههای دیگر سرویس شما را راهاندازی کنند، حتی هنگام استفاده از هدف صریح.
توجه:
کاربران میتوانند ببینند چه سرویسهایی در دستگاهشان درحال اجرا است. اگر سرویسی را ببینند که نمیشناسند یا به آن اعتماد ندارند، میتوانند آن سرویس را متوقف کنند. برای
جلوگیری از توقف تصادفی سرویس توسط کاربران، باید
مشخصه
android:description
را به عنصر
<service>
در مانیفست برنامهتان اضافه کنید. در شرح،
جمله کوتاهی ارائه دهید که توضیح دهد این سرویس چه کاری انجام میدهد و چه مزایایی
ارائه میدهد.
درحال ایجاد سرویس شروعشده
سرویس شروعشده سرویسی است که مؤلفه دیگری با فراخوانی startService() آن را شروع میکند، که منجر به فراخوانی روش onStartCommand() سرویس میشود.
وقتی سرویسی شروع میشود، چرخه حیاتی دارد که مستقل از مؤلفهای است که آن را شروع کرده است. این سرویس میتواند بهطور نامحدود در پسزمینه اجرا شود، حتی اگر مؤلفهای که آن را راهاندازی کرده است ازبین برود. به همین دلیل، سرویس باید پساز تکمیل کارش با فراخوانی stopSelf() خودش را متوقف کند، یا مؤلفه دیگری میتواند با فراخوانی stopService() آن را متوقف کند.
مؤلفه برنامه، مثل فعالیت، میتواند با فراخوانی startService() و ارسال Intent، سرویس را شروع کند.
این مؤلفه سرویس را مشخص میکند و شامل دادههایی است که سرویس باید از آنها استفاده کند. سرویس این Intent را در روش onStartCommand() دریافت میکند.
برای مثال، فرض کنید فعالیتی باید برخی دادهها را در پایگاه داده آنلاین ذخیره کند. فعالیت
میتواند سرویس همراهی را شروع کند و دادهها را برای ذخیره کردن با ارسال هدف به startService() به آن تحویل دهد. سرویس هدف را در onStartCommand() دریافت میکند، به اینترنت متصل میشود، و تراکنش پایگاه داده را انجام میدهد. وقتی تراکنش کامل شد، سرویس خودش متوقف میشود و
ازبین میرود.
احتیاط: سرویس در همان فرایند برنامهای اجرا میشود که در آن اعلام شده است و بهطور پیشفرض در رشته اصلی آن برنامه اجرا میشود. اگر سرویس شما درحالیکه کاربر با فعالیتی از همان برنامه تعامل دارد، عملیات فشرده یا مسدودکننده انجام دهد، سرویس عملکرد فعالیت را کند میکند. برای جلوگیری از تأثیر بر عملکرد برنامه، رشته جدیدی را در سرویس شروع کنید.
کلاس Service کلاس پایه برای همه سرویسها است. وقتی این کلاس را گسترش میدهید، مهم است که رشته جدیدی ایجاد کنید که در آن
سرویس بتواند همه کارهایش را تکمیل کند؛ سرویس بهطور پیشفرض از رشته اصلی برنامهتان استفاده میکند که
میتواند عملکرد هر فعالیتی را که برنامهتان درحال اجرای آن است کند کند.
چارچوب Android همچنین زیرکلاس IntentService
Service را ارائه میدهد که از یک
رشته عامل برای رسیدگی به همه درخواستهای شروع، یکی پساز دیگری، استفاده میکند. استفاده از این کلاس برای برنامههای جدید توصیه نمیشود زیرا بهدلیل معرفی محدودیتهای اجرای پسزمینه، از Android 8 Oreo بهبعد بهخوبی کار نخواهد کرد.
علاوهبراین، از Android 11 منسوخ شده است.
میتوانید از JobIntentService بهعنوان جایگزینی برای IntentService استفاده کنید که با نسخههای جدیدتر Android سازگار است.
بخشهای زیر نحوه پیادهسازی سرویس سفارشی خودتان را شرح میدهند، اما برای اکثر موارد استفاده، اکیداً توصیه میشود بهجای آن از WorkManager استفاده کنید. به راهنمای پردازش پسزمینهای در Android مراجعه کنید تا ببینید آیا راهحلی متناسب با نیازهایتان وجود دارد یا نه.
گسترش کلاس Service
میتوانید کلاس 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()ازبین ببرد، سرویس را دوباره ایجاد نکنید، مگراینکه قصد معوقی برای ارائه وجود داشته باشد. این ایمنترین گزینه برای جلوگیری از اجرای سرویس شما در مواقع غیرضروری است و زمانی که برنامه شما میتواند بهسادگی هر کار ناتمامی را بازراهاندازی کند. START_STICKY- If the system kills the service after
onStartCommand()returns, recreate the service and callonStartCommand(), but do not redeliver the last intent. درعوض، سیستمonStartCommand()را با قصد تهی فراخوانی میکند، مگراینکه قصد معوقی برای شروع سرویس وجود داشته باشد. در این صورت، آن هدفها تحویل داده میشوند. این برای پخشکنندههای رسانه (یا سرویسهای مشابه) که فرمانی را اجرا نمیکنند اما بهطور نامحدود درحال اجرا هستند و منتظر کاری هستند مناسب است. START_REDELIVER_INTENT- If the system kills the service after
onStartCommand()returns, recreate the service and callonStartCommand()with the last intent that was delivered to the service. هر قصد معوقی بهنوبت تحویل داده میشود. این برای سرویسهایی مناسب است که فعالانه کاری را انجام میدهند که باید فوراً ازسر گرفته شود، مثل بارگیری فایل.
برای جزئیات بیشتر درباره این مقادیر برگشتی، به اسناد مرجع پیوندشده برای هر ثابت مراجعه کنید.
شروع کردن سرویس
میتوانید سرویسی را از فعالیت یا مؤلفه برنامه دیگری با ارسال
Intent
به startService() یا startForegroundService() شروع کنید. سیستم
Android روش onStartCommand() سرویس را فراخوانی میکند و Intent را به آن ارسال میکند،
که مشخص میکند کدام سرویس راهاندازی شود.
توجه: اگر برنامه شما سطح میانای برنامهسازی کاربردی ۲۶ یا بالاتر را هدف قرار دهد، سیستم
محدودیتهایی را برای استفاده یا ایجاد سرویسهای پسزمینهای اعمال میکند، مگراینکه خود برنامه
در پیشزمینه باشد. اگر برنامهای نیاز به ایجاد سرویس پیشزمینهای داشته باشد،
برنامه باید 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() آن را متوقف کند.
وقتی درخواست توقف با stopSelf() یا stopService() ارسال شود، سیستم در اسرع وقت سرویس را ازبین میبرد.
اگر سرویس شما چند درخواست را بهطور همزمان به 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 funonCreate() { // The service is being created } override funonStartCommand(intent: Intent?, flags: Int, startId: Int): Int { // The service is starting, due to a call to startService() return startMode } override funonBind(intent: Intent): IBinder? { // A client is binding to the service with bindService() return binder } override funonUnbind(intent: Intent): Boolean { // All clients have unbound with unbindService() return allowRebind } override funonRebind(intent: Intent) { // A client is binding to the service with bindService(), // after onUnbind() has already been called } override funonDestroy() { // The service is no longer used and is being destroyed } }
توجه: برخلاف روشهای فراخوانی چرخه حیات فعالیت، لازم نیست پیادهسازی ابرکلاس این روشهای فراخوانی را فراخوانی کنید.
شکل ۲. چرخه حیات سرویس. نمودار سمت راست چرخه حیات را وقتی سرویس با startService() ایجاد میشود نشان میدهد و نمودار سمت چپ چرخه حیات را وقتی سرویس با bindService() ایجاد میشود نشان میدهد.
شکل ۲ روشهای فراخوانی معمول برای یک سرویس را نشان میدهد. اگرچه این شکل سرویسهایی را که توسط 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()
در بخش مربوط به مدیریت چرخه حیات
یک سرویس متصل است.