Wprowadzenie do działań

Klasa Activity to kluczowy komponent Androida. oraz sposób uruchamiania i łączenia działań to podstawa jako część modelu aplikacji platformy. W przeciwieństwie do paradygmatów programowania które aplikacje są uruchamiane z użyciem metody main(), system Android system inicjuje kod w instancji Activity przez konkretne metody wywołania zwrotnego, które odpowiadają konkretnym etapom cyklu życia usługi.

Przedstawiliśmy w nim pojęcie działań, a w dalszej części przedstawiliśmy podstawowe wskazówki dotyczące pracy z nimi. Więcej informacji o sprawdzonych metodach tworzenia architektury aplikacji znajdziesz w artykule patrz Przewodnik po architekturze aplikacji.

Pojęcie działań

Aplikacja mobilna różni się od jej wersji na komputery tym, 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 np. otworzysz aplikację do obsługi poczty na ekranie głównym, możesz zobaczyć ikonę listę adresów e-mail. Jeśli natomiast korzystasz z aplikacji do obsługi mediów społecznościowych, jeśli uruchomisz aplikację do poczty e-mail, możesz przejść bezpośrednio do ekranu aplikacji napisanego e-maila.

Klasa Activity ma ułatwiać stosowanie tego schematu. Gdy jedna aplikacja wywołuje drugą, ta wywołuje działanie w drugiej aplikacji, a nie jej całościowej całości. W ten sposób aktywność służy jako który jest punktem wejścia w interakcję aplikacji z użytkownikiem. Wdrożenie activity jako podklasa klasy Activity.

Aktywność to okno, w którym aplikacja rysuje jego UI. To okno zwykle wypełnia ekran, ale może być mniejsze niż i pływać nad innymi oknami. Zazwyczaj jedna aktywność implementuje jeden ekran w aplikacji. Na przykład jedno z działań w aplikacji może implementować ekran Preferencje, a inne stosować ekran Wybierz zdjęcie.

Większość aplikacji ma wiele ekranów, co oznacza, że składa się aktywności. Zazwyczaj jedno działanie w aplikacji jest określane jako główne activity, czyli pierwszy ekran, który wyświetla się po uruchomieniu aplikacji przez użytkownika. Każda aktywność może następnie rozpoczynać nowe działanie w celu wykonywać różne działania. Na przykład główna aktywność w zwykłym e-mailu aplikacja może udostępnić ekran, na którym wyświetla się skrzynka odbiorcza. Następnie główny element aktywność może uruchamiać inne działania, w których wyświetlane są ekrany zadań, na przykład pisania e-maili i otwierania poszczególnych e-maili.

Choć działania razem tworzą spójną całość w aplikacji, każda aktywność jest tylko luźno powiązana z innymi działaniami; jest zazwyczaj minimalnych zależności między działaniami w aplikacji. aktywność często inicjuje działania należące do innych aplikacji. Przykład: przeglądarka może uruchomić aktywność udostępniania w aplikacji mediów społecznościowych.

Aby korzystać z aktywności w aplikacji, musisz zarejestrować informacje o nich w z manifestu aplikacji i musisz odpowiednio zarządzać cyklami życia działań. Zagadnienia te zostały omówione w pozostałej części tego dokumentu.

Konfigurowanie pliku manifestu

Aby aplikacja mogła korzystać z aktywności, musisz je zadeklarować. i niektórych ich atrybutach.

Deklarowanie aktywności

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

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

Jedynym wymaganym atrybutem tego elementu jest android:nazwa, , która określa nazwę klasy aktywności. Możesz też dodać atrybuty które określają cechy aktywności, np. etykietę, ikonę lub motyw interfejsu. Więcej informacji o tych i innych atrybutach znajdziesz w artykule <activity> dokumentacji elementów.

Uwaga: po opublikowaniu aplikacji: nie zmieniaj aktywności nazw. Może to spowodować uszkodzenie niektórych funkcji, np. skrótów do aplikacji. Więcej informacji o zmianach, których należy unikać po opublikowaniu, znajdziesz w artykule To, co nie może się zmienić.

Deklarowanie filtrów intencji

Filtry intencji to bardzo przydatna funkcja platformy Androida. Ta które umożliwia uruchomienie działania opartego nie tylko na jawne, ale też niejawne. Przykład: wyraźne żądanie może nakazać systemowi „rozpoczęcie wysyłania wiadomości e-mail”. w aplikacji Gmail”. Z kolei żądanie niejawne informuje „Uruchom ekran Wyślij e-maila w dowolnym które mogą wykonać zadanie”. Gdy interfejs systemu pyta użytkownika, której aplikacji użyć podczas wykonywania zadania – jest to w praktyce filtr intencji.

Aby skorzystać z tej funkcji, deklaruj <filtr-intent> w <activity>. Definicja tego elementu zawiera <action>, opcjonalnie <category> element lub <data> . Te elementy połącz, aby określić typ zamiaru, na który może odpowiedzieć Twoja aktywność. Dla: z tego fragmentu kodu dowiesz się, jak skonfigurować aktywność, która wysyła dane tekstowe i otrzymuje w tym celu żą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ładowej funkcji <action> określa, że ta aktywność wysyła dane. Deklarowanie atrybutu <category> jako element DEFAULT włącza działanie do otrzymywania próśb o wprowadzenie na rynek. Parametr <data> określa typ danych, ta aktywność może wysyłać wiadomości. Fragment kodu poniżej pokazuje, jak wywoływać metodę opisana powyżej czynność:

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 Twoja aplikacja była samodzielna i nie zezwalała na aktywowanie innych aplikacji jego działań, żadnych innych filtrów intencji. Aktywności, których nie chcesz robić dostępnych dla innych aplikacji nie powinny mieć żadnych filtrów intencji, samodzielnie rozpoczynać je od intencji. Więcej informacji o tym, Twoje działania mogą reagować na intencje, zobacz Intencje i filtry intencji.

Deklarowanie uprawnień

Pliku manifestu możesz użyć za pomocą Tag <activity> do sterowania aplikacje, które mogą rozpoczynać określoną aktywność. Działanie rodzica nie może uruchomić aktywności dziecka, chyba że obie mają takie same uprawnienia pliku manifestu. Jeśli zadeklarujesz <uses-permission> dla aktywności nadrzędnej, każda aktywność podrzędna musi mieć . <uses-permission>, .

Na przykład, jeśli aplikacja chce używać hipotetycznej aplikacji o nazwie SocialApp aby udostępnić posta w mediach społecznościowych, aplikacja SocialApp musi definiować uprawnienia które aplikacja musi mieć: 

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

/>

Następnie, aby móc wywoływać SocialApp, aplikacja musi spełniać warunki uprawnień Plik manifestu aplikacji SocialApp: 

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

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

Zarządzanie cyklem życia aktywności

W ciągu swojego życia aktywność przechodzi przez kilka stanów. Do obsługi przejść między stanami używa się serii wywołań zwrotnych. W poniższych sekcjach wprowadzić te wywołania zwrotne.

onCreate()

Musisz zaimplementować to wywołanie zwrotne, które jest wywoływane, gdy system utworzy działania. Implementacja powinna zainicjować kluczowe komponenty Twojej aktywności: np. aplikacja powinna tworzyć widoki danych i wiązać dane z tutaj. Co najważniejsze, w tym miejscu należy zadzwonić setContentView() do zdefiniowania układu interfejsu aktywności.

Gdy zakończy się działanie funkcji onCreate(), następne wywołanie zwrotne to zawsze onStart().

onStart()

Po wyjściu z aplikacji onCreate() aktywność przechodzi w stan rozpoczęcia, a aktywność staje się widoczna dla użytkownika. Wywołanie zwrotne zawiera wynik ostatecznych przygotowań do wykonania działania wychodziły na pierwszy plan i stały się interaktywne.

onWznów()

System wywołuje to wywołanie zwrotne tuż przed rozpoczęciem interakcji. z użytkownikiem. W tym momencie aktywność znajduje się na jej początku i rejestruje wszystkie dane wejściowe użytkownika. Większość kluczowych funkcji aplikacji zaimplementowane w metodzie onResume().

Zawsze dostępne wywołanie zwrotne onPause() obserwuje: onResume().

onPause()

System wywołuje onPause(), gdy aktywność zniknie zaznaczenie i przechodzi w stan wstrzymania. Ten stan występuje, gdy na przykład użytkownik klika przycisk Wstecz lub Ostatnie. Gdy system wywoła onPause() za Twoją aktywność, technicznie oznacza to, że Twoja aktywność jest wciąż częściowo widoczna, ale najczęściej wskazuje na to, użytkownik opuszcza aktywność i wkrótce zostanie ona umieszczona w Stan zatrzymany lub wznowiony.

Działanie, które jest w stanie wstrzymania, może nadal aktualizować interfejs, jeśli użytkownik oczekuje aktualizacji interfejsu. Przykładem takiej aktywności może być wyświetlenie nawigacji na ekranie mapy lub w odtwarzaczu. Nawet jeśli takie działania stracą koncentrację, użytkownik oczekuje, że interfejs użytkownika będzie nadal aktualizowany.

Nie należy używać: onPause(), aby zapisać aplikację lub użytkownika do analizy danych, wykonywać wywołania sieciowe i wykonywać transakcje w bazie danych. Informacje na temat oszczędzania danych można znaleźć w sekcji Zapisywanie i przywracanie stanu aktywności.

Gdy onPause() zakończy wykonywanie, następne wywołanie zwrotne to onStop() lub onResume(), w zależności od ma miejsce, gdy aktywność przejdzie w stan wstrzymania.

onStop()

System wywołuje metodę onStop(), gdy aktywność nie jest już widoczna dla użytkownika. Może się tak zdarzyć, gdy działanie jest niszczone, lub rozpoczyna się istniejąca aktywność ma stan Wznowiono i obejmuje zatrzymaną aktywność. We wszystkich tych przypadkach zatrzymana aktywność nie jest już w ogóle nie są widoczne.

Kolejne wywołanie zwrotne, które wywołuje system, to onRestart(), jeśli aktywność powraca i wchodzi w interakcję z użytkownikiem, onDestroy() jeśli ta aktywność zostanie całkowicie zakończona.

onRestart()

System wywołuje to wywołanie zwrotne, gdy działanie w stanie zatrzymania to który zaraz się uruchomi. onRestart() przywraca stan aktywności z chwili jej zatrzymania.

Po tym wywołaniu zawsze następuje: onStart()

onDestroy()

System wywołuje to wywołanie zwrotne przed zniszczeniem działania.

Jest to ostatnie wywołanie zwrotne od aktywności. onDestroy() to zwykle wdrażane, by zapewnić, że wszystkie zasoby działania są zwolniony po zniszczeniu działania lub obejmującego go proces.

Ta sekcja zawiera jedynie wprowadzenie do tego tematu. Więcej szczegółowe omówienie cyklu życia aktywności i jego wywołań zwrotnych, Więcej informacji: Aktywność Cykl życia.