Omówienie powiązanych usług

Powiązana usługa to serwer w interfejsie klient-serwer. Umożliwia komponentom, takim jak aktywności, powiązanie z usługą, wysyłanie żądań, odbieranie odpowiedzi i komunikację między procesami (IPC). Powiązana usługa zwykle działa tylko wtedy, gdy obsługuje inny komponent aplikacji, i nie działa w tle bez ograniczeń czasowych.

W tym dokumencie opisano, jak utworzyć powiązaną usługę, w tym jak powiązać ją z innymi komponentami aplikacji. Dodatkowe informacje o usługach, np. o tym, jak dostarczać powiadomienia z usługi i ustawiać jej działanie na pierwszym planie, znajdziesz w omówieniu usług.

Podstawy

Powiązana usługa to implementacja klasy Service, która umożliwia innym aplikacjom powiązanie się z nią i interakcję. Aby zapewnić powiązanie z usługą, zaimplementuj metodę wywołania zwrotnego onBind(). Ta metoda zwraca obiekt IBinder, który definiuje interfejs programistyczny, którego klienci mogą używać do interakcji z usługą.

Tworzenie powiązania z uruchomioną usługą

Jak opisano w omówieniu usług, możesz utworzyć usługę, która jest zarówno uruchomiona, jak i powiązana. Oznacza to, że możesz uruchomić usługę, wywołując metodę startService(), co pozwoli jej działać bez ograniczeń czasowych. Możesz też zezwolić klientowi na powiązanie z usługą przez wywołanie bindService().

Jeśli zezwolisz na uruchomienie i powiązanie usługi, po jej uruchomieniu system nie zniszczy jej, gdy wszyscy klienci zostaną od niej odłączeni. Zamiast tego musisz wyraźnie zatrzymać usługę, wywołując metodę stopSelf() lub stopService().

Zwykle implementuje się onBind() lub onStartCommand(), ale czasami konieczne jest zaimplementowanie obu tych rozwiązań. Na przykład odtwarzacz muzyki może potrzebować usługi, która działa bezterminowo i zapewnia powiązanie. Dzięki temu aktywność może uruchomić usługę, aby odtworzyć muzykę, która będzie odtwarzana nawet wtedy, gdy użytkownik opuści aplikację. Gdy użytkownik wróci do aplikacji, aktywność może powiązać się z usługą, aby odzyskać kontrolę nad odtwarzaniem.

Więcej informacji o cyklu życia usługi podczas dodawania powiązania do uruchomionej usługi znajdziesz w sekcji Zarządzanie cyklem życia powiązanej usługi.

Klient wiąże się z usługą, wywołując metodę bindService(). W takim przypadku musi udostępniać implementację interfejsu ServiceConnection, który monitoruje połączenie z usługą. Wartość zwracana przez bindService() wskazuje, czy żądana usługa istnieje i czy klient ma do niej dostęp.

Gdy system Android tworzy połączenie między klientem a usługą, wywołuje onServiceConnected() w ServiceConnection. Metoda onServiceConnected() zawiera argument IBinder, którego klient używa do komunikacji z powiązaną usługą.

Z usługą możesz połączyć wiele klientów jednocześnie. System zapisuje jednak w pamięci podręcznej kanał komunikacji usługi IBinder. Innymi słowy, system wywołuje metodę onBind() usługi, aby wygenerować IBinder tylko wtedy, gdy pierwszy klient się powiąże. Następnie system dostarcza ten sam obiekt IBinder do wszystkich dodatkowych klientów, którzy powiążą się z tą samą usługą, bez ponownego wywoływania metody onBind().

Gdy ostatni klient odłączy się od usługi, system ją zniszczy, chyba że została uruchomiona za pomocą startService().

Najważniejszą częścią implementacji powiązanej usługi jest zdefiniowanie interfejsu zwracanego przez metodę wywołania zwrotnego onBind(). W następnej sekcji omówiono kilka sposobów definiowania interfejsu IBinder usługi.

Tworzenie powiązanej usługi

Podczas tworzenia usługi, która zapewnia powiązanie, musisz podać IBinder, który zapewnia interfejs programowania, którego klienci mogą używać do interakcji z usługą. Interfejs można zdefiniować na 3 sposoby:

Rozszerzanie klasy Binder
Jeśli usługa jest prywatna dla Twojej aplikacji i działa w tym samym procesie co klient (co jest częstym przypadkiem), utwórz interfejs, rozszerzając klasę Binder i zwracając jej instancję z onBind(). Klient otrzymuje Binder i może go używać do bezpośredniego dostępu do metod publicznych dostępnych w implementacji Binder lub Service.

Jest to preferowana technika, gdy usługa jest tylko procesem roboczym w tle dla Twojej aplikacji. Jedynym przypadkiem, w którym nie jest to preferowany sposób tworzenia interfejsu, jest sytuacja, gdy usługa jest używana przez inne aplikacje lub w osobnych procesach.

Korzystanie z komunikatora
Jeśli interfejs ma działać w różnych procesach, możesz utworzyć interfejs usługi za pomocą Messenger. W ten sposób usługa definiuje Handler, który odpowiada na różne typy obiektów Message.

Ten obiekt Handler jest podstawą dla obiektu Messenger, który może następnie udostępnić obiekt IBinder klientowi, umożliwiając mu wysyłanie poleceń do usługi za pomocą obiektów Message. Dodatkowo klient może zdefiniować własny obiekt Messenger, aby usługa mogła wysyłać wiadomości z powrotem.

Jest to najprostszy sposób komunikacji między procesami (IPC), ponieważ Messenger umieszcza wszystkie żądania w jednym wątku, dzięki czemu nie musisz projektować usługi pod kątem bezpieczeństwa wątków.

Używanie AIDL
Język definiowania interfejsu Androida (AIDL) rozkłada obiekty na elementy podstawowe, które system operacyjny może zrozumieć, i porządkuje je w procesach, aby umożliwić komunikację między procesami (IPC). Poprzednia metoda, wykorzystująca Messenger, jest oparta na AIDL jako strukturze bazowej.

Jak wspomnieliśmy w poprzedniej sekcji, Messenger tworzy kolejkę wszystkich żądań klientów w jednym wątku, więc usługa otrzymuje żądania pojedynczo. Jeśli jednak chcesz, aby usługa obsługiwała wiele żądań jednocześnie, możesz użyć bezpośrednio AIDL. W takim przypadku usługa musi być wątkowo bezpieczna i obsługiwać wielowątkowość.

Aby używać AIDL bezpośrednio, utwórz plik .aidl, który definiuje interfejs programowania. Narzędzia Android SDK używają tego pliku do wygenerowania klasy abstrakcyjnej, która implementuje interfejs i obsługuje IPC, którą możesz następnie rozszerzyć w ramach usługi.

Uwaga: w przypadku większości aplikacji AIDL nie jest najlepszym wyborem do tworzenia powiązanej usługi, ponieważ może wymagać wielowątkowości i skomplikowanej implementacji. Dlatego w tym dokumencie nie omawiamy, jak używać go w usłudze. Jeśli masz pewność, że musisz używać AIDL bezpośrednio, zapoznaj się z dokumentem AIDL.

Rozszerzanie klasy Binder

Jeśli tylko aplikacja lokalna korzysta z Twojej usługi i nie musi ona działać w różnych procesach, możesz zaimplementować własną klasę Binder, która zapewnia klientowi bezpośredni dostęp do metod publicznych w usłudze.

Uwaga: działa to tylko wtedy, gdy klient i usługa znajdują się w tej samej aplikacji i procesie, co jest najczęstszym przypadkiem. Sprawdza się to na przykład w przypadku aplikacji muzycznej, która musi powiązać aktywność z własną usługą odtwarzającą muzykę w tle.

Ustawienia należy skonfigurować w następujący sposób:

  1. W usłudze utwórz instancję Binder, która wykonuje jedną z tych czynności:
    • Zawiera metody publiczne, które klient może wywołać.
    • Zwraca bieżącą instancję Service, która ma metody publiczne, które klient może wywołać.
    • Zwraca instancję innej klasy hostowanej przez usługę z metodami publicznymi, które klient może wywołać.
  2. Zwróć tę instancję Binder z metody wywołania zwrotnego onBind().
  3. W kliencie odbierz Binder z metody wywołania zwrotnego onServiceConnected() i wykonaj wywołania powiązanej usługi, korzystając z podanych metod.

Uwaga: usługa i klient muszą znajdować się w tej samej aplikacji, aby klient mógł rzutować zwrócony obiekt i prawidłowo wywoływać jego interfejsy API. Usługa i klient muszą też znajdować się w tym samym procesie, ponieważ ta technika nie wykonuje żadnego marshalingu między procesami.

Oto przykład usługi, która zapewnia klientom dostęp do metod w usłudze za pomocą implementacji Binder:

class LocalService : Service() {
    // Binder given to clients.
    private val binder = LocalBinder()

    // Random number generator.
    private val mGenerator = Random()

    /** Method for clients.  */
    val randomNumber: Int
        get() = mGenerator.nextInt(100)

    /**
     * Class used for the client Binder. Because we know this service always
     * runs in the same process as its clients, we don't need to deal with IPC.
     */
    inner class LocalBinder : Binder() {
        // Return this instance of LocalService so clients can call public methods.
        fun getService(): LocalService = this@LocalService
    }

    override fun onBind(intent: Intent): IBinder {
        return binder
    }
}

LocalBinder udostępnia klientom metodę getService() do pobierania bieżącej instancji LocalService. Dzięki temu klienci mogą wywoływać metody publiczne w usłudze. Klienci mogą na przykład dzwonić do getRandomNumber() z usługi.

Oto aktywność, która wiąże się z LocalService i wywołuje getRandomNumber() po kliknięciu przycisku:

class BindingActivity : Activity() {
    private var mService: LocalService? = null
    private var mBound: Boolean = false

    /** Defines callbacks for service binding, passed to bindService().  */
    private val connection = object : ServiceConnection {

        override fun onServiceConnected(className: ComponentName, service: IBinder) {
            // We've bound to LocalService, cast the IBinder and get LocalService instance.
            val binder = service as LocalService.LocalBinder
            mService = binder.getService()
            mBound = true
        }

        override fun onServiceDisconnected(arg0: ComponentName) {
            mService = null
            mBound = false
        }
    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
    }

    override fun onStart() {
        super.onStart()
        // Bind to LocalService.
        Intent(this, LocalService::class.java).also { intent ->
            bindService(intent, connection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        unbindService(connection)
        // Release the reference so the service can be garbage-collected once it's
        // destroyed. onServiceDisconnected() isn't called when the client unbinds.
        mService = null
        mBound = false
    }

    /** Called when a button is clicked (the button in the layout file attaches to
     * this method with the android:onClick attribute).  */
    fun onButtonClick(v: View) {
        if (mBound) {
            // Call a method from the LocalService.
            // However, if this call is something that might hang, then put this request
            // in a separate thread to avoid slowing down the activity performance.
            val num: Int = mService?.randomNumber ?: return
            Toast.makeText(this, "number: $num", Toast.LENGTH_SHORT).show()
        }
    }
}

Powyższy przykład pokazuje, jak klient wiąże się z usługą za pomocą implementacji ServiceConnection i wywołania zwrotnego onServiceConnected(). W następnej sekcji znajdziesz więcej informacji o procesie wiązania z usługą.

Uwaga: w poprzednim przykładzie metoda onStop() odłącza klienta od usługi i zwalnia jego odwołanie do niej. Odłączaj klientów od usług w odpowiednich momentach, zgodnie z opisem w sekcji Dodatkowe uwagi.

Więcej przykładowego kodu znajdziesz w klasach LocalService.java i LocalServiceActivities.java w ApiDemos.

Korzystanie z Messengera

Jeśli usługa musi komunikować się z procesami zdalnymi, możesz użyć Messenger, aby udostępnić interfejs usługi. Ta technika umożliwia komunikację między procesami (IPC) bez konieczności używania AIDL.

Użycie Messenger w interfejsie jest prostsze niż użycie AIDL, ponieważ Messenger umieszcza w kolejce wszystkie wywołania usługi. Interfejs AIDL wysyła do usługi jednoczesne żądania, które muszą być obsługiwane przez wielowątkowość.

W przypadku większości aplikacji usługa nie musi wykonywać wielowątkowości, więc użycie Messenger pozwala usłudze obsługiwać jedno wywołanie naraz. Jeśli ważne jest, aby usługa była wielowątkowa, do zdefiniowania interfejsu użyj AIDL.

Oto podsumowanie sposobu korzystania z Messenger:

  1. Usługa implementuje interfejs Handler, który otrzymuje wywołanie zwrotne dla każdego połączenia od klienta.
  2. Usługa używa Handler do utworzenia obiektu Messenger (który jest odwołaniem do Handler).
  3. Messenger tworzy IBinder, który usługa zwraca klientom z onBind().
  4. Klienci używają IBinder do utworzenia instancji Messenger (która odwołuje się do Handler usługi), której klient używa do wysyłania obiektów Message do usługi.
  5. Usługa otrzymuje każdy obiekt Message w obiekcie Handler, a dokładnie w metodzie handleMessage().

W ten sposób klient nie ma żadnych metod, które mógłby wywołać w usłudze. Zamiast tego klient dostarcza wiadomości (obiekty Message), które usługa odbiera w Handler.

Oto przykładowa usługa, która używa interfejsu Messenger:

/** Command to the service to display a message.  */
private const val MSG_SAY_HELLO = 1

class MessengerService : Service() {

    /**
     * Target we publish for clients to send messages to IncomingHandler.
     */
    private lateinit var mMessenger: Messenger

    /**
     * Handler of incoming messages from clients.
     */
    internal class IncomingHandler(
        context: Context,
        private val applicationContext: Context = context.applicationContext
    ) : Handler(Looper.getMainLooper()) {
        override fun handleMessage(msg: Message) {
            when (msg.what) {
                MSG_SAY_HELLO ->
                    Toast.makeText(applicationContext, "hello!", Toast.LENGTH_SHORT).show()
                else -> super.handleMessage(msg)
            }
        }
    }

    /**
     * When binding to the service, we return an interface to our messenger
     * for sending messages to the service.
     */
    override fun onBind(intent: Intent): IBinder? {
        Toast.makeText(applicationContext, "binding", Toast.LENGTH_SHORT).show()
        mMessenger = Messenger(IncomingHandler(this))
        return mMessenger.binder
    }
}

Metoda handleMessage() w Handler to miejsce, w którym usługa otrzymuje przychodzące żądanie Message i decyduje, co zrobić, na podstawie elementu what.

Klient musi tylko utworzyć Messenger na podstawie IBinder zwróconego przez usługę i wysłać wiadomość za pomocą send(). Oto przykład aktywności, która wiąże się z usługą i dostarcza do niej wiadomość MSG_SAY_HELLO:

class ActivityMessenger : Activity() {
    /** Messenger for communicating with the service.  */
    private var mService: Messenger? = null

    /** Flag indicating whether we have called bind on the service.  */
    private var bound: 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 has been
            // established, giving us the object we can use to
            // interact with the service.  We are communicating with the
            // service using a Messenger, so here we get a client-side
            // representation of that from the raw IBinder object.
            mService = Messenger(service)
            bound = true
        }

        override fun onServiceDisconnected(className: ComponentName) {
            // This is called when the connection with the service has been
            // unexpectedly disconnected—that is, its process crashed.
            mService = null
            bound = false
        }
    }

    fun sayHello(v: View) {
        if (!bound) return
        // Create and send a message to the service, using a supported 'what' value.
        val msg: Message = Message.obtain(null, MSG_SAY_HELLO, 0, 0)
        try {
            mService?.send(msg)
        } catch (e: RemoteException) {
            e.printStackTrace()
        }

    }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.main)
    }

    override fun onStart() {
        super.onStart()
        // Bind to the service.
        Intent(this, MessengerService::class.java).also { intent ->
            bindService(intent, mConnection, Context.BIND_AUTO_CREATE)
        }
    }

    override fun onStop() {
        super.onStop()
        // Unbind from the service.
        if (bound) {
            unbindService(mConnection)
            mService = null
            bound = false
        }
    }
}

Ten przykład nie pokazuje, jak usługa może odpowiedzieć klientowi. Jeśli chcesz, aby usługa odpowiadała, musisz też utworzyć Messenger w kliencie. Gdy klient otrzyma wywołanie zwrotne onServiceConnected(), wysyła do usługi żądanie Message, które zawiera Messenger klienta w parametrze replyTo metody send().

Przykład tego, jak zapewnić dwukierunkową komunikację, znajdziesz w przykładach MessengerService.java (usługa) i MessengerServiceActivities.java (klient).

Tworzenie powiązania z usługą

Komponenty aplikacji (klienty) mogą wiązać się z usługą, wywołując bindService(). System Android wywołuje metodę onBind() usługi, która zwraca obiekt IBinder do interakcji z usługą.

Wiązanie jest asynchroniczne, a funkcja bindService() natychmiast zwraca wynik bez zwracania IBinder do klienta. Aby otrzymać IBinder, klient musi utworzyć instancję ServiceConnection i przekazać ją do bindService(). ServiceConnection zawiera metodę wywołania zwrotnego, którą system wywołuje, aby dostarczyć IBinder.

Uwaga: z usługą mogą się wiązać tylko aktywności, usługi i mechanizmy dostarczania treści. Nie można powiązać usługi z odbiornikiem komunikatów.

Aby powiązać usługę z klientem, wykonaj te czynności:

  1. Wdrożenie: ServiceConnection.

    Twoja implementacja musi zastąpić 2 metody wywołania zwrotnego:

    onServiceConnected()
    System wywołuje tę metodę, aby dostarczyć obiekt IBinder zwracany przez metodę onBind() usługi.
    onServiceDisconnected()
    System Android wywołuje tę metodę, gdy połączenie z usługą zostanie nieoczekiwanie utracone, np. gdy usługa ulegnie awarii lub zostanie zamknięta. Ta metoda nie jest wywoływana, gdy klient odłącza się od usługi.
  2. Wywołaj bindService(), przekazując implementację ServiceConnection.

    Uwaga: jeśli metoda zwraca wartość false, klient nie ma prawidłowego połączenia z usługą. Wywołaj jednak unbindService() w kliencie. W przeciwnym razie klient uniemożliwi wyłączenie usługi, gdy będzie ona bezczynna.

  3. Gdy system wywoła metodę wywołania zwrotnego onServiceConnected(), możesz zacząć wywoływać usługę, używając metod zdefiniowanych przez interfejs.
  4. Aby rozłączyć się z usługą, zadzwoń pod numer unbindService().

    Jeśli klient jest nadal powiązany z usługą, gdy aplikacja go niszczy, zniszczenie powoduje odłączenie klienta. Zalecamy odłączenie klienta, gdy tylko zakończy interakcję z usługą. Dzięki temu nieaktywna usługa zostanie wyłączona. Więcej informacji o odpowiednich momentach na powiązanie i odwiązanie znajdziesz w sekcji Dodatkowe uwagi.

W poniższym przykładzie klient łączy się z usługą utworzoną wcześniej przez rozszerzenie klasy Binder, więc wystarczy, że rzutuje zwrócony obiekt IBinder na klasę LocalBinder i zażąda instancji LocalService:

var mService: LocalService? = null

val mConnection = object : ServiceConnection {
    // Called when the connection with the service is established.
    override fun onServiceConnected(className: ComponentName, service: IBinder) {
        // Because we have bound to an explicit
        // service that is running in our own process, we can
        // cast its IBinder to a concrete class and directly access it.
        val binder = service as LocalService.LocalBinder
        mService = binder.getService()
        mBound = true
    }

    // Called when the connection with the service disconnects unexpectedly.
    override fun onServiceDisconnected(className: ComponentName) {
        Log.e(TAG, "onServiceDisconnected")
        mService = null
        mBound = false
    }
}

Za pomocą tego ServiceConnection klient może powiązać się z usługą, przekazując go do bindService(), jak w tym przykładzie:

Intent(this, LocalService::class.java).also { intent ->
    bindService(intent, connection, Context.BIND_AUTO_CREATE)
}
  • Pierwszym parametrem metody bindService() jest obiekt Intent, który jednoznacznie określa usługę do powiązania.

    Uwaga: jeśli używasz intencji do powiązania z Service, upewnij się, że Twoja aplikacja jest bezpieczna, używając jawnej intencji. Używanie intencji niejawnej do uruchamiania usługi stanowi zagrożenie dla bezpieczeństwa, ponieważ nie można mieć pewności, która usługa odpowie na intencję, a użytkownik nie widzi, która usługa się uruchamia. Począwszy od Androida 5.0 (poziom interfejsu API 21), system zgłasza wyjątek, jeśli wywołasz bindService() z niejawną intencją.

  • Drugi parametr to obiekt ServiceConnection.
  • Trzeci parametr to flaga wskazująca opcje powiązania – zwykle BIND_AUTO_CREATE, aby utworzyć usługę, jeśli jeszcze nie działa. Inne możliwe wartości to BIND_DEBUG_UNBIND, BIND_NOT_FOREGROUND lub 0 (brak).

Uwagi dodatkowe

Oto kilka ważnych informacji o wiązaniu z usługą:

  • Zawsze przechwytuj wyjątki DeadObjectException, które są zgłaszane, gdy połączenie zostanie przerwane. Jest to jedyny wyjątek zgłaszany przez metody zdalne.
  • Obiekty są zliczane przez odwołania w procesach.
  • Zazwyczaj wiązanie i odłączanie jest parowane podczas odpowiednich momentów uruchamiania i wyłączania w cyklu życia klienta, jak opisano w tych przykładach:
    • Jeśli chcesz korzystać z usługi tylko wtedy, gdy aktywność jest widoczna, powiąż ją podczas onStart() i odłącz podczas onStop().
    • Jeśli chcesz, aby aktywność otrzymywała odpowiedzi nawet wtedy, gdy jest zatrzymana w tle, powiąż ją podczas onCreate() i odłącz podczas onDestroy(). Pamiętaj, że oznacza to, że aktywność musi korzystać z usługi przez cały czas jej działania, nawet w tle. Gdy usługa jest w innym procesie, zwiększasz wagę procesu i jest bardziej prawdopodobne, że zostanie on zamknięty przez system.

    Uwaga: zwykle nie wiąże się i nie rozwiązuje aktywności podczas wywołań zwrotnych onResume() i onPause(), ponieważ te wywołania zwrotne występują przy każdym przejściu cyklu życia. Ogranicz do minimum przetwarzanie, które odbywa się podczas tych przejść.

    Jeśli wiele aktywności w aplikacji jest powiązanych z tą samą usługą i następuje przejście między 2 z nich, usługa może zostać zniszczona i utworzona ponownie, gdy bieżąca aktywność zostanie odłączona (podczas wstrzymania), zanim zostanie powiązana następna (podczas wznowienia). To przejście działania, które pokazuje, jak działania koordynują swoje cykle życia, jest opisane w sekcji Cykl życia działania.

Więcej przykładowego kodu pokazującego, jak powiązać z usługą, znajdziesz w klasie RemoteService.java w ApiDemos.

Zarządzanie cyklem życia powiązanej usługi

Gdy usługa zostanie odłączona od wszystkich klientów, system Android ją niszczy (chyba że została uruchomiona za pomocą startService()). Nie musisz więc zarządzać cyklem życia usługi, jeśli jest to wyłącznie powiązana usługa. System Android zarządza nią za Ciebie na podstawie tego, czy jest powiązana z jakimiś klientami.

Jeśli jednak zdecydujesz się wdrożyć metodę wywołania zwrotnego onStartCommand(), musisz wyraźnie zatrzymać usługę, ponieważ jest ona teraz uważana za uruchomioną. W takim przypadku usługa działa, dopóki nie zatrzyma się sama za pomocą metody stopSelf() lub dopóki inny komponent nie wywoła metody stopService(), niezależnie od tego, czy jest powiązana z jakimiś klientami.

Dodatkowo, jeśli usługa jest uruchomiona i akceptuje powiązanie, gdy system wywołuje metodę onUnbind(), możesz opcjonalnie zwrócić true, jeśli chcesz otrzymać wywołanie metody onRebind(), gdy klient następnym razem powiąże się z usługą. onRebind() zwraca void, ale klient nadal otrzymuje IBinder w wywołaniu zwrotnym onServiceConnected(). Na rysunku poniżej przedstawiono logikę tego rodzaju cyklu życia.

Cykl życia uruchomionej i powiązanej usługi: wywoływane są metody onStartCommand() i onBind(); gdy wszystkie klienty zostaną odłączone, wywoływana jest metoda onUnbind(); przy następnym powiązaniu wywoływana jest metoda onRebind(), jeśli metoda onUnbind() zwróciła wartość „true”, w przeciwnym razie wywoływana jest metoda onBind(); po zatrzymaniu usługi wywoływana jest metoda onDestroy().
Rysunek 1. Cykl życia usługi, która została uruchomiona i umożliwia powiązanie.

Więcej informacji o cyklu życia uruchomionej usługi znajdziesz w omówieniu usług.