:~$ newsletter --subscribe
cat ~/artykuly/mobile/przesylanie-danych-miedzy-aktywnosciami-w-androidzie.md

Przesyłanie danych między Aktywnościami w Androidzie

W poprzednim artykule na temat programowania w Androidzie, opisywałem co to są Aktywności, jaki jest ich cykl życia oraz jak je uruchomić. Część z was, podczas lektury poprzedniego postu pewnie pomyślała sobie, „ok, ale jak przesłać między tymi oknami dane?” jeśli tak to właśnie ten dylemat rozwiążemy w tym artykule. A więc do dzieła!

Założeniem projektantów systemu Android jest to, aby każda aplikacja składała się z różnych niezależnych od siebie okien. W tym celu programistom został więc udostępniony mechanizm Aktywności. Jednak, należy pamiętać o tym, że choć każde okno jest oddzielne to dane wprowadzone w jednym mogą być potrzebne w drugim. Jest to rzecz tak naturalna, że specjalnie do tego został zaprojektowany odpowiedni mechanizm służący właśnie do przekazywania między aktywnościami różnych obiektów.

Jak to wszystko się odbywa?

A więc tak, stanem wyjściowym będzie nowy projekt stworzony w artykule „pierwsza aplikacja w Android Studio„. Jego struktura prezentuje się tak:

proj-start-dane-aktywnosc

Na samym początku w layoucie activity_main.xml musimy dodać przycisk, który po kliknięciu będzie uruchamiał drugą aktywność. Przeciągamy więc z toolboxa odpowiednią kontrolkę i zmieniamy zawartość przyciska na tekst „Nowa aktywność„:

dodanie-buttona-dane-aktywnosci

Następnie w pliku MainActivity.java tworzymy nową metodę o nazwie nextStep(View view). Jej kod wygląda następująco:

java
public void nextStep(View view) {

}

Teraz z powrotem przechodzimy do activity_main.xml i po kliknięciu w buttona w prawej kolumnie „Properties” (pl. właściwości) odszukujemy pozycji o nazwie onClick i z listy wybieramy nowo dodaną metodę:

dodanie-metody-onclick-dane-aktywnosci

Kod naszego buttonu wygląda tak (można go wkleić do pliku z layoutem):

xml
<Button
        android:text="Button"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:layout_alignParentTop="true"
        android:layout_centerHorizontal="true"
        android:layout_marginTop="197dp"
        android:id="@+id/button"
        tools:text="Nowa aktywność"
        android:onClick="nextStep" />

Ok, teraz zgodnie z instrukcjami z artykułu „Aktywności w Androidzie” dodajemy do projektu nową aktywność o nazwie „SecondActivity„. Jako typ aktywności wybieramy na przykład „Blank Activity„.

Wracamy do metody nextStep() i wpisujemy tam kod, który uruchomi drugą aktywność czyli SecondActivity (szczegóły omawiane były w artykule „Aktywności w Androidzie„). Kod naszej metody wygląda więc następująco:

java
public void nextStep(View view) {
     Intent i = new Intent(this, SecondActivity.class);
     startActivity(i);
}

Teraz możemy uruchomić nasz projekt, i po kliknięciu w przycisk „Nowa aktywność” zostaniemy przeniesieni do nowego okna. Zbierzmy się więc za przekazywanie danych.

putExtra() co to takiego?

Tworząc obiekt typu Intent mamy publicznie dostępną metodę o nazwie putExtra(). Jest to metoda, która umożliwia nam przesyłanie danych z jednej aktywności do drugiej. Załóżmy, że w MainActivity wczytujemy jakieś tam informacje podane przez użytkownika – na potrzeby tego przykładu nie ma znaczenia w jaki sposób to robimy więc załóżmy, że wszystkie potrzebne dane mamy zapisane w polu typu String o nazwie name. Pole to jest publicznie dostępne w klasie MainActivity.

Nasz dotychczasowy kod:

java
public class MainActivity extends Activity {

    public String name;

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        name = "Łukasz Dudziński";
    }

    public void nextStep(View view) {
        Intent i = new Intent(this, SecondActivity.class);
        startActivity(i);
    }
}

Teraz chcemy dane zapisane w polu name przesłać do drugiej aktywności o nazwie SecondActivity. Wykorzystamy do tego omówioną wyżej metodę:

java
i.putExtra("name", name);

W ten właśnie sposób dodajemy do nowego Intentu dane, które będziemy mogli odczytać w drugiej aktywności.

Jak pewnie zauważyliście metoda putExtra() przyjmuje dwa argumenty, pierwszy typu String to unikalna nazwa danych, które przesyłamy, a drugi to przesyłany obiekt.

Uwaga: Nie każdy obiekt możemy w ten sposób przesłać do drugiej aktywności. Dozwolone są następujące typy obiektów:

  • putExtra(String name, Parcelable value);
  • putExtra(String name, long[] value);
  • putExtra(String name, byte value);
  • putExtra(String name, double[] value);
  • putExtra(String name, CharSequence value);
  • putExtra(String name, boolean[] value);
  • putExtra(String name, int value);
  • putExtra(String name, char[] value);
  • putExtra(String name, byte[] value);
  • putExtra(String name, Parcelable[] value);
  • putExtra(String name, Bundle value);
  • putExtra(String name, CharSequence[] value);
  • putExtra(String name, float[] value);
  • putExtra(String name, double value);
  • putExtra(String name, int[] value);
  • putExtra(String name, String[] value);
  • putExtra(String name, short[] value);
  • putExtra(String name, boolean value);
  • putExtra(String name, String value);
  • putExtra(String name, long value);
  • putExtra(String name, char value);
  • putExtra(String name, Serializable value);
  • putExtra(String name, float value);
  • putExtra(String name, short value);

Cały kod metody nextStep():

java
public void nextStep(View view) {
     Intent i = new Intent(this, SecondActivity.class);
     i.putExtra("name", name);
     startActivity(i);
}

Odczyt danych

Kiedy już uruchomimy drugą aktywność pasowało by odczytać wszystkie przesłane dane. Aby to zrobić musimy skorzystać z odpowiedniej metody obiektu Intent – oczywiście wcześniej pobierając odpowiedniego Intenta oraz jako argument podać unikalną nazwę naszych danych podaną przy zapisywaniu ich.

Dla Stringa będzie to wyglądało tak:

java
getIntent().getStringExtra("name");

Gdzie jako argument metody getStringExtra() podaliśmy unikalną nazwę naszych danych zapisaną w poprzednim Intencie (w metodzie putExtra()).

Uwaga: Każdy typ obiektu odczytujemy inną metodą:

booleangetBooleanArrayExtra(String name);
BundlegetBundleExtra(String name);
byte[]getByteArrayExtra(String name);
bytegetByteExtra(String name, byte defaultValue);
char[]getCharArrayExtra(String name);
chargetCharExtra(String name, char defaultValue);
CharSequence[]getCharSequenceArrayExtra(String name);
ArrayList<CharSequence>getCharSequenceArrayListExtra(String name);
CharSequencegetCharSequenceExtra(String name);
double[]getDoubleArrayExtra(String name);
doublegetDoubleExtra(String name, double defaultValue);
BundlegetExtras();
float[]getFloatArrayExtra(String name);
floatgetFloatExtra(String name, float defaultValue);
int[]getIntArrayExtra(String name);
intgetIntExtra(String name, int defaultValue);
ArrayList<Integer>getIntegerArrayListExtra(String name);
long[]getLongArrayExtra(String name);
longgetLongExtra(String name, long defaultValue);
Parcelable[]getParcelableArrayExtra(String name);
<T extends Parcelable>ArrayList<T>getParcelableArrayListExtra(String name);
<T extends Parcelable> TgetParcelableExtra(String name);
SerializablegetSerializableExtra(String name);
short[]getShortArrayExtra(String name);
shortgetShortExtra(String name, short defaultValue);
String[]getStringArrayExtra(String name);
ArrayList<String>getStringArrayListExtra(String name);
StringgetStringExtra(String name);

Cały kod naszej drugiej aktywności:

java
public class SecondActivity extends Activity {

    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_second);

        // Tutaj odczytujemy przesłane dane
        String name = getIntent().getStringExtra("name");
    }
}

Gotowe teraz wiemy już jak przekazywać dane między różnymi oknami w naszej aplikacji.

Dopisek (stan na 2026): mechanizm ekstrasów Intentu, czyli putExtra() i metody typu getStringExtra(), pozostaje aktualnym, oficjalnie dokumentowanym sposobem przekazywania danych między komponentami Androida. Przykłady w tym artykule są jednak napisane w Javie i pochodzą ze starszej wersji Android Studio. Współczesna dokumentacja Androida posługuje się Kotlinem.

Łukasz Dudziński
Łukasz Dudziński · założyciel i autor
Pasjonat informatyki, a zwłaszcza programowania. Zwariowany maniak na tle nowych technologii oraz komputerów. W wolnych chwilach bloger... więcej-o-mnie →
ls ~/artykuly/powiazane --limit 3
komentarze --count 2
rss dla komentarzy →
LeUZI2021-04-11 ·

Dzięki za artykuł z wyjaśnieniami działania intentu. Bardzo mi pomogły…

tomi012021-04-13 ·

Serio?

dodaj-komentarz

Komentarze są moderowane. Podane dane przetwarzamy wyłącznie w celu publikacji komentarza (polityka prywatności).