مدیریت lifecycle سرویس - در برنامه نویسی اندروید

lifecycle یک سرویس بسیار ساده تر از یک اکتیویتی است. با این حال، مهم تر است که به نحوه ایجاد و نابودی سرویس خود توجه کنید زیرا یک سرویس می تواند بدون اطلاع کاربر در پس زمینه اجرا شود.

روش های اجرای سرویس

چرخه عمر سرویس – از زمانی که ایجاد می شود تا زمانی که از بین می رود – می تواند یکی از این دو مسیر را دنبال کند:

• یک سرویس شروع شده
  این سرویس زمانی ایجاد می شود که مؤلفه دیگری متد startService() را فراخوانی میکند. سپس سرویس به طور نامحدود اجرا می شود و باید با فراخوانی متد stopSelf() خود را متوقف کند. مؤلفه دیگری نیز می تواند با فراخوانی stopService() سرویس را متوقف کند. هنگامی که سرویس متوقف می شود، سیستم آن را از بین می برد و از حافظه خارج میشود.
• یک سرویس متصل شونده
  این سرویس زمانی ایجاد می شود که مؤلفه دیگری (یک کلاینت) متد bindService() را فراخوانی کند. سپس کلاینت از طریق رابط IBinder با سرویس ارتباط برقرار می کند. کلاینت می تواند با فراخوانی متد ()unbindService اتصال را ببندد. چندین کلاینت می توانند به یک سرویس متصل شوند و وقتی همه آنها از هم جدا شوند، سیستم سرویس را از بین می برد و از حافظه خارج میشود. این سرویس نیازی به توقف خود ندارد.

این دو مسیر کاملاً از هم جدا نیستند. می توانید به سرویسی متصل شوید که قبلاً با متد startService() شروع شده است. به عنوان مثال، می‌توانید با فراخوانی متد startService() یک سرویس موسیقی پس‌زمینه را با یک Intent راه‌اندازی کنید که موسیقی برای پخش را مشخص می‌کند. بعداً، احتمالاً وقتی کاربر می‌خواهد کنترلی روی پخش‌کننده اعمال کند یا اطلاعاتی درباره آهنگ فعلی به دست آورد، یک اکتیویتی می‌تواند با فراخوانی متد bindService() به سرویس متصل شود. در مواردی مانند این، متد stopService() یا متد stopSelf() در واقع سرویس را متوقف نمی کنند تا زمانی که همه کلاینت ها اتصال خود را ببندند.

پیاده سازی callbackهای چرخه عمر سرویس

مانند یک اکتیویتی، یک سرویس دارای متدهای callback چرخه حیات می باشند که می‌توانید برای نظارت بر تغییرات در وضعیت سرویس و انجام کار در زمان‌های مناسب، آن‌ها را پیاده‌سازی کنید. ساختار سرویس پایین هر یک از متد های چرخه عمر را نشان می دهد:

public class ExampleService extends Service {
    int startMode;       // نشان می دهد که در صورت کشته شدن سرویس چگونه باید رفتار کرد
    IBinder binder;      // رابط برای کلاینت های که متصل می شوند
    boolean allowRebind; // نشان می دهد که آیا onRebind باید استفاده شود یا خیر

    @Override
    public void onCreate() {
        // سرویس در حال ایجاد است
    }
    @Override
    public int onStartCommand(Intent intent, int flags, int startId) {
        // به دلیل صدا زدن این سرویس با متد startService() سرویس در حال شروع است.
        return startMode;
    }
    @Override
    public IBinder onBind(Intent intent) {
        // یک کلاینت با متد  bindService() به سرویس متصل می شود
        return binder;
    }
    @Override
    public boolean onUnbind(Intent intent) {
        // تمامی کلاینت ها از سرویس با فراخوانی متد unbindService() جدا شده اند.
        return allowRebind;
    }
    @Override
    public void onRebind(Intent intent) {
        // یک کلاینت در حال اتصال به سرویس با متد bindService() می باشند.
        // پس از اینکه متد  ()onUnbind قبلا فراخوانی شده است
    }
    @Override
    public void onDestroy() {
        // این سرویس دیگر استفاده نمی شود و در حال نابودی است
    }
}

توجه: بر خلاف روش‌های برگشت فراخوان چرخه حیات فعالیت، شما نیازی به فراخوانی اجرای سوپرکلاس این متدهای برگشتی ندارید.

چرخه عمر

در تصویر بالا نمودار سمت چپ lifecycle سرویس برای زمانی می باشد که سرویس با متد startService() اجرا میشود. و نمودار سمت راست lifecycle سرویس برای زمانی است که سرویس با متد bindService() اجرا میشود. شکل بالا متدهای معمولی callbackهایی را برای یک سرویس نشان می دهد. اگرچه این شکل سرویس‌هایی را که توسط متد startService ایجاد می‌شوند از سرویس‌هایی که توسط متد bindService ایجاد می‌شوند جدا می‌کند، اما به خاطر داشته باشید که هر سرویس، مهم نیست که چگونه شروع شده باشد، در هر حالت به کلاینت ها اجازه اتصال به خود را میدهد.

سرویسی که در ابتدا با متد onStartCommand() (توسط کلاینتی که متد startService() را فراخوانی می‌کند) هنوز می‌تواند یک فراخوانی با متد onBind() را دریافت کند (زمانی که کلاینت متد ()bindService را صدا میزند).

نظارت بر چرخه عمر سرویس

با اجرای این متدها، می توانید این دو حلقه تودرتو چرخه عمر سرویس را نظارت کنید:

• کل طول عمر یک سرویس بین زمانی که متد onCreate() فراخوانی می شود و زمانی که متد ()onDestroy فراخوانی میشود است. مانند یک اکتیویتی، یک سرویس تنظیمات اولیه خود را در onCreate() انجام می دهد و تمام منابع باقی مانده را در onDestroy() آزاد می کند. به عنوان مثال، یک سرویس پخش موسیقی می تواند تردی را ایجاد کند که در آن موسیقی در onCreate() پخش می شود و سپس می تواند ترد را در onDestroy() متوقف کند.
• طول عمر فعال یک سرویس با فراخوانی متد ()onStartCommand یا ()onBind آغاز می شود. برای هر متد یک Intent بعنوان پارامتر ورودی ارسال میشود که برای متد startService() یا bindService() ارسال میشود. اگر سرویس راه اندازی شده باشد، طول عمر فعال در همان زمانی به پایان میرسد که کل عمر سرویس به پایان میرسد (سرویس حتی پس از بازگشت نتیجه متد onStartCommand() همچنان فعال است). اگر سرویس محدود باشد، با بازگشت نتیجه متد ()onUnbind، عمر فعال سرویس به پایان می رسد.

توجه: متدهای onCreate() و onDestroy() برای همه سرویس ها فراخوانی می شوند، خواه توسط متد startService() یا bindService() اجرا شده باشد.

توجه: اگرچه یک سرویس شروع شده با فراخوانی متد stopSelf() یا stopService() متوقف می شود. پاسخ فراخوانی مربوطه ای برای سرویس وجود ندارد (هیچ پاسخ فراخوانی برای متد onStop وجود ندارد). مگر اینکه سرویس به یک کلاینت متصل باشد. وقتی سرویس متوقف شود، سیستم آن را از بین می‌برد و متد onDestroy() تنها فراخوان برگشتی دریافتی میباشد.