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

Migracja do komponentu Nawigacja

Komponent Nawigacja to biblioteka, która może zarządzać złożoną nawigacją, animacją przejścia, precyzyjnymi linkami, oraz argumentu sprawdzany podczas kompilowania przekazywany między ekranami aplikacji.

Ten dokument służy jako ogólny przewodnik po migracji istniejącej aplikacji do przy użyciu komponentu Nawigacja.

Ogólnie migracja obejmuje te czynności:

Przenoszenie logiki UI z ekranu poza działania – przenieś interfejs aplikacji logują się w działaniach, tak by każda z nich posiadała wyłącznie logikę komponenty interfejsu globalnego nawigacji, takie jak Toolbar, podczas przekazywania implementacji poszczególnych ekranów we fragmencie lub niestandardowym miejscu docelowym.
Zintegruj komponent nawigacji – w przypadku każdego działania utwórz plik graf nawigacji zawierający co najmniej jeden fragment zarządzany przez ten działania. Zastąp transakcje związane z fragmentami operacjami komponentu Nawigacja.
Dodaj miejsca docelowe aktywności – zamień połączenia (startActivity()) na za pomocą miejsc docelowych aktywności.
Połącz aktywności – łącz wykresy nawigacyjne w przypadkach, gdy: różne działania mają wspólny układ.

Wymagania wstępne

W tym przewodniku przyjęto założenie, że aplikacja została już przeniesiona, aby mogła korzystać AndroidX. W przeciwnym razie migrację swojego projektu, by można było zacząć korzystać z AndroidaX i kontynuuję.

Logi UI specyficzne dla ekranu zostaje usunięta z działań

Aktywności to komponenty na poziomie systemu, które ułatwiają interakcję graficzną między aplikacją a Androidem. Aktywności są zarejestrowane w pliku manifestu aplikacji. aby Android wie, jakie działania są dostępne do uruchomienia. Aktywność pozwala aplikacji na reagowanie również na zmiany w Androidzie, np. gdy interfejs aplikacji wkracza na pierwszy plan lub go opuszcza, obraca się itd. aktywność może też służyć jako miejsce, stan udostępniania między ekranami.

Aktywności w kontekście aplikacji powinny służyć jako host do nawigacji i powinni dysponować wiedzą i logiką przechodzenia między ekranami, i tak dalej. Lepiej jednak zarządzać szczegółami interfejsu do mniejszej części interfejsu, którą można wykorzystać wielokrotnie. Zalecana implementacja wzór to fragmenty. Zobacz Pojedyncza aktywność: dlaczego, kiedy i jak , aby dowiedzieć się więcej o zaletach używania fragmentów. Nawigacja obsługuje fragmenty za pomocą zależności fragmentu nawigacji. Nawigacja obsługuje też niestandardowych typów miejsc docelowych.

Jeśli aplikacja nie korzysta z fragmentów, najpierw musisz przeprowadzić migrację. na każdym ekranie aplikacji, aby użyć fragmentu. Nie usuwasz aktywności o w tym punkcie. Zamiast tego tworzysz fragment reprezentujący ekran i przerwy logikę interfejsu użytkownika przez odpowiedzialność.

Przedstawiamy fragmenty

Aby zilustrować proces wprowadzania fragmentów, zacznijmy od przykładu aplikacji składającej się z 2 ekranów: listy produktów i Szczegóły produktu. Po kliknięciu usługi na ekranie listy na ekran ze szczegółowymi informacjami.

W tym przykładzie ekrany z listą i szczegółami są obecnie oddzielnymi działaniami.

Utwórz nowy układ do hostowania interfejsu użytkownika

Aby przedstawić fragment, utwórz nowy plik układu dla aktywności go hostować. Spowoduje to zastąpienie obecnego układu widoku treści aktywności.

Aby uzyskać prosty widok, możesz użyć elementu FrameLayout, jak pokazano poniżej przykładowy product_list_host:

<FrameLayout
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:id="@+id/main_content"
   android:layout_height="match_parent"
   android:layout_width="match_parent" />

Atrybut id odnosi się do sekcji treści, do której później dodajemy atrybuty fragment.

Następnie w funkcji onCreate() aktywności zmodyfikuj odwołanie do pliku układu w funkcji onCreate aktywności, aby wskazać nowy plik układu:

Kotlin

class ProductListActivity : AppCompatActivity() {
    ...
    override fun onCreate(savedInstanceState: Bundle?) {
        ...
        // Replace setContentView(R.layout.product_list) with the line below
        setContentView(R.layout.product_list_host)
        ...
    }
}

Java

public class ProductListActivity extends AppCompatActivity {
    ...
    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        ...
        // Replace setContentView(R.layout.product_list); with the line below
        setContentView(R.layout.product_list_host);
        ...
    }
}

Istniejący układ (w tym przykładzie product_list) jest używany jako widok główny dla fragmentu, który chcesz utworzyć.

Tworzenie fragmentu

Utwórz nowy fragment, aby zarządzać interfejsem Twojego ekranu. Dobrą praktyką jest muszą być spójne z nazwą hosta aktywności. W poniższym fragmencie kodu użyto ProductListFragment, na przykład:

Kotlin

class ProductListFragment : Fragment() {
    // Leave empty for now.
}

Java

public class ProductListFragment extends Fragment {
    // Leave empty for now.
}

Przenieś logikę aktywności do fragmentu

Gdy masz już ustaloną definicję fragmentu, następnym krokiem jest przeniesienie logiki UI z tego ekranu do nowego fragmentu. Jeśli przechodzisz z architektura oparta na aktywności, masz sporą logikę tworzenia widoków w ramach funkcji onCreate() dotyczącej Twojej aktywności.

Oto przykładowy ekran aktywności z elementami interfejsu, które musimy przenieść:

Kotlin

class ProductListActivity : AppCompatActivity() {

    // Views and/or ViewDataBinding references, Adapters...
    private lateinit var productAdapter: ProductAdapter
    private lateinit var binding: ProductListActivityBinding

    ...

    // ViewModels, System Services, other Dependencies...
    private val viewModel: ProductListViewModel by viewModels()

    ...

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)

        // View initialization logic
        DataBindingUtil.setContentView(this, R.layout.product_list_activity)

        // Post view initialization logic
        // Connect adapters
        productAdapter = ProductAdapter(productClickCallback)
        binding.productsList.setAdapter(productAdapter)

        // Initialize view properties, set click listeners, etc.
        binding.productsSearchBtn.setOnClickListener {...}

        // Subscribe to state
        viewModel.products.observe(this, Observer { myProducts ->
            ...
        })

        // ...and so on
    }
   ...
}

Java

public class ProductListActivity extends AppCompatActivity {

    // Views and/or ViewDataBinding references, adapters...
    private ProductAdapter productAdapter;
    private ProductListActivityBinding binding;

    ...

    // ViewModels, system services, other dependencies...
    private ProductListViewModel viewModel;

    ...

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        // View initialization logic
        DataBindingUtil.setContentView(this, R.layout.product_list_activity);

        // Post view initialization logic
        // Connect adapters
        productAdapter = new ProductAdapter(productClickCallback);
        binding.productsList.setAdapter(productAdapter);

        // Initialize ViewModels and other dependencies
        ProductListViewModel viewModel = new ViewModelProvider(this).get(ProductListViewModel.java);

        // Initialize view properties, set click listeners, etc.
        binding.productsSearchBtn.setOnClickListener(v -> { ... });

        // Subscribe to state
        viewModel.getProducts().observe(this, myProducts ->
            ...
       );

       // ...and so on
   }

Aktywność może również wpływać na to, kiedy i w jaki sposób użytkownik przechodzi do strony na następnym ekranie, tak jak w przykładzie poniżej:

Kotlin

    // Provided to ProductAdapter in ProductListActivity snippet.
    private val productClickCallback = ProductClickCallback { product ->
        show(product)
    }

    fun show(product: Product) {
        val intent = Intent(this, ProductActivity::class.java)
        intent.putExtra(ProductActivity.KEY_PRODUCT_ID, product.id)
        startActivity(intent)
    }

Java

// Provided to ProductAdapter in ProductListActivity snippet.
private ProductClickCallback productClickCallback = this::show;

private void show(Product product) {
    Intent intent = new Intent(this, ProductActivity.class);
    intent.putExtra(ProductActivity.KEY_PRODUCT_ID, product.getId());
    startActivity(intent);
}

We fragmencie należy podzielić tę pracę między onCreateView() oraz onViewCreated(), a w aktywności pozostaje tylko nawigacja:

Kotlin

class ProductListFragment : Fragment() {

    private lateinit var binding: ProductListFragmentBinding
    private val viewModel: ProductListViewModel by viewModels()

     // View initialization logic
    override fun onCreateView(inflater: LayoutInflater,
            container: ViewGroup?,
            savedInstanceState: Bundle?): View? {
        binding = DataBindingUtil.inflate(
                inflater,
                R.layout.product_list,
                container,
                false
        )
        return binding.root
    }

    // Post view initialization logic
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        // Connect adapters
        productAdapter = ProductAdapter(productClickCallback)
        binding.productsList.setAdapter(productAdapter)

        // Initialize view properties, set click listeners, etc.
        binding.productsSearchBtn.setOnClickListener {...}

        // Subscribe to state
        viewModel.products.observe(this, Observer { myProducts ->
            ...
        })

        // ...and so on
    }

    // Provided to ProductAdapter
    private val productClickCallback = ProductClickCallback { product ->
        if (lifecycle.currentState.isAtLeast(Lifecycle.State.STARTED)) {
            (requireActivity() as ProductListActivity).show(product)
        }
    }
    ...
}

Java

public class ProductListFragment extends Fragment {

    private ProductAdapter productAdapter;
    private ProductListFragmentBinding binding;

    // View initialization logic
    @Nullable
    @Override
    public View onCreateView(@NonNull LayoutInflater inflater,
            @Nullable ViewGroup container,
            @Nullable Bundle savedInstanceState) {
        binding = DataBindingUtil.inflate(
                inflater,
                R.layout.product_list_fragment,
                container,
                false);
        return binding.getRoot();
    }

    // Post view initialization logic
    @Override
    public void onViewCreated(@NonNull View view,
            @Nullable Bundle savedInstanceState) {

        // Connect adapters
        binding.productsList.setAdapter(productAdapter);

        // Initialize ViewModels and other dependencies
        ProductListViewModel viewModel = new ViewModelProvider(this)
                .get(ProductListViewModel.class);

        // Initialize view properties, set click listeners, etc.
        binding.productsSearchBtn.setOnClickListener(...)

        // Subscribe to state
        viewModel.getProducts().observe(this, myProducts -> {
            ...
       });

       // ...and so on

    // Provided to ProductAdapter
    private ProductClickCallback productClickCallback = new ProductClickCallback() {
        @Override
        public void onClick(Product product) {
            if (getLifecycle().getCurrentState().isAtLeast(Lifecycle.State.STARTED)) {
                ((ProductListActivity) requireActivity()).show(product);
            }
        }
    };
    ...
}

Zwróć uwagę, że w aplikacji ProductListFragment nie ma wywołania setContentView(). aby rozszerzyć i połączyć układ. We fragmencie onCreateView() inicjuje metodę widoku głównym. onCreateView() pobiera instancję LayoutInflater, która może być używana do: zwiększyć widok główny na podstawie pliku zasobów układu. W tym przykładzie użyto ponownie istniejący układ product_list, który był używany przez aktywność, ponieważ nic musi zmienić się na sam układ.

Jeśli masz jakąś logikę interfejsu w funkcjach onStart(), onResume() dotyczących Twojej aktywności, funkcji onPause() lub onStop(), które nie są związane z nawigacją, możesz przenieść je do odpowiednich funkcji o tej samej nazwie we fragmencie.

Zainicjuj fragment w działaniu hosta

Po przeniesieniu całej logiki interfejsu do tego fragmentu można przechodzić tylko nie powinny mieć zastosowania żadne wartości logiczne.

Kotlin

class ProductListActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.product_list_host)
    }

    fun show(product: Product) {
        val intent = Intent(this, ProductActivity::class.java)
        intent.putExtra(ProductActivity.KEY_PRODUCT_ID, product.id)
        startActivity(intent)
    }
}

Java

public class ProductListActivity extends AppCompatActivity {

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

    public void show(Product product) {
        Intent intent = new Intent(this, ProductActivity.class);
        intent.putExtra(ProductActivity.KEY_PRODUCT_ID, product.getId());
        startActivity(intent);
    }
}

Ostatnim krokiem jest utworzenie wystąpienia fragmentu w elemencie onCreate(), po ustawieniu widoku treści:

Kotlin

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    setContentView(R.layout.product_list_host)

    if (savedInstanceState == null) {
        val fragment = ProductListFragment()
        supportFragmentManager
                .beginTransaction()
                .add(R.id.main_content, fragment)
                .commit()
    }
}

Java

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

    if (savedInstanceState == null) {
        ProductListFragment fragment = new ProductListFragment();
        getSupportFragmentManager()
                .beginTransaction()
                .add(R.id.main_content, fragment)
                .commit();
    }
}

Jak widać w tym przykładzie, FragmentManager automatycznie zapisuje i przywraca fragmentami w czasie zmian konfiguracji, więc wystarczy dodać fragment, jeśli savedInstanceState ma wartość null.

Przekazywanie dodatkowych intencji do fragmentu

Jeśli Twoja aktywność otrzymuje Extras poprzez intencję, możesz przekazać je usłudze fragment bezpośrednio jako argumenty.

W tym przykładzie ProductDetailsFragment otrzymuje swoje argumenty bezpośrednio z dodatkowych informacji o zamiarze działania:

Kotlin

...

if (savedInstanceState == null) {
    val fragment = ProductDetailsFragment()

    // Intent extras and Fragment Args are both of type android.os.Bundle.
    fragment.arguments = intent.extras

    supportFragmentManager
            .beginTransaction()
            .add(R.id.main_content, fragment)
            .commit()
}

...

Java

...

if (savedInstanceState == null) {
    ProductDetailsFragment fragment = new ProductDetailsFragment();

    // Intent extras and fragment Args are both of type android.os.Bundle.
    fragment.setArguments(getIntent().getExtras());

    getSupportFragmentManager()
            .beginTransaction()
            .add(R.id.main_content, fragment)
            .commit();
}

...

Teraz możesz już przetestować działanie aplikacji na pierwszym ekranie. zaktualizowany o fragment z fragmentem. Kontynuuj przenoszenie pozostałej części konta na podstawie aktywności. ekranów, a po każdej iteracji czas na testowanie.

Zintegruj komponent nawigacji

Po zastosowaniu architektury opartej na fragmentach możesz przystąpić do integracji komponentu Nawigacja.

Najpierw dodaj do projektu najnowsze zależności nawigacji po instrukcji w Informacje o wersji biblioteki nawigacji

Tworzenie wykresu nawigacyjnego

Komponent Nawigacja reprezentuje konfigurację nawigacji w aplikacji w w postaci wykresu, podobnie jak wyświetlenia aplikacji. To pomaga uporządkowanie nawigacji w aplikacji poza bazą kodu za pomocą której możesz wizualnie edytować nawigację po aplikacji.

Aby utworzyć wykres nawigacyjny, zacznij od utworzenia nowego folderu zasobów o nazwie navigation Aby dodać wykres, kliknij katalog prawym przyciskiem myszy i wybierz Nowe > Plik zasobów nawigacyjnych.

Komponent Nawigacja używa aktywności jako host do nawigacji i zamienia poszczególne fragmenty na tego hosta, gdy użytkownicy będą przeglądać witryny. do aplikacji. Zanim zaczniesz tworzyć wizualne układy nawigacji w aplikacji, Chcę skonfigurować element NavHost w aktywności, która będzie go hostować wykres. Ponieważ korzystamy z fragmentów, możemy użyć komponentu Nawigacja domyślna implementacja NavHost, NavHostFragment

Interfejs NavHostFragment jest konfigurowany za pomocą interfejsu FragmentContainerView umieszczone w aktywności hosta, jak w tym przykładzie:

<androidx.fragment.app.FragmentContainerView
   android:name="androidx.navigation.fragment.NavHostFragment"
   app:navGraph="@navigation/product_list_graph"
   app:defaultNavHost="true"
   android:id="@+id/main_content"
   android:layout_width="match_parent"
   android:layout_height="match_parent" />

Atrybut app:NavGraph wskazuje wykres nawigacyjny powiązany z tym elementem hosta nawigacji. Ustawienie tej właściwości powoduje rozwinięcie wykresu nawigacyjnego i ustawienie wykresu. usłudze w domenie NavHostFragment. Atrybut app:defaultNavHost zapewnia że NavHostFragment przechwytuje systemowy przycisk Wstecz.

Jeśli korzystasz z nawigacji najwyższego poziomu, np. DrawerLayout lub BottomNavigationView, to FragmentContainerView zastępuje główny element widoku treści. Zobacz Aktualizowanie komponentów interfejsu za pomocą NavigationUI .

W przypadku prostego układu możesz użyć tego elementu: FragmentContainerView element podrzędny elementu podrzędnego ViewGroup:

<FrameLayout
   xmlns:app="http://schemas.android.com/apk/res-auto"
   xmlns:android="http://schemas.android.com/apk/res/android"
   android:layout_height="match_parent"
   android:layout_width="match_parent">

<androidx.fragment.app.FragmentContainerView
   android:id="@+id/main_content"
   android:name="androidx.navigation.fragment.NavHostFragment"
   app:navGraph="@navigation/product_list_graph"
   app:defaultNavHost="true"
   android:layout_width="match_parent"
   android:layout_height="match_parent" />

</FrameLayout>

Jeśli klikniesz kartę Projekt na dole, zobaczysz wykres podobny do tego. do pokazanego poniżej. W lewym górnym rogu wykresu, w kolumnie Miejsca docelowe, możesz zobaczyć odwołanie do aktywności NavHost w formularzu z layout_name (resource_id).

Kliknij przycisk plusa w górnej części ekranu, aby dodać fragmenty do tego wykresu.

Komponent Nawigacja określa poszczególne ekrany jako miejsca docelowe. Miejscami docelowymi mogą być fragmenty, działania lub niestandardowe miejsca docelowe. Możesz dodać dowolny typ miejsca docelowego na wykresie. Pamiętaj jednak, że miejsca docelowe aktywności to są uznawane za miejsca docelowe terminala, ponieważ po przejściu do określonej aktywności miejsce docelowe, działasz na osobnym hoście nawigacji i wykresie.

Komponent Nawigacja odnosi się do sposobu, w jaki użytkownicy jako działania. Działanie może też opisywać przejście animacji i działań elementów wyskakujących.

Usuń transakcje związane z fragmentami

Używasz teraz komponentu Nawigacja i jeśli nawigujesz pomiędzy ekranami opartymi na fragmentach w ramach tej samej aktywności, możesz usunąć FragmentManager interakcje.

Jeśli aplikacja używa wielu fragmentów w ramach tej samej aktywności lub na najwyższym poziomie takich jak układ szuflady czy dolna nawigacja, za pomocą funkcji FragmentManager i FragmentTransactions. , aby dodać lub zastąpić fragmenty w sekcji z zawartością główną interfejsu użytkownika. Może teraz można zastąpić i uprościć za pomocą komponentu Nawigacja aby połączyć miejsca docelowe na wykresie, a następnie użyj NavController

Oto kilka scenariuszy, jakie możesz napotkać, wraz z możliwymi podejściami dla każdego scenariusza.

Pojedyncza aktywność zarządzająca wieloma fragmentami

Jeśli masz jedną aktywność, która zarządza wieloma fragmentami, aktywność kod może wyglądać tak:

Kotlin

class MainActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        // Logic to load the starting destination
        //  when the Activity is first created
        if (savedInstanceState == null) {
            val fragment = ProductListFragment()
            supportFragmentManager.beginTransaction()
                    .add(R.id.fragment_container, fragment, ProductListFragment.TAG)
                    .commit()
        }
    }

    // Logic to navigate the user to another destination.
    // This may include logic to initialize and set arguments on the destination
    // fragment or even transition animations between the fragments (not shown here).
    fun navigateToProductDetail(productId: String) {
        val fragment = new ProductDetailsFragment()
        val args = Bundle().apply {
            putInt(KEY_PRODUCT_ID, productId)
        }
        fragment.arguments = args

        supportFragmentManager.beginTransaction()
                .addToBackStack(ProductDetailsFragment.TAG)
                .replace(R.id.fragment_container, fragment, ProductDetailsFragment.TAG)
                .commit()
    }
}

Java

public class MainActivity extends AppCompatActivity {

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

        // Logic to load the starting destination when the activity is first created.
        if (savedInstanceState == null) {
            val fragment = ProductListFragment()
            supportFragmentManager.beginTransaction()
                    .add(R.id.fragment_container, fragment, ProductListFragment.TAG)
                    .commit();
        }
    }

    // Logic to navigate the user to another destination.
    // This may include logic to initialize and set arguments on the destination
    // fragment or even transition animations between the fragments (not shown here).
    public void navigateToProductDetail(String productId) {
        Fragment fragment = new ProductDetailsFragment();
        Bundle args = new Bundle();
        args.putInt(KEY_PRODUCT_ID, productId);
        fragment.setArguments(args);

        getSupportFragmentManager().beginTransaction()
                .addToBackStack(ProductDetailsFragment.TAG)
                .replace(R.id.fragment_container, fragment, ProductDetailsFragment.TAG)
                .commit();
    }
}

W źródłowym miejscu docelowym możesz wywoływać funkcję nawigacyjną odpowiedź na wybrane zdarzenie, na przykład:

Kotlin

class ProductListFragment : Fragment() {
    ...
    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        // In this example a callback is passed to respond to an item clicked
        //  in a RecyclerView
        productAdapter = ProductAdapter(productClickCallback)
        binding.productsList.setAdapter(productAdapter)
    }
    ...

    // The callback makes the call to the activity to make the transition.
    private val productClickCallback = ProductClickCallback { product ->
            (requireActivity() as MainActivity).navigateToProductDetail(product.id)
    }
}

Java

public class ProductListFragment extends Fragment  {
    ...
    @Override
    public void onViewCreated(@NonNull View view,
            @Nullable Bundle savedInstanceState) {
    // In this example a callback is passed to respond to an item clicked in a RecyclerView
        productAdapter = new ProductAdapter(productClickCallback);
        binding.productsList.setAdapter(productAdapter);
    }
    ...

    // The callback makes the call to the activity to make the transition.
    private ProductClickCallback productClickCallback = product -> (
        ((MainActivity) requireActivity()).navigateToProductDetail(product.getId())
    );
}

Można to zastąpić, aktualizując wykres nawigacji tak, aby zawierał początkowe miejsce docelowe i działania, które łączą miejsca docelowe i określają, – gdy są wymagane – argumenty:

<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/product_list_graph"
    app:startDestination="@id/product_list">

    <fragment
        android:id="@+id/product_list"
        android:name="com.example.android.persistence.ui.ProductListFragment"
        android:label="Product List"
        tools:layout="@layout/product_list">
        <action
            android:id="@+id/navigate_to_product_detail"
            app:destination="@id/product_detail" />
    </fragment>
    <fragment
        android:id="@+id/product_detail"
        android:name="com.example.android.persistence.ui.ProductDetailFragment"
        android:label="Product Detail"
        tools:layout="@layout/product_detail">
        <argument
            android:name="product_id"
            app:argType="integer" />
    </fragment>
</navigation>

Następnie możesz zaktualizować swoją aktywność:

Kotlin

class MainActivity : AppCompatActivity() {

    // No need to load the start destination, handled automatically by the Navigation component
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
    }
}

Java

public class MainActivity extends AppCompatActivity {

    // No need to load the start destination, handled automatically by the Navigation component
    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);
    }
}

Aktywność nie wymaga już metody navigateToProductDetail(). W ciągu następnych aktualizujemy ProductListFragment tak, by używał NavController do nawigacji przejdź do kolejnego ekranu ze szczegółami produktu.

Bezpiecznie przekazuj argumenty

Komponent Nawigacja ma wtyczkę do Gradle o nazwie Bezpieczne argumenty który generuje proste klasy obiektów i konstruktora zapewniające dostęp argumentów miejsc docelowych i czynności.

Po zastosowaniu wtyczki wszystkie argumenty zdefiniowane w miejscu docelowym w powoduje, że platforma komponentu Nawigacja generuje Klasa Arguments, która udostępnia bezpieczne argumenty typu w miejscu docelowym. Zdefiniowanie działania powoduje wygenerowanie przez wtyczkę konfiguracji Directions klasa, która może pomóc w poinformowaniu NavController o tym, jak dotrzeć do użytkownika miejsce docelowe. Gdy działanie wskazuje miejsce docelowe, które wymaga argumentów, generowana klasa Directions zawiera metody konstruktora, które tych parametrów.

We fragmencie użyj kodu NavController i wygenerowanej klasy Directions, aby należy podać argumenty bezpieczne do typu w miejscu docelowym, jak w poniższym przykładzie przykład:

Kotlin

class ProductListFragment : Fragment() {

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        // In this example a callback is passed to respond to an item clicked in a RecyclerView
        productAdapter = ProductAdapter(productClickCallback)
        binding.productsList.setAdapter(productAdapter)
    }
    ...

    // The callback makes the call to the NavController to make the transition.
    private val productClickCallback = ProductClickCallback { product ->
        val directions = ProductListDirections.navigateToProductDetail(product.id)
        findNavController().navigate(directions)
    }
}

Java

public class ProductListFragment extends Fragment  {
    ...
    @Override
    public void onViewCreated(@NonNull View view,
            @Nullable Bundle savedInstanceState) {
        // In this example a callback is passed to respond to an item clicked in a RecyclerView
        productAdapter = new ProductAdapter(productClickCallback);
        binding.productsList.setAdapter(productAdapter);
    }
    ...

    // The callback makes the call to the activity to make the transition.
    private ProductClickCallback productClickCallback = product -> {
        ProductListDirections.ViewProductDetails directions =
                ProductListDirections.navigateToProductDetail(product.getId());
        NavHostFragment.findNavController(this).navigate(directions);
    };
}

Nawigacja najwyższego poziomu

Jeśli Twoja aplikacja używa interfejsu DrawerLayout, konfiguracja może być obszerna które polega na otwarciu i zamknięciu panelu oraz przejściu do innych miejscach docelowych.

Wynikowa aktywność może wyglądać np. tak:

Kotlin

class MainActivity : AppCompatActivity(),
    NavigationView.OnNavigationItemSelectedListener {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val toolbar: Toolbar = findViewById(R.id.toolbar)
        setSupportActionBar(toolbar)

        val drawerLayout: DrawerLayout = findViewById(R.id.drawer_layout)
        val navView: NavigationView = findViewById(R.id.nav_view)
        val toggle = ActionBarDrawerToggle(
                this,
                drawerLayout,
                toolbar,
                R.string.navigation_drawer_open, 
                R.string.navigation_drawer_close
        )
        drawerLayout.addDrawerListener(toggle)
        toggle.syncState()

        navView.setNavigationItemSelectedListener(this)
    }

    override fun onBackPressed() {
        val drawerLayout: DrawerLayout = findViewById(R.id.drawer_layout)
        if (drawerLayout.isDrawerOpen(GravityCompat.START)) {
            drawerLayout.closeDrawer(GravityCompat.START)
        } else {
            super.onBackPressed()
        }
    }

    override fun onNavigationItemSelected(item: MenuItem): Boolean {
        // Handle navigation view item clicks here.
        when (item.itemId) {
            R.id.home -> {
                val homeFragment = HomeFragment()
                show(homeFragment)
            }
            R.id.gallery -> {
                val galleryFragment = GalleryFragment()
                show(galleryFragment)
            }
            R.id.slide_show -> {
                val slideShowFragment = SlideShowFragment()
                show(slideShowFragment)
            }
            R.id.tools -> {
                val toolsFragment = ToolsFragment()
                show(toolsFragment)
            }
        }
        val drawerLayout: DrawerLayout = findViewById(R.id.drawer_layout)
        drawerLayout.closeDrawer(GravityCompat.START)
        return true
    }
}

private fun show(fragment: Fragment) {

    val drawerLayout = drawer_layout as DrawerLayout
    val fragmentManager = supportFragmentManager

    fragmentManager
            .beginTransaction()
            .replace(R.id.main_content, fragment)
            .commit()

    drawerLayout.closeDrawer(GravityCompat.START)
}

Java

public class MainActivity extends AppCompatActivity
        implements NavigationView.OnNavigationItemSelectedListener {

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

        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        DrawerLayout drawer = findViewById(R.id.drawer_layout);
        NavigationView navigationView = findViewById(R.id.nav_view);
        ActionBarDrawerToggle toggle = new ActionBarDrawerToggle(
                this,
                drawer,
                toolbar,
                R.string.navigation_drawer_open,
                R.string.navigation_drawer_close);
        drawer.addDrawerListener(toggle);
        toggle.syncState();

        navigationView.setNavigationItemSelectedListener(this);
    }

    @Override
    public void onBackPressed() {
        DrawerLayout drawer = findViewById(R.id.drawer_layout);
        if (drawer.isDrawerOpen(GravityCompat.START)) {
            drawer.closeDrawer(GravityCompat.START);
        } else {
            super.onBackPressed();
        }
    }

    @Override
    public boolean onNavigationItemSelected(MenuItem item) {
        // Handle navigation view item clicks here.
        int id = item.getItemId();

        if (id == R.id.home) {
            Fragment homeFragment = new HomeFragment();
            show(homeFragment);
        } else if (id == R.id.gallery) {
            Fragment galleryFragment = new GalleryFragment();
            show(galleryFragment);
        } else if (id == R.id.slide_show) {
            Fragment slideShowFragment = new SlideShowFragment();
            show(slideShowFragment);
        } else if (id == R.id.tools) {
            Fragment toolsFragment = new ToolsFragment();
            show(toolsFragment);
        }

        DrawerLayout drawer = findViewById(R.id.drawer_layout);
        drawer.closeDrawer(GravityCompat.START);
        return true;
    }

    private void show(Fragment fragment) {

        DrawerLayout drawerLayout = findViewById(R.id.drawer_layout);
        FragmentManager fragmentManager = getSupportFragmentManager();

        fragmentManager
                .beginTransaction()
                .replace(R.id.main_content, fragment)
                .commit();

        drawerLayout.closeDrawer(GravityCompat.START);
    }
}

Po dodaniu komponentu Nawigacja do projektu i utworzeniu dodaj do niego wszystkie miejsca docelowe treści (np. Strona główna, Galeria, Pokaz slajdów i Narzędzia z powyższego przykładu). Upewnij się, aby wartości id pozycji w menu były zgodne z powiązanymi wartościami parametru id miejsca docelowego, jak poniżej:

<!-- activity_main_drawer.xml -->
<menu xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:tools="http://schemas.android.com/tools"
    tools:showIn="navigation_view">

    <group android:checkableBehavior="single">
        <item
            android:id="@+id/home"
            android:icon="@drawable/ic_menu_camera"
            android:title="@string/menu_home" />
        <item
            android:id="@+id/gallery"
            android:icon="@drawable/ic_menu_gallery"
            android:title="@string/menu_gallery" />
        <item
            android:id="@+id/slide_show"
            android:icon="@drawable/ic_menu_slideshow"
            android:title="@string/menu_slideshow" />
        <item
            android:id="@+id/tools"
            android:icon="@drawable/ic_menu_manage"
            android:title="@string/menu_tools" />
    </group>
</menu>

<!-- activity_main_graph.xml -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/main_graph"
    app:startDestination="@id/home">

    <fragment
        android:id="@+id/home"
        android:name="com.example.HomeFragment"
        android:label="Home"
        tools:layout="@layout/home" />

    <fragment
        android:id="@+id/gallery"
        android:name="com.example.GalleryFragment"
        android:label="Gallery"
        tools:layout="@layout/gallery" />

    <fragment
        android:id="@+id/slide_show"
        android:name="com.example.SlideShowFragment"
        android:label="Slide Show"
        tools:layout="@layout/slide_show" />

    <fragment
        android:id="@+id/tools"
        android:name="com.example.ToolsFragment"
        android:label="Tools"
        tools:layout="@layout/tools" />

</navigation>

Jeśli pasują do wartości id w menu i na wykresie, możesz połączyć NavController dla tej aktywności, aby automatycznie obsługiwać nawigację na podstawie tę pozycję w menu. NavController obsługuje również otwieranie i zamykanie DrawerLayout oraz prawidłowe działanie przycisków Wstecz i Wstecz.

Możesz zaktualizować urządzenie MainActivity, by podłączyć NavController do Toolbar i NavigationView.

Oto przykład:

Kotlin

class MainActivity : AppCompatActivity()  {

    val drawerLayout by lazy { findViewById<DrawerLayout>(R.id.drawer_layout) }
    val navController by lazy {
      (supportFragmentManager.findFragmentById(R.id.main_content) as NavHostFragment).navController
    }
    val navigationView by lazy { findViewById<NavigationView>(R.id.nav_view) }

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)

        val toolbar = findViewById<Toolbar>(R.id.toolbar)
        setSupportActionBar(toolbar)

        // Show and Manage the Drawer and Back Icon
        setupActionBarWithNavController(navController, drawerLayout)

        // Handle Navigation item clicks
        // This works with no further action on your part if the menu and destination id’s match.
        navigationView.setupWithNavController(navController)

    }

    override fun onSupportNavigateUp(): Boolean {
        // Allows NavigationUI to support proper up navigation or the drawer layout
        // drawer menu, depending on the situation
        return navController.navigateUp(drawerLayout)
    }
}

Java

public class MainActivity extends AppCompatActivity {

    private DrawerLayout drawerLayout;
    private NavController navController;
    private NavigationView navigationView;

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);
        setContentView(R.layout.activity_main);

        drawerLayout = findViewById(R.id.drawer_layout);
        NavHostFragment navHostFragment = (NavHostFragment)
            getSupportFragmentManager().findFragmentById(R.id.main_content);
        navController = navHostFragment.getNavController();
        navigationView = findViewById(R.id.nav_view);

        Toolbar toolbar = findViewById(R.id.toolbar);
        setSupportActionBar(toolbar);

        // Show and Manage the Drawer and Back Icon
        NavigationUI.setupActionBarWithNavController(this, navController, drawerLayout);

        // Handle Navigation item clicks
        // This works with no further action on your part if the menu and destination id’s match.
        NavigationUI.setupWithNavController(navigationView, navController);

    }

    @Override
    public boolean onSupportNavigateUp() {
        // Allows NavigationUI to support proper up navigation or the drawer layout
        // drawer menu, depending on the situation.
        return NavigationUI.navigateUp(navController, drawerLayout);

    }
}

Tej samej techniki możesz używać zarówno w przypadku nawigacji opartej na bottomNavigationView, i nawigację w menu. Zobacz Aktualizowanie komponentów interfejsu za pomocą NavigationUI .

Dodaj miejsca docelowe aktywności

po podłączeniu każdego ekranu aplikacji do komponentu Nawigacja. nie używasz już aplikacji FragmentTransactions do przełączania się między miejsca docelowe oparte na fragmentach, następnym krokiem jest wyeliminowanie startActivity połączeń.

Najpierw znajdź miejsca w aplikacji, w których masz 2 osobne wykresy nawigacyjne i używają usługi startActivity do przechodzenia między nimi.

Ten przykład zawiera dwa wykresy (A i B) oraz wywołanie startActivity() funkcji przejście z punktu A do B.

Kotlin

fun navigateToProductDetails(productId: String) {
    val intent = Intent(this, ProductDetailsActivity::class.java)
    intent.putExtra(KEY_PRODUCT_ID, productId)
    startActivity(intent)
}

Java

private void navigateToProductDetails(String productId) {
    Intent intent = new Intent(this, ProductDetailsActivity.class);
    intent.putExtra(KEY_PRODUCT_ID, productId);
    startActivity(intent);

Następnie zastąp je na wykresie A miejscem docelowym aktywności, które odpowiada przejście do aktywności hosta na wykresie B. Jeśli masz argumenty przekazywane do funkcji początkowym punktem wykresu B, możesz wyznaczyć je w miejscu docelowym aktywności definicji.

W poniższym przykładzie graf A definiuje miejsce docelowe aktywności, które pobiera product_id argument wraz z działaniem. Wykres B nie zawiera żadnych zmian.

Reprezentacja grafów A i B w formacie XML może wyglądać tak:

<!-- Graph A -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/product_list_graph"
    app:startDestination="@id/product_list">

    <fragment
        android:id="@+id/product_list"
        android:name="com.example.android.persistence.ui.ProductListFragment"
        android:label="Product List"
        tools:layout="@layout/product_list_fragment">
        <action
            android:id="@+id/navigate_to_product_detail"
            app:destination="@id/product_details_activity" />
    </fragment>

    <activity
        android:id="@+id/product_details_activity"
        android:name="com.example.android.persistence.ui.ProductDetailsActivity"
        android:label="Product Details"
        tools:layout="@layout/product_details_host">

        <argument
            android:name="product_id"
            app:argType="integer" />

    </activity>

</navigation>

<!-- Graph B -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    app:startDestination="@id/product_details">

    <fragment
        android:id="@+id/product_details"
        android:name="com.example.android.persistence.ui.ProductDetailsFragment"
        android:label="Product Details"
        tools:layout="@layout/product_details_fragment">
        <argument
            android:name="product_id"
            app:argType="integer" />
    </fragment>

</navigation>

Możesz przejść do aktywności hosta z grafu B za pomocą tych samych mechanizmów służy do przechodzenia do miejsc docelowych fragmentów:

Kotlin

fun navigateToProductDetails(productId: String) {
    val directions = ProductListDirections.navigateToProductDetail(productId)
    findNavController().navigate(directions)
}

Java

private void navigateToProductDetails(String productId) {
    ProductListDirections.NavigateToProductDetail directions =
            ProductListDirections.navigateToProductDetail(productId);
    Navigation.findNavController(getView()).navigate(directions);

Przekaż argumenty miejsca docelowego aktywności do początkowego fragmentu docelowego

Jeśli działanie w miejscu docelowym otrzymuje dodatki, tak jak w poprzednim przykładzie, możesz przekazać je do miejsca docelowego bezpośrednio jako argumenty, ale trzeba ręcznie ustawić wykres nawigacji gospodarza w sekcji onCreate(), dzięki czemu możesz przekazywać dodatkowe intencji jako argumenty do funkcji Jak widać poniżej:

Kotlin

class ProductDetailsActivity : AppCompatActivity() {

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.product_details_host)
        val navHostFragment = supportFragmentManager.findFragmentById(R.id.main_content) as NavHostFragment
        val navController = navHostFramgent.navController
        navController
                .setGraph(R.navigation.product_detail_graph, intent.extras)
    }

}

Java

public class ProductDetailsActivity extends AppCompatActivity {

    @Override
    protected void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        setContentView(R.layout.product_details_host);
        NavHostFragment navHostFragment = (NavHostFragment)
            getSupportFragmentManager().findFragmentById(R.id.main_content);
        NavController navController = navHostFragment.getNavController();
        navController
                .setGraph(R.navigation.product_detail_graph, getIntent().getExtras());
    }

}

Dane można wyodrębnić z argumentów fragmentu Bundle za pomocą generowana klasa argumentów, jak w tym przykładzie:

Kotlin

class ProductDetailsFragment : Fragment() {

    val args by navArgs<ProductDetailsArgs>()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        val productId = args.productId
        ...
    }
    ...

Java

public class ProductDetailsFragment extends Fragment {

    ProductDetailsArgs args;

    @Override
    public void onCreate(@Nullable Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        args = ProductDetailsArgs.fromBundle(requireArguments());
    }

    @Override
    public void onViewCreated(@NonNull View view,
            @Nullable Bundle savedInstanceState) {
       int productId = args.getProductId();
       ...
    }
    ...

Łączenie aktywności

Wykresy nawigacyjne można łączyć w przypadku, gdy wiele aktywności ma taki sam ten sam układ, na przykład prosty element FrameLayout zawierający pojedynczy fragment. W W większości przypadków wystarczy połączyć wszystkie elementy wykresu nawigacji i aktualizowanie elementów docelowych aktywności, aby dzielić je na fragmenty miejsca docelowe.

Ten przykład łączy wykresy A i B z poprzedniej sekcji:

Przed połączeniem:

<!-- Graph A -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/product_list_graph"
    app:startDestination="@id/product_list">

    <fragment
        android:id="@+id/product_list"
        android:name="com.example.android.persistence.ui.ProductListFragment"
        android:label="Product List Fragment"
        tools:layout="@layout/product_list">
        <action
            android:id="@+id/navigate_to_product_detail"
            app:destination="@id/product_details_activity" />
    </fragment>
    <activity
        android:id="@+id/product_details_activity"
        android:name="com.example.android.persistence.ui.ProductDetailsActivity"
        android:label="Product Details Host"
        tools:layout="@layout/product_details_host">
        <argument android:name="product_id"
            app:argType="integer" />
    </activity>

</navigation>

<!-- Graph B -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/product_detail_graph"
    app:startDestination="@id/product_details">

    <fragment
        android:id="@+id/product_details"
        android:name="com.example.android.persistence.ui.ProductDetailsFragment"
        android:label="Product Details"
        tools:layout="@layout/product_details">
        <argument
            android:name="product_id"
            app:argType="integer" />
    </fragment>
</navigation>

Po połączeniu:

<!-- Combined Graph A and B -->
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/product_list_graph"
    app:startDestination="@id/product_list">

    <fragment
        android:id="@+id/product_list"
        android:name="com.example.android.persistence.ui.ProductListFragment"
        android:label="Product List Fragment"
        tools:layout="@layout/product_list">
        <action
            android:id="@+id/navigate_to_product_detail"
            app:destination="@id/product_details" />
    </fragment>

    <fragment
        android:id="@+id/product_details"
        android:name="com.example.android.persistence.ui.ProductDetailsFragment"
        android:label="Product Details"
        tools:layout="@layout/product_details">
        <argument
            android:name="product_id"
            app:argType="integer" />
    </fragment>

</navigation>

Użycie takich samych nazw działań podczas scalania może sprawić, że proces ten będzie przebiegał płynnie nie wymagając przy tym żadnych zmian w Twojej bazie kodu. Przykład: navigateToProductDetail pozostaje tutaj bez zmian. Jedyna różnica jest taka, to działanie reprezentuje teraz nawigację do miejsca docelowego fragmentu w obrębie tego samego NavHost zamiast miejsca docelowego aktywności:

Kotlin

fun navigateToProductDetails(productId: String) {
    val directions = ProductListDirections.navigateToProductDetail(productId)
    findNavController().navigate(directions)
}

Java

private void navigateToProductDetails(String productId) {
    ProductListDirections.NavigateToProductDetail directions =
            ProductListDirections.navigateToProductDetail(productId);
    Navigation.findNavController(getView()).navigate(directions);

Dodatkowe materiały

Więcej informacji związanych z nawigacją znajdziesz w tych tematach:

Aktualizowanie komponentów interfejsu za pomocą interfejsu NavigationUI – Dowiedz się, jak zarządzać nawigacją za pomocą górnego paska aplikacji, panelu nawigacji i dolna nawigacja
Nawigacja testowa - Dowiedz się, jak przetestować nawigację w aplikacji