Utwórz fragment

Fragment reprezentuje modułowy fragment interfejsu użytkownika w aktywności. Fragment ma własny cykl życia, otrzymuje własne zdarzenia wejściowe i można dodawać i usuwać fragmenty, gdy aktywna jest aktywność tego rodzaju.

W tym dokumencie opisano sposób tworzenia fragmentu i umieszczania go w aktywności.

Konfigurowanie środowiska

Takie fragmenty wymagają zależności od biblioteki fragmentów AndroidaX. Aby uwzględnić tę zależność, musisz dodać repozytorium Google Maven do pliku settings.gradle projektu.

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

dependencyResolutionManagement {
    repositoriesMode.set(RepositoriesMode.FAIL_ON_PROJECT_REPOS)
    repositories {
        google()
        ...
    }
}

Aby uwzględnić w projekcie bibliotekę fragmentu AndroidaX, dodaj te zależności do pliku build.gradle aplikacji:

dependencies {
    def fragment_version = "1.6.2"

    // Java language implementation
    implementation "androidx.fragment:fragment:$fragment_version"
    // Kotlin
    implementation "androidx.fragment:fragment-ktx:$fragment_version"
}

dependencies {
    val fragment_version = "1.6.2"

    // Java language implementation
    implementation("androidx.fragment:fragment:$fragment_version")
    // Kotlin
    implementation("androidx.fragment:fragment-ktx:$fragment_version")
}

Tworzenie klasy fragmentu

Aby utworzyć fragment, rozszerz klasę AndroidX Fragment i zastąp jej metody, aby wstawić logikę aplikacji, podobnie jak robi się to przy tworzeniu klasy Activity. Aby utworzyć minimalny fragment definiujący własny układ, udostępnij zasób układu fragmentu do konstruktora podstawowego, jak w przykładzie poniżej:

class ExampleFragment : Fragment(R.layout.example_fragment)

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }
}

Biblioteka Fragment udostępnia też bardziej specjalistyczne klasy bazowe fragmentów:

DialogFragment

Wyświetla pływające okno. Użycie tej klasy do utworzenia okna jest dobrą alternatywą dla korzystania z metod pomocniczych dotyczących okien w klasie Activity, ponieważ fragmenty automatycznie obsługują tworzenie i czyszczenie elementu Dialog. Więcej informacji znajdziesz w sekcji Wyświetlanie okien dialogowych przy użyciu DialogFragment.

PreferenceFragmentCompat

Wyświetla hierarchię obiektów Preference w postaci listy. Za pomocą PreferenceFragmentCompat możesz utworzyć ekran ustawień aplikacji.

Dodawanie fragmentu do działania

Ogólnie fragment musi być umieszczony w obrębie AndroidaX FragmentActivity, aby był częścią interfejsu użytkownika w układzie aktywności. FragmentActivity to klasa bazowa dla AppCompatActivity, więc jeśli już podklasyfikujesz AppCompatActivity, aby zapewnić zgodność wsteczną w aplikacji, nie musisz zmieniać klasy podstawowej aktywności.

Możesz dodać fragment do hierarchii widoków działania, definiując fragment w pliku układu aktywności lub definiując kontener z fragmentem w pliku układu aktywności, a następnie automatycznie dodając fragment z poziomu aktywności. W obu przypadkach musisz dodać element FragmentContainerView określający lokalizację, w której fragment powinien zostać umieszczony w hierarchii widoków aktywności. Zdecydowanie zalecamy, aby zawsze używać FragmentContainerView jako kontenera na potrzeby fragmentów, ponieważ FragmentContainerView zawiera poprawki specyficzne dla fragmentów, których nie obsługują inne grupy widoków, takie jak FrameLayout.

Dodaj fragment za pomocą pliku XML

Aby deklaratywnie dodać fragment do kodu XML układu aktywności, użyj elementu FragmentContainerView.

Oto przykładowy układ aktywności zawierający pojedynczy element FragmentContainerView:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:name="com.example.ExampleFragment" />

Atrybut android:name określa nazwę klasy Fragment, którą chcesz uruchomić. Gdy układ aktywności jest zawyżony, określony fragment jest tworzony, następuje wywołanie onInflate() w nowo utworzonym fragmencie i tworzony jest element FragmentTransaction w celu dodania fragmentu do elementu FragmentManager.

Automatyczne dodawanie fragmentów

Aby automatycznie dodawać fragment do układu aktywności, układ powinien zawierać element FragmentContainerView, który będzie służyć jako kontener fragmentu, jak w tym przykładzie:

<!-- res/layout/example_activity.xml -->
<androidx.fragment.app.FragmentContainerView
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:id="@+id/fragment_container_view"
    android:layout_width="match_parent"
    android:layout_height="match_parent" />

W przeciwieństwie do pliku XML atrybut android:name nie jest tutaj używany w elementach FragmentContainerView, więc żaden konkretny fragment nie jest instalowany automatycznie. Zamiast tego do utworzenia instancji fragmentu i dodania go do układu działania używany jest element FragmentTransaction.

Gdy aktywność jest aktywna, możesz dokonywać transakcji związanych z fragmentami, np. dodawać, usuwać lub zastępować fragmenty. W FragmentActivity możesz pobrać wystąpienie FragmentManager, za pomocą którego można utworzyć FragmentTransaction. Następnie możesz utworzyć wystąpienie fragmentu w metodzie onCreate() aktywności za pomocą FragmentTransaction.add(), przekazując identyfikator ViewGroup kontenera w układzie i klasę fragmentu, którą chcesz dodać, a następnie zatwierdź transakcję, jak pokazano w tym przykładzie:

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            supportFragmentManager.commit {
                setReorderingAllowed(true)
                add<ExampleFragment>(R.id.fragment_container_view)
            }
        }
    }
}

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, null)
                .commit();
        }
    }
}

W poprzednim przykładzie transakcja dotycząca fragmentu jest tworzona tylko wtedy, gdy savedInstanceState ma wartość null. Dzięki temu fragment zostanie dodany tylko raz, podczas tworzenia działania. Po zmianie konfiguracji i odtworzeniu aktywności savedInstanceState nie ma już wartości null i nie trzeba dodawać fragmentu po raz drugi, ponieważ fragment jest automatycznie przywracany z savedInstanceState.

Jeśli fragment wymaga danych początkowych, argumenty można przekazać do niego, podając Bundle w wywołaniu funkcji FragmentTransaction.add(), jak pokazano poniżej:

class ExampleActivity : AppCompatActivity(R.layout.example_activity) {
      override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        if (savedInstanceState == null) {
            val bundle = bundleOf("some_int" to 0)
            supportFragmentManager.commit {
                setReorderingAllowed(true)
                add<ExampleFragment>(R.id.fragment_container_view, args = bundle)
            }
        }
    }
}

public class ExampleActivity extends AppCompatActivity {
    public ExampleActivity() {
        super(R.layout.example_activity);
    }
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        if (savedInstanceState == null) {
            Bundle bundle = new Bundle();
            bundle.putInt("some_int", 0);

            getSupportFragmentManager().beginTransaction()
                .setReorderingAllowed(true)
                .add(R.id.fragment_container_view, ExampleFragment.class, bundle)
                .commit();
        }
    }
}

Argumenty Bundle można pobrać z fragmentu, wywołując metodę requireArguments(). Do pobierania każdego argumentu można używać odpowiednich metod pobierania Bundle.

class ExampleFragment : Fragment(R.layout.example_fragment) {
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val someInt = requireArguments().getInt("some_int")
        ...
    }
}

class ExampleFragment extends Fragment {
    public ExampleFragment() {
        super(R.layout.example_fragment);
    }

    @Override
    public void onViewCreated(@NonNull View view, Bundle savedInstanceState) {
        int someInt = requireArguments().getInt("some_int");
        ...
    }
}

Zobacz także:

Więcej informacji o transakcjach związanych z fragmentami i elementami FragmentManager znajdziesz w przewodniku po menedżerach fragmentów.