Przegląd usług

Service to komponent aplikacji, który może wykonywać długo trwające operacje w tle. Nie ma interfejsu użytkownika. Po uruchomieniu usługa może działać przez pewien czas, nawet gdy użytkownik przełączy się na inną aplikację. Dodatkowo komponent może powiązać się z usługą, aby z nią współdziałać, a nawet realizować komunikację między procesami (IPC). Usługa może na przykład obsługiwać transakcje sieciowe, odtwarzać muzykę, wykonywać operacje wejścia/wyjścia na plikach lub wchodzić w interakcje z mechanizmem dostarczania treści – wszystko to w tle.

Uwaga: usługa działa w głównym wątku procesu hostującego. Usługa nie tworzy własnego wątku i nie działa w osobnym procesie, chyba że określisz inaczej. Aby uniknąć błędów typu „Aplikacja nie odpowiada” (ANR), wszystkie operacje blokujące należy wykonywać w osobnym wątku w ramach usługi.

Rodzaje usług

Są 3 rodzaje usług:

Pierwszy plan

Usługa działająca na pierwszym planie wykonuje operację, która jest widoczna dla użytkownika. Na przykład aplikacja audio używa usługi na pierwszym planie do odtwarzania ścieżki dźwiękowej. Usługi na pierwszym planie muszą wyświetlać powiadomienie. Usługi na pierwszym planie działają nawet wtedy, gdy użytkownik nie wchodzi w interakcję z aplikacją.

Gdy używasz usługi na pierwszym planie, musisz wyświetlać powiadomienie, aby użytkownicy byli świadomi, że usługa jest uruchomiona. Tego powiadomienia nie można odrzucić, dopóki usługa nie zostanie zatrzymana lub usunięta z pierwszego planu.

Dowiedz się więcej o konfigurowaniu usług na pierwszym planie w aplikacji.

Uwaga: interfejs API WorkManager umożliwia elastyczne planowanie zadań i w razie potrzeby może uruchamiać te zadania jako usługi na pierwszym planie. W wielu przypadkach użycie biblioteki WorkManager jest lepszym rozwiązaniem niż bezpośrednie korzystanie z usług działających na pierwszym planie.

Tło
Usługa w tle wykonuje operację, która nie jest bezpośrednio zauważalna dla użytkownika. Jeśli na przykład aplikacja używa usługi do kompresowania pamięci, zwykle jest to usługa w tle.

Uwaga: jeśli aplikacja jest kierowana na interfejs API na poziomie 26 lub wyższym, system nakłada ograniczenia na działanie usług w tle, gdy aplikacja nie jest na pierwszym planie. W większości przypadków nie należy na przykład uzyskiwać dostępu do informacji o lokalizacji w tle. Zamiast tego zaplanuj zadania za pomocą WorkManagera.

Powiązane
Usługa jest powiązana, gdy komponent aplikacji powiąże się z nią przez wywołanie bindService(). Powiązana usługa oferuje interfejs klient-serwer, który umożliwia komponentom interakcję z usługą, wysyłanie żądań, otrzymywanie wyników, a nawet wykonywanie tych czynności między procesami za pomocą komunikacji między procesami (IPC). Powiązana usługa działa tylko wtedy, gdy jest z nią powiązany inny komponent aplikacji. Z usługą może być powiązanych wiele komponentów jednocześnie, ale gdy wszystkie zostaną odłączone, usługa zostanie zniszczona.

Chociaż w tej dokumentacji uruchomione i powiązane usługi są zwykle omawiane osobno, usługa może działać na oba sposoby – może być uruchomiona (aby działać bezterminowo) i umożliwiać powiązanie. Wystarczy, że zaimplementujesz kilka metod wywołania zwrotnego: onStartCommand(), aby umożliwić komponentom uruchamianie usługi, i onBind(), aby umożliwić wiązanie.

Niezależnie od tego, czy usługa jest uruchomiona, powiązana czy jedno i drugie, każdy komponent aplikacji może jej używać (nawet z osobnej aplikacji) w taki sam sposób, w jaki każdy komponent może używać aktywności – uruchamiając ją za pomocą Intent. Możesz jednak zadeklarować usługę jako prywatną w pliku manifestu i zablokować dostęp z innych aplikacji. Więcej informacji na ten temat znajdziesz w sekcji Deklarowanie usługi w pliku manifestu.

Wybieranie między usługą a wątkiem

Usługa to po prostu komponent, który może działać w tle, nawet gdy użytkownik nie wchodzi w interakcję z aplikacją. Dlatego należy ją utworzyć tylko wtedy, gdy jest to konieczne.

Jeśli musisz wykonać pracę poza wątkiem głównym, ale tylko wtedy, gdy użytkownik wchodzi w interakcję z aplikacją, utwórz nowy wątek w kontekście innego komponentu aplikacji. Jeśli na przykład chcesz odtwarzać muzykę, ale tylko podczas działania aktywności, możesz utworzyć wątek w metodzie onCreate(), uruchomić go w metodzie onStart() i zatrzymać w metodzie onStop(). Zamiast tradycyjnej klasy Thread rozważ też użycie pul wątków i wykonawców z pakietu java.util.concurrent lub współprogramów Kotlin. Więcej informacji o przenoszeniu wykonywania do wątków w tle znajdziesz w dokumencie Wątki na Androidzie.

Pamiętaj, że jeśli używasz usługi, domyślnie nadal działa ona w głównym wątku aplikacji, więc jeśli wykonuje ona intensywne lub blokujące operacje, musisz utworzyć w niej nowy wątek.

Podstawy

Aby utworzyć usługę, musisz utworzyć podklasę Service lub użyć jednej z jej istniejących podklas. W swojej implementacji musisz zastąpić niektóre metody wywołania zwrotnego, które obsługują kluczowe aspekty cyklu życia usługi, i udostępnić mechanizm, który umożliwia komponentom powiązanie z usługą, jeśli jest to konieczne. Oto najważniejsze metody wywołania zwrotnego, które należy zastąpić:

onStartCommand()
System wywołuje tę metodę, wywołując startService(), gdy inny komponent (np. aktywność) żąda uruchomienia usługi. Po wykonaniu tej metody usługa jest uruchamiana i może działać w tle przez nieograniczony czas. Jeśli to zrobisz, Twoim obowiązkiem będzie zatrzymanie usługi po zakończeniu jej działania przez wywołanie stopSelf() lub stopService(). Jeśli chcesz tylko udostępnić powiązanie, nie musisz implementować tej metody.
onBind()
System wywołuje tę metodę, wywołując bindService(), gdy inny komponent chce powiązać się z usługą (np. w celu wykonania RPC). W implementacji tej metody musisz udostępnić interfejs, którego klienci używają do komunikacji z usługą, zwracając IBinder. Zawsze musisz implementować tę metodę. Jeśli jednak nie chcesz zezwalać na wiązanie, zwróć wartość null.
onCreate()
System wywołuje tę metodę, aby wykonać jednorazowe procedury konfiguracji podczas tworzenia usługi (przed wywołaniem metody onStartCommand() lub onBind()). Jeśli usługa już działa, ta metoda nie jest wywoływana.
onDestroy()
System wywołuje tę metodę, gdy usługa nie jest już używana i jest niszczona. Usługa powinna implementować tę metodę, aby czyścić zasoby, takie jak wątki, zarejestrowane detektory czy odbiorniki. To ostatnie wywołanie, które otrzymuje usługa.

Jeśli komponent uruchamia usługę, wywołując startService() (co powoduje wywołanie onStartCommand()), usługa działa, dopóki nie zatrzyma się sama za pomocą stopSelf() lub dopóki inny komponent nie zatrzyma jej, wywołując stopService().

Jeśli komponent wywołuje metodę bindService(), aby utworzyć usługę, a metoda onStartCommand() nie jest wywoływana, usługa działa tylko tak długo, jak długo komponent jest z nią powiązany. Po odłączeniu usługi od wszystkich klientów system ją niszczy.

System Android zatrzymuje usługę tylko wtedy, gdy brakuje pamięci i musi odzyskać zasoby systemowe na potrzeby aktywności, na której skupia się użytkownik. Jeśli usługa jest powiązana z aktywnością, na której skupia się użytkownik, jest mniej prawdopodobne, że zostanie zamknięta. Jeśli usługa jest zadeklarowana jako działająca na pierwszym planie, rzadko jest zamykana. Jeśli usługa została uruchomiona i działa przez dłuższy czas, system z czasem obniża jej pozycję na liście zadań w tle, przez co usługa staje się bardzo podatna na zakończenie. Jeśli usługa została uruchomiona, musisz zaprojektować ją tak, aby prawidłowo obsługiwała ponowne uruchomienia przez system. Jeśli system zakończy działanie usługi, uruchomi ją ponownie, gdy tylko zasoby staną się dostępne, ale zależy to również od wartości zwracanej przez onStartCommand(). Więcej informacji o tym, kiedy system może zniszczyć usługę, znajdziesz w dokumencie Procesy i wątki.

W kolejnych sekcjach dowiesz się, jak utworzyć metody usługi startService() i bindService() oraz jak ich używać w innych komponentach aplikacji.

Deklarowanie usługi w pliku manifestu

Wszystkie usługi musisz zadeklarować w pliku manifestu aplikacji, tak samo jak aktywności i inne komponenty.

Aby zadeklarować usługę, dodaj element <service> jako element podrzędny elementu <application>. Oto przykład:

<manifest ... >
  ...
  <application ... >
      <service android:name=".ExampleService" />
      ...
  </application>
</manifest>

Więcej informacji o deklarowaniu usługi w pliku manifestu znajdziesz w dokumentacji elementu <service>.

W elemencie <service> możesz uwzględnić inne atrybuty, aby zdefiniować właściwości, takie jak uprawnienia wymagane do uruchomienia usługi i proces, w którym usługa powinna działać. Atrybut android:name jest jedynym wymaganym atrybutem – określa on nazwę klasy usługi. Po opublikowaniu aplikacji nie zmieniaj tej nazwy, aby uniknąć ryzyka uszkodzenia kodu z powodu zależności od jawnych intencji uruchamiania lub wiązania usługi (przeczytaj post na blogu Things That Cannot Change).

Uwaga: aby zapewnić bezpieczeństwo aplikacji, zawsze używaj intencji jawnej podczas uruchamiania Service i nie deklaruj filtrów intencji dla usług. Używanie intencji ogólnej 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 zamiarem niejawnym.

Możesz zapewnić, że usługa będzie dostępna tylko dla Twojej aplikacji, dodając atrybut android:exported i ustawiając go na false. Uniemożliwi to innym aplikacjom uruchamianie Twojej usługi, nawet przy użyciu intencji jawnej.

Uwaga: użytkownicy mogą zobaczyć, jakie usługi są uruchomione na ich urządzeniu. Jeśli zobaczy usługę, której nie rozpoznaje lub której nie ufa, może ją zatrzymać. Aby uniknąć przypadkowego zatrzymania usługi przez użytkowników, musisz dodać atrybut android:description do elementu <service> w pliku manifestu aplikacji. W opisie podaj krótkie zdanie wyjaśniające, co robi usługa i jakie korzyści zapewnia.

Tworzenie uruchomionej usługi

Uruchomiona usługa to usługa, którą inny komponent uruchamia przez wywołanie startService(), co powoduje wywołanie metody onStartCommand() usługi.

Uruchomiona usługa ma cykl życia niezależny od komponentu, który ją uruchomił. Usługa może działać w tle przez nieokreślony czas, nawet jeśli komponent, który ją uruchomił, zostanie zniszczony. Dlatego usługa powinna zatrzymać się po zakończeniu zadania, wywołując metodę stopSelf(), lub inny komponent może ją zatrzymać, wywołując metodę stopService().

Komponent aplikacji, taki jak aktywność, może uruchomić usługę, wywołując startService() i przekazując Intent, który określa usługę i zawiera dane, których usługa ma używać. Usługa otrzymuje ten obiekt Intent w metodzie onStartCommand().

Załóżmy na przykład, że aktywność musi zapisać pewne dane w bazie danych online. Aktywność może uruchomić usługę towarzyszącą i przekazać jej dane do zapisania, przekazując intencję do metody startService(). Usługa odbiera intencję w onStartCommand(), łączy się z internetem i wykonuje transakcję bazy danych. Po zakończeniu transakcji usługa zatrzymuje się i jest niszczona.

Uwaga: usługa działa w tym samym procesie co aplikacja, w której jest zadeklarowana, i domyślnie w głównym wątku tej aplikacji. Jeśli usługa wykonuje intensywne lub blokujące operacje, gdy użytkownik wchodzi w interakcję z aktywnością z tej samej aplikacji, usługa spowalnia działanie aktywności. Aby uniknąć wpływu na wydajność aplikacji, rozpocznij nowy wątek w usłudze.

Klasa Service jest klasą bazową dla wszystkich usług. Gdy rozszerzasz tę klasę, ważne jest, aby utworzyć nowy wątek, w którym usługa może wykonać wszystkie swoje zadania. Usługa domyślnie używa głównego wątku aplikacji, co może spowolnić działanie wszystkich aktywności, które aplikacja wykonuje.

Platforma Androida udostępnia też podklasę IntentService klasy Service, która używa wątku instancji roboczej do obsługi wszystkich żądań uruchomienia, po jednym naraz. Nie zalecamy używania tej klasy w nowych aplikacjach, ponieważ nie będzie ona działać prawidłowo w systemie Android 8 Oreo i nowszych ze względu na wprowadzenie limitów wykonywania w tle. Ponadto od Androida 11 jest on wycofany. Możesz użyć JobIntentService jako zamiennika IntentService, który jest zgodny z nowszymi wersjami Androida.

W sekcjach poniżej opisujemy, jak wdrożyć własną usługę niestandardową, ale w większości przypadków zdecydowanie zalecamy korzystanie z WorkManagera. Zapoznaj się z przewodnikiem po procesach w tle na Androidzie, aby sprawdzić, czy istnieje rozwiązanie, które odpowiada Twoim potrzebom.

Rozszerzanie klasy Service

Możesz rozszerzyć klasę Service, aby obsługiwać każdą przychodzącą intencję. Podstawowa implementacja może wyglądać tak:

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()
    }
}

Przykładowy kod obsługuje wszystkie połączenia przychodzące w onStartCommand() i publikuje zadanie w Handler działającym w wątku w tle. Działa tak samo jak IntentService i przetwarza wszystkie żądania seryjnie, jedno po drugim. Możesz na przykład zmienić kod, aby uruchamiać zadania w puli wątków, jeśli chcesz jednocześnie wykonywać wiele żądań.

Zwróć uwagę, że metoda onStartCommand() musi zwracać liczbę całkowitą. Liczba całkowita to wartość, która opisuje, jak system powinien kontynuować usługę w przypadku, gdy system ją zakończy. Wartość zwracana przez funkcję onStartCommand() musi być jedną z tych stałych:

START_NOT_STICKY
Jeśli system zakończy działanie usługi po zwróceniu onStartCommand(), nie odtwarzaj usługi, chyba że są intencje oczekujące na dostarczenie. To najbezpieczniejsza opcja, która pozwala uniknąć uruchamiania usługi, gdy nie jest to konieczne, i gdy aplikacja może po prostu ponownie uruchomić niedokończone zadania.
START_STICKY
Jeśli system zakończy usługę po zwróceniu onStartCommand(), utwórz ją ponownie i wywołaj onStartCommand(), ale nie dostarczaj ponownie ostatniej intencji. Zamiast tego system wywołuje onStartCommand() z intencją null, chyba że istnieją intencje oczekujące na uruchomienie usługi. W takim przypadku te intencje są dostarczane. Jest to odpowiednie w przypadku odtwarzaczy multimedialnych (lub podobnych usług), które nie wykonują poleceń, ale działają bezterminowo i czekają na zadanie.
START_REDELIVER_INTENT
Jeśli system zakończy usługę po zwróceniu onStartCommand(), utwórz ją ponownie i wywołaj onStartCommand() z ostatnią intencją dostarczoną do usługi. Wszystkie intencje oczekujące są dostarczane po kolei. Jest to odpowiednie w przypadku usług, które aktywnie wykonują zadanie, które powinno zostać natychmiast wznowione, np. pobieranie pliku.

Więcej informacji o tych zwracanych wartościach znajdziesz w dokumentacji referencyjnej dotyczącej poszczególnych stałych.

uruchamianie usługi,

Możesz uruchomić usługę z aktywności lub innego komponentu aplikacji, przekazując Intent do startService() lub startForegroundService(). System Android wywołuje metodę onStartCommand() usługi i przekazuje jej obiekt Intent, który określa, którą usługę należy uruchomić.

Uwaga: jeśli aplikacja jest kierowana na interfejs API na poziomie 26 lub wyższym, system nakłada ograniczenia na korzystanie z usług w tle i ich tworzenie, chyba że aplikacja działa na pierwszym planie. Jeśli aplikacja musi utworzyć usługę działającą na pierwszym planie, powinna wywołać startForegroundService(). Ta metoda tworzy usługę w tle, ale sygnalizuje systemowi, że usługa zostanie przeniesiona na pierwszy plan. Po utworzeniu usługi musi ona wywołać metodę startForeground() w ciągu 5 sekund.

Na przykład aktywność może uruchomić przykładową usługę z poprzedniej sekcji (HelloService) za pomocą jawnej intencji z startService(), jak pokazano poniżej:

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

Metoda startService() zwraca wynik natychmiast, a system Android wywołuje metodę onStartCommand() usługi. Jeśli usługa nie jest jeszcze uruchomiona, system najpierw wywołuje onCreate(), a następnie onStartCommand().

Jeśli usługa nie zapewnia też powiązania, intencja dostarczana z startService() jest jedynym trybem komunikacji między komponentem aplikacji a usługą. Jeśli jednak chcesz, aby usługa wysłała wynik z powrotem, klient, który ją uruchamia, może utworzyć obiekt PendingIntent na potrzeby komunikatu (za pomocą metody getBroadcast()) i dostarczyć go do usługi w obiekcie Intent, który ją uruchamia. Usługa może następnie użyć transmisji, aby dostarczyć wynik.

Wiele żądań uruchomienia usługi powoduje wiele odpowiednich wywołań metody onStartCommand() usługi. Jednak do zatrzymania usługi wystarczy tylko jedno żądanie (z stopSelf() lub stopService()).

Zatrzymywanie usługi

Uruchomiona usługa musi zarządzać własnym cyklem życia. Oznacza to, że system nie zatrzymuje ani nie niszczy usługi, chyba że musi odzyskać pamięć systemową, a usługa nadal działa po zwróceniu onStartCommand(). Usługa musi zatrzymać się sama, wywołując stopSelf(), lub inny komponent może ją zatrzymać, wywołując stopService().

Po otrzymaniu żądania zatrzymania za pomocą stopSelf() lub stopService() system niszczy usługę tak szybko, jak to możliwe.

Jeśli Twoja usługa obsługuje jednocześnie wiele żądań do onStartCommand(), nie zatrzymuj jej po zakończeniu przetwarzania żądania uruchomienia, ponieważ mogło nadejść nowe żądanie uruchomienia (zatrzymanie po zakończeniu pierwszego żądania spowodowałoby zakończenie drugiego). Aby uniknąć tego problemu, możesz użyć stopSelf(int), aby mieć pewność, że żądanie zatrzymania usługi zawsze będzie oparte na najnowszym żądaniu uruchomienia. Oznacza to, że gdy wywołujesz stopSelf(int), przekazujesz identyfikator żądania rozpoczęcia (startId dostarczony do onStartCommand()), któremu odpowiada żądanie zatrzymania. Jeśli usługa otrzyma nowe żądanie uruchomienia, zanim będzie można wywołać metodę stopSelf(int), identyfikator nie będzie pasować i usługa nie zostanie zatrzymana.

Uwaga: aby uniknąć marnowania zasobów systemowych i zużywania baterii, upewnij się, że aplikacja zatrzymuje swoje usługi po zakończeniu pracy. W razie potrzeby inne komponenty mogą zatrzymać usługę, wywołując stopService(). Nawet jeśli włączysz wiązanie dla usługi, musisz zawsze samodzielnie zatrzymać usługę, jeśli kiedykolwiek otrzyma wywołanie metody onStartCommand().

Więcej informacji o cyklu życia usługi znajdziesz w sekcji Zarządzanie cyklem życia usługi poniżej.

Tworzenie powiązanej usługi

Powiązana usługa to taka, która umożliwia komponentom aplikacji powiązanie się z nią przez wywołanie bindService() w celu utworzenia długotrwałego połączenia. Zwykle nie zezwala komponentom na uruchamianie go przez wywołanie metody startService().

Utwórz powiązaną usługę, jeśli chcesz wchodzić z nią w interakcje z poziomu aktywności i innych komponentów w aplikacji lub udostępniać niektóre funkcje aplikacji innym aplikacjom za pomocą komunikacji między procesami (IPC).

Aby utworzyć powiązaną usługę, zaimplementuj metodę wywołania zwrotnego onBind(), która zwraca obiekt IBinder definiujący interfejs do komunikacji z usługą. Inne komponenty aplikacji mogą następnie wywołać metodę bindService(), aby pobrać interfejs i zacząć wywoływać metody w usłudze. Usługa działa tylko po to, aby obsługiwać powiązany z nią komponent aplikacji, więc gdy nie ma żadnych komponentów powiązanych z usługą, system ją niszczy. Nie musisz zatrzymywać powiązanej usługi w taki sam sposób, jak w przypadku usługi uruchomionej za pomocą metody onStartCommand().

Aby utworzyć powiązaną usługę, musisz zdefiniować interfejs, który określa, jak klient może komunikować się z usługą. Ten interfejs między usługą a klientem musi być implementacją IBinder i musi być zwracany przez usługę z metody wywołania zwrotnego onBind(). Gdy klient otrzyma IBinder, może zacząć korzystać z usługi za pomocą tego interfejsu.

Z usługą może się jednocześnie powiązać wielu klientów. Gdy klient zakończy interakcję z usługą, wywołuje metodę unbindService(), aby ją odłączyć. Gdy z usługą nie są powiązani żadni klienci, system ją niszczy.

Powiązaną usługę można wdrożyć na wiele sposobów, a jej implementacja jest bardziej skomplikowana niż w przypadku uruchomionej usługi. Z tego powodu powiązane usługi zostały omówione w osobnym dokumencie na temat powiązanych usług.

wysyłanie powiadomień do użytkownika,

Gdy usługa jest uruchomiona, może powiadamiać użytkownika o zdarzeniach za pomocą powiadomień na pasku powiadomień lub powiadomień na pasku stanu.

Powiadomienie na pasku to komunikat, który pojawia się na powierzchni bieżącego okna tylko na chwilę, a następnie znika. Powiadomienie na pasku stanu zawiera ikonę na pasku stanu z wiadomością, którą użytkownik może wybrać, aby wykonać działanie (np. rozpocząć aktywność).

Zwykle powiadomienie na pasku stanu jest najlepszą techniką, gdy zadanie w tle, takie jak pobieranie pliku, zostało zakończone i użytkownik może teraz podjąć działanie. Gdy użytkownik wybierze powiadomienie w widoku rozwiniętym, może ono rozpocząć działanie (np. wyświetlić pobrany plik).

zarządzanie cyklem życia usługi,

Cykl życia usługi jest znacznie prostszy niż cykl życia aktywności. Jednak jeszcze ważniejsze jest zwrócenie uwagi na to, jak usługa jest tworzona i niszczona, ponieważ może ona działać w tle bez wiedzy użytkownika.

Cykl życia usługi – od utworzenia do zniszczenia – może przebiegać na 2 sposoby:

  • uruchomiona usługa,

    Usługa jest tworzona, gdy inny komponent wywołuje startService(). Usługa działa wtedy bezterminowo i musi zatrzymać się sama, wywołując stopSelf(). Inny komponent może też zatrzymać usługę, wywołując stopService(). Gdy usługa zostanie zatrzymana, system ją niszczy.

  • powiązana usługa,

    Usługa jest tworzona, gdy inny komponent (klient) wywołuje metodę bindService(). Klient komunikuje się z usługą za pomocą interfejsu IBinder. Klient może zamknąć połączenie, wywołując unbindService(). Z tą samą usługą może być powiązanych wiele klientów. Gdy wszystkie zostaną odłączone, system niszczy usługę. Usługa nie musi się zatrzymywać.

Te 2 ścieżki nie są całkowicie odrębne. Możesz powiązać z usługą, która została już uruchomiona za pomocą startService(). Możesz na przykład uruchomić usługę muzyki w tle, wywołując metodę startService() z obiektem Intent, który identyfikuje muzykę do odtworzenia. Później, gdy użytkownik będzie chciał przejąć kontrolę nad odtwarzaczem lub uzyskać informacje o bieżącym utworze, aktywność może powiązać się z usługą, wywołując metodę bindService(). W takich przypadkach stopService() lub stopSelf() nie zatrzymuje usługi, dopóki wszystkie klienty nie zostaną odłączone.

Implementowanie wywołań zwrotnych cyklu życia

Podobnie jak aktywność, usługa ma metody wywołania zwrotnego cyklu życia, które możesz zaimplementować, aby monitorować zmiany stanu usługi i wykonywać zadania w odpowiednich momentach. Poniższa usługa szkieletowa demonstruje każdą z metod cyklu życia:

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
    }
}

Uwaga: w przeciwieństwie do metod wywołania zwrotnego cyklu życia działania nie musisz wywoływać implementacji klasy nadrzędnej tych metod wywołania zwrotnego.

Rysunek 2. Cykl życia usługi. Diagram po lewej stronie pokazuje cykl życia, gdy usługa jest tworzona za pomocą startService(), a diagram po prawej stronie pokazuje cykl życia, gdy usługa jest tworzona za pomocą bindService().

Rysunek 2 przedstawia typowe metody wywołania zwrotnego dla usługi. Chociaż na rysunku usługi utworzone przez startService() są oddzielone od tych utworzonych przez bindService(), pamiętaj, że każda usługa, niezależnie od sposobu jej uruchomienia, może potencjalnie umożliwiać klientom powiązanie się z nią. Usługa, która została początkowo uruchomiona za pomocą onStartCommand() (gdy klient wywołał startService()), nadal może otrzymać wywołanie onBind() (gdy klient wywoła bindService()).

Implementując te metody, możesz monitorować te 2 zagnieżdżone pętle cyklu życia usługi:

  • Cały cykl życia usługi trwa od momentu wywołania onCreate() do momentu zwrócenia onDestroy(). Podobnie jak aktywność, usługa wykonuje początkową konfigurację w metodzie onCreate() i zwalnia wszystkie pozostałe zasoby w metodzie onDestroy(). Na przykład usługa odtwarzania muzyki może utworzyć wątek, w którym muzyka jest odtwarzana w onCreate(), a następnie zatrzymać wątek w onDestroy().

    Uwaga: metody onCreate() i onDestroy() są wywoływane w przypadku wszystkich usług, niezależnie od tego, czy zostały utworzone przez startService() czy bindService().

  • Aktywny czas życia usługi rozpoczyna się od wywołania metody onStartCommand() lub onBind(). Każda metoda otrzymuje obiekt Intent, który został przekazany do metody startService() lub bindService().

    Jeśli usługa zostanie uruchomiona, aktywny czas życia zakończy się w tym samym czasie co cały czas życia (usługa jest nadal aktywna nawet po zwróceniu onStartCommand()). Jeśli usługa jest powiązana, aktywny czas życia kończy się, gdy onUnbind() zwraca wartość.

Uwaga: chociaż uruchomiona usługa jest zatrzymywana przez wywołanie metody stopSelf() lub stopService(), nie ma odpowiedniego wywołania zwrotnego dla usługi (nie ma wywołania zwrotnego onStop()). Jeśli usługa nie jest powiązana z klientem, system niszczy ją po jej zatrzymaniu – onDestroy() to jedyne wywołanie zwrotne, które otrzymasz.

Więcej informacji o tworzeniu usługi, która umożliwia powiązanie, znajdziesz w dokumencie Powiązane usługi, który zawiera więcej informacji o metodzie wywołania zwrotnego onRebind() w sekcji Zarządzanie cyklem życia powiązanej usługi.