Ta strona została przetłumaczona przez Cloud Translation API.

Wprowadzenie do działań

Klasa Activity jest kluczowym komponentem aplikacji na Androida, a sposób uruchamiania i łączenia aktywności to podstawowy element modelu aplikacji platformy. W przeciwieństwie do paradygmatów programowania, w których aplikacje są uruchamiane za pomocą metody main(), system Android inicjuje kod w instancji Activity, wywołując określone metody wywołania zwrotnego odpowiadające konkretnym etapom cyklu życia.

W tym dokumencie omówimy pojęcie działań i podamy kilka wskazówek, jak z nimi korzystać. Więcej informacji o sprawdzonych metodach tworzenia architektury aplikacji znajdziesz w przewodniku po architekturze aplikacji.

Koncepcja działań

Aplikacja mobilna różni się od jej wersji na komputery tym, że interakcja użytkownika z aplikacją nie zawsze zaczyna się w tym samym miejscu. Zamiast tego ścieżka użytkownika często zaczyna się niedeterministycznie. Jeśli na przykład otworzysz aplikację do poczty e-mail na ekranie głównym, zobaczysz listę e-maili. Jeśli natomiast używasz aplikacji mediów społecznościowych, która następnie uruchamia Twoją aplikację do poczty e-mail, możesz przejść bezpośrednio do ekranu aplikacji, by utworzyć e-maila.

Klasa Activity ma ułatwiać ten model. Gdy jedna aplikacja wywołuje inną, aplikacja wywołująca wykonuje działanie w drugiej aplikacji, a nie jako jej element. Aktywność jest w ten sposób punktem wejścia aplikacji w interakcję z użytkownikiem. Działanie wdrażasz jako podklasę klasy Activity.

Działanie to okno, w którym aplikacja generuje interfejs użytkownika. Okno zazwyczaj wypełnia ekran, ale może być mniejsze od ekranu i unosić się nad innymi oknami. Zasadniczo jedno działanie implementuje jeden ekran w aplikacji. Na przykład w jednej z działań w aplikacji może być zaimplementowany ekran Preferencje, a w innym ekran Wybierz zdjęcie.

Większość aplikacji ma wiele ekranów, co oznacza, że obejmują one wiele aktywności. Zwykle jedna aktywność w aplikacji jest określana jako główna aktywność, czyli pierwszy ekran wyświetlany po uruchomieniu aplikacji przez użytkownika. Każda aktywność może następnie rozpoczynać inne działanie, by wykonać inne działania. Na przykład głównym działaniem w prostej aplikacji do obsługi poczty e-mail może być ekran wyświetlający skrzynkę odbiorczą. Następnie mogą uruchomić się inne działania, które będą wyświetlać ekrany do takich zadań jak pisanie e-maili czy otwieranie poszczególnych e-maili.

Chociaż działania wspólnie tworzą spójne wrażenia użytkownika, każda z nich jest tylko luźno powiązana z pozostałymi działaniami – zazwyczaj występują one w minimalnym stopniu. Na przykład aplikacja przeglądarki może uruchamiać działanie udostępniania w aplikacji mediów społecznościowych.

Aby korzystać z aktywności w aplikacji, musisz zarejestrować informacje na ich temat w jej pliku manifestu i odpowiednio zarządzać cyklami życia aktywności. Zagadnienia te zostały omówione w pozostałej części niniejszego dokumentu.

Konfigurowanie pliku manifestu

Aby aplikacja mogła korzystać z aktywności, musisz je zadeklarować w pliku manifestu i określić ich atrybuty.

Deklarowanie aktywności

Aby zadeklarować aktywność, otwórz plik manifestu i dodaj element <activity> jako element podrzędny elementu <application>. Na przykład:

<manifest ... >
  <application ... >
      <activity android:name=".ExampleActivity" />
      ...
  </application ... >
  ...
</manifest >

Jedynym wymaganym atrybutem tego elementu jest android:name, który określa nazwę klasy działania. Możesz też dodawać atrybuty definiujące cechy działań, takie jak etykieta, ikona czy motyw interfejsu. Więcej informacji o tych i innych atrybutach znajdziesz w dokumentacji referencyjnej elementu <activity>.

Uwaga: po opublikowaniu aplikacji nie zmieniaj nazw działań. Jeśli to zrobisz, niektóre funkcje, takie jak skróty do aplikacji, mogą nie działać prawidłowo. Więcej informacji o zmianach, których należy unikać po opublikowaniu, znajdziesz w artykule Rzeczy, których nie można zmienić.

Deklarowanie filtrów intencji

Filtry intencji to bardzo zaawansowana funkcja platformy Androida. Umożliwiają one uruchomienie działania nie tylko na podstawie jawnego, ale też ukrytego żądania. Na przykład jednoznaczne żądanie może spowodować, że system „rozpocznie działanie wysyłania e-maili w aplikacji Gmail”. Z kolei żądanie niejawne informuje system, że ma „uruchomić ekran wysyłania e-maili w dowolnym działaniu, które może wykonać to zadanie”. Gdy interfejs systemu pyta użytkownika, której aplikacji użyć do wykonania zadania, jest to filtr intencji.

Możesz skorzystać z tej funkcji, zadeklarując atrybut <intent-filter> w elemencie <activity>. Definicja tego elementu zawiera element <action> oraz opcjonalnie element <category> lub <data>. Połączenie tych elementów wskazuje typ intencji, na który aktywność może reagować. Na przykład ten fragment kodu pokazuje, jak skonfigurować działanie, które wysyła dane tekstowe i odbiera żądania od innych działań:

<activity android:name=".ExampleActivity" android:icon="@drawable/app_icon">
    <intent-filter>
        <action android:name="android.intent.action.SEND" />
        <category android:name="android.intent.category.DEFAULT" />
        <data android:mimeType="text/plain" />
    </intent-filter>
</activity>

W tym przykładzie element <action> określa, że działanie to wysyła dane. Zadeklarowanie elementu <category> jako DEFAULT umożliwia aktywności otrzymywanie żądań uruchomienia. Element <data> określa typ danych, jakie ta aktywność może wysyłać. Ten fragment kodu pokazuje, jak wywołać opisaną powyżej aktywność:

Kotlin

val sendIntent = Intent().apply {
    action = Intent.ACTION_SEND
    type = "text/plain"
    putExtra(Intent.EXTRA_TEXT, textMessage)
}
startActivity(sendIntent)

Java

// Create the text message with a string
Intent sendIntent = new Intent();
sendIntent.setAction(Intent.ACTION_SEND);
sendIntent.setType("text/plain");
sendIntent.putExtra(Intent.EXTRA_TEXT, textMessage);
// Start the activity
startActivity(sendIntent);

Jeśli chcesz, aby aplikacja była samodzielna i nie pozwalać innym aplikacjom na aktywowanie aktywności, nie potrzebujesz żadnych innych filtrów intencji. Działania, których nie chcesz udostępniać innym aplikacjom, nie powinny zawierać filtrów intencji i możesz je uruchamiać samodzielnie za pomocą intencji jawnych. Więcej informacji o tym, jak działania mogą reagować na intencje, znajdziesz w artykule o intencjach i filtrach intencji.

Deklarowanie uprawnień

Aby określić, które aplikacje mogą rozpoczynać konkretną aktywność, użyj tagu <activity> w pliku manifestu. Aktywność nadrzędna nie może uruchamiać aktywności podrzędnej, chyba że obie mają w pliku manifestu takie same uprawnienia. Jeśli w przypadku aktywności nadrzędnej zadeklarujesz element <uses-permission>, każda aktywność podrzędna musi mieć pasujący element <uses-permission>.

Jeśli np. do udostępnienia posta w mediach społecznościowych aplikacja chce użyć hipotetycznej aplikacji o nazwie SocialApp, musi ona definiować uprawnienia, które musi mieć aplikacja, która ją wywołuje:

<manifest>
<activity android:name="...."
   android:permission=”com.google.socialapp.permission.SHARE_POST”

/>

Następnie, aby móc wywoływać SocialApp, Twoja aplikacja musi pasować do uprawnień ustawionych w pliku manifestu SocialApp:

<manifest>
   <uses-permission android:name="com.google.socialapp.permission.SHARE_POST" />
</manifest>

Więcej informacji o uprawnieniach i zabezpieczeniach znajdziesz w artykule Zabezpieczenia i uprawnienia.

Zarządzanie cyklem życia aktywności

W trakcie działania aktywność przechodzi kilka stanów. Korzystasz z serii wywołań zwrotnych do obsługi przejść między stanami. W sekcjach poniżej opisujemy te wywołania.

onCreate()

Musisz wdrożyć to wywołanie zwrotne, które jest uruchamiane, gdy system utworzy aktywność. Implementacja powinna zainicjować podstawowe komponenty działania: na przykład aplikacja powinna tworzyć widoki danych i wiązać dane z listami tutaj. Przede wszystkim tutaj musisz wywołać setContentView(), aby określić układ interfejsu aktywności.

Po zakończeniu onCreate() następne wywołanie zwrotne to zawsze onStart().

onStart()

Gdy działanie onCreate() zostanie zamknięte, działanie przejdzie w stan Rozpoczęte i stanie się ono widoczne dla użytkownika. Wywołanie zwrotne zawiera informacje na temat ostatecznych przygotowań działania do przejścia na pierwszy plan i przejścia na interaktywność.

onWznów()

System wywołuje to wywołanie zwrotne tuż przed rozpoczęciem interakcji z użytkownikiem. W tym momencie aktywność znajduje się na górze stosu aktywności i obejmuje wszystkie dane wejściowe użytkownika. Większość kluczowych funkcji aplikacji jest wdrażana w metodzie onResume().

Wywołanie zwrotne onPause() zawsze występuje zgodnie z metodą onResume().

onPause()

System wywołuje funkcję onPause(), gdy aktywność przestaje być aktywna i przechodzi w stan wstrzymania. Ten stan pojawia się np. wtedy, gdy użytkownik kliknie przycisk Wstecz lub Ostatnie. Gdy system wywołuje funkcję onPause() w związku z Twoją aktywnością, technicznie oznacza to, że aktywność jest nadal częściowo widoczna, ale najczęściej jest to sygnał, że użytkownik ją opuszcza, przez co wkrótce przejdzie w stan Zatrzymana lub Wznowiona.

Działanie w stanie wstrzymania może nadal aktualizować interfejs użytkownika, jeśli użytkownik oczekuje, że się on zaktualizuje. Może to być np. wyświetlenie ekranu mapy nawigacyjnej lub odtwarzany odtwarzacz. Nawet jeśli takie działania przestaną być aktywne, użytkownik oczekuje, że interfejs użytkownika będzie nadal aktualizowany.

Nie używaj onPause() do zapisywania danych aplikacji i użytkownika, wykonywania wywołań sieciowych ani wykonywania transakcji w bazie danych. Więcej informacji o zapisywaniu danych znajdziesz w artykule Zapisywanie i przywracanie stanu aktywności.

Gdy onPause() zakończy wykonywanie, następne wywołanie zwrotne będzie mieć wartość onStop() lub onResume(), w zależności od tego, co się stanie po tym, jak aktywność przejdzie w stan wstrzymania.

onStop()

System wywołuje onStop(), gdy aktywność nie jest już widoczna dla użytkownika. Może się tak zdarzyć, gdy aktywność jest w trakcie niszczenia, rozpoczyna się nowa lub wkracza już w stan wznowienia i obejmuje zatrzymaną aktywność. We wszystkich tych przypadkach przerwana aktywność nie jest już widoczna.

Następne wywołanie zwrotne to onRestart(), jeśli aktywność wraca do interakcji z użytkownikiem, lub onDestroy(), jeśli aktywność zostaje całkowicie zakończona.

onRestart()

System wywołuje to wywołanie zwrotne, gdy działanie w stanie Zatrzymano ma na celu ponowne uruchomienie. onRestart() przywraca stan aktywności od momentu jej zatrzymania.

Po tym wywołaniu zwrotnym zawsze występuje onStart().

onDestroy()

System wywołuje to wywołanie zwrotne, zanim działanie zostanie zniszczone.

To ostatnie wywołanie zwrotne w tej aktywności. Funkcja onDestroy() jest zazwyczaj wdrażana w celu zapewnienia, że wszystkie zasoby aktywności zostaną zwolnione po zniszczeniu aktywności lub zawierającego ją procesu.

Ta sekcja zawiera tylko wprowadzenie do tego tematu. Bardziej szczegółowe informacje na temat cyklu życia aktywności i jego wywołań zwrotnych znajdziesz w artykule Cykl życia aktywności.