Nawigacja warunkowa

Podczas projektowania nawigacji w aplikacji możesz chcieć przechodzić do jednego miejsca docelowego zamiast innego na podstawie logiki warunkowej. Na przykład użytkownik może kliknąć precyzyjny link do miejsca docelowego, które wymaga zalogowania się, lub możesz mieć różne miejsca docelowe w grze, gdy gracz wygra lub przegra.

Logowanie użytkownika

W tym przykładzie użytkownik próbuje przejść do ekranu profilu, który wymaga uwierzytelnienia. To działanie wymaga uwierzytelnienia, więc użytkownik powinien zostać przekierowany do ekranu logowania, jeśli nie został jeszcze uwierzytelniony.

Wykres nawigacji w tym przykładzie może wyglądać tak:

proces logowania jest obsługiwany niezależnie od głównego procesu nawigacji w aplikacji.
Rysunek 1. Proces logowania jest obsługiwany niezależnie od głównego procesu nawigacji w aplikacji.

Aby przeprowadzić uwierzytelnianie, aplikacja musi przejść do login_fragment, gdzie użytkownik może wpisać nazwę użytkownika i hasło. Jeśli zostanie zaakceptowana, użytkownik zostanie przekierowany z powrotem na ekran profile_fragment. Jeśli nie, użytkownik zostanie poinformowany, że jego dane logowania są nieprawidłowe, za pomocą komunikatu Snackbar. Jeśli użytkownik wróci do ekranu profilu bez logowania się, zostanie przekierowany na ekran main_fragment.

Oto wykres nawigacji dla tej aplikacji:

<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/nav_graph"
        app:startDestination="@id/main_fragment">
    <fragment
            android:id="@+id/main_fragment"
            android:name="com.google.android.conditionalnav.MainFragment"
            android:label="fragment_main"
            tools:layout="@layout/fragment_main">
        <action
                android:id="@+id/navigate_to_profile_fragment"
                app:destination="@id/profile_fragment"/>
    </fragment>
    <fragment
            android:id="@+id/login_fragment"
            android:name="com.google.android.conditionalnav.LoginFragment"
            android:label="login_fragment"
            tools:layout="@layout/login_fragment"/>
    <fragment
            android:id="@+id/profile_fragment"
            android:name="com.google.android.conditionalnav.ProfileFragment"
            android:label="fragment_profile"
            tools:layout="@layout/fragment_profile"/>
</navigation>

MainFragment zawiera przycisk, który użytkownik może kliknąć, aby wyświetlić swój profil. Jeśli użytkownik chce zobaczyć ekran profilu, musi najpierw przejść uwierzytelnianie. Ta interakcja jest modelowana za pomocą 2 osobnych fragmentów, ale zależy od wspólnego stanu użytkownika. Te informacje o stanie nie są odpowiedzialnością żadnego z tych 2 fragmentów i lepiej przechowywać je we wspólnym obiekcie UserViewModel. Ten obiekt ViewModel jest udostępniany między fragmentami przez ograniczenie jego zakresu do aktywności, która implementuje interfejs ViewModelStoreOwner. W tym przykładzie requireActivity() jest przekształcane na MainActivity, ponieważ MainActivity hostuje ProfileFragment:

Kotlin

class ProfileFragment : Fragment() {
    private val userViewModel: UserViewModel by activityViewModels()
    ...
}

Java

public class ProfileFragment extends Fragment {
    private UserViewModel userViewModel;
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        userViewModel = new ViewModelProvider(requireActivity()).get(UserViewModel.class);
        ...
    }
    ...
}

Dane użytkownika w UserViewModel są udostępniane za pomocą LiveData, więc aby zdecydować, gdzie przejść, musisz je obserwować. Po przejściu na stronę ProfileFragment aplikacja wyświetla wiadomość powitalną, jeśli dane użytkownika są dostępne. Jeśli dane użytkownika to null, przechodzisz do LoginFragment, ponieważ użytkownik musi się uwierzytelnić, zanim zobaczy swój profil. Zdefiniuj logikę decyzyjną w pliku ProfileFragment, jak w tym przykładzie:

Kotlin

class ProfileFragment : Fragment() {
    private val userViewModel: UserViewModel by activityViewModels()

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        val navController = findNavController()
        userViewModel.user.observe(viewLifecycleOwner, Observer { user ->
            if (user != null) {
                showWelcomeMessage()
            } else {
                navController.navigate(R.id.login_fragment)
            }
        })
    }

    private fun showWelcomeMessage() {
        ...
    }
}

Java

public class ProfileFragment extends Fragment {
    private UserViewModel userViewModel;

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        userViewModel = new ViewModelProvider(requireActivity()).get(UserViewModel.class);
        final NavController navController = Navigation.findNavController(view);
        userViewModel.user.observe(getViewLifecycleOwner(), (Observer<User>) user -> {
            if (user != null) {
                showWelcomeMessage();
            } else {
                navController.navigate(R.id.login_fragment);
            }
        });
    }

    private void showWelcomeMessage() {
        ...
    }
}

Jeśli dane użytkownika są null, gdy dotrze on do ProfileFragment, zostanie przekierowany do LoginFragment.

Możesz użyć NavController.getPreviousBackStackEntry, aby pobrać NavBackStackEntry dla poprzedniego miejsca docelowego, które zawiera stan miejsca docelowego właściwy dla NavController. LoginFragment używa SavedStateHandle poprzedniego NavBackStackEntry, aby ustawić wartość początkową wskazującą, czy użytkownik zalogował się pomyślnie. To jest stan, który chcesz zwrócić, jeśli użytkownik natychmiast naciśnie przycisk Wstecz. Ustawienie tego stanu za pomocą SavedStateHandle zapewnia, że stan będzie utrzymywany po śmierci procesu.

Kotlin

class LoginFragment : Fragment() {
    companion object {
        const val LOGIN_SUCCESSFUL: String = "LOGIN_SUCCESSFUL"
    }

    private val userViewModel: UserViewModel by activityViewModels()
    private lateinit var savedStateHandle: SavedStateHandle

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        savedStateHandle = findNavController().previousBackStackEntry!!.savedStateHandle
        savedStateHandle.set(LOGIN_SUCCESSFUL, false)
    }
}

Java

public class LoginFragment extends Fragment {
    public static String LOGIN_SUCCESSFUL = "LOGIN_SUCCESSFUL"

    private UserViewModel userViewModel;
    private SavedStateHandle savedStateHandle;

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        userViewModel = new ViewModelProvider(requireActivity()).get(UserViewModel.class);

        savedStateHandle = Navigation.findNavController(view)
                .getPreviousBackStackEntry()
                .getSavedStateHandle();
        savedStateHandle.set(LOGIN_SUCCESSFUL, false);
    }
}

Gdy użytkownik wpisze nazwę użytkownika i hasło, zostaną one przekazane do UserViewModel w celu uwierzytelnienia. Jeśli uwierzytelnianie się powiedzie, UserViewModel zapisze dane użytkownika. LoginFragment aktualizuje wartość LOGIN_SUCCESSFUL w SavedStateHandle i usuwa się ze stosu wstecznego.

Kotlin

class LoginFragment : Fragment() {
    companion object {
        const val LOGIN_SUCCESSFUL: String = "LOGIN_SUCCESSFUL"
    }

    private val userViewModel: UserViewModel by activityViewModels()
    private lateinit var savedStateHandle: SavedStateHandle

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        savedStateHandle = findNavController().previousBackStackEntry!!.savedStateHandle
        savedStateHandle.set(LOGIN_SUCCESSFUL, false)

        val usernameEditText = view.findViewById(R.id.username_edit_text)
        val passwordEditText = view.findViewById(R.id.password_edit_text)
        val loginButton = view.findViewById(R.id.login_button)

        loginButton.setOnClickListener {
            val username = usernameEditText.text.toString()
            val password = passwordEditText.text.toString()
            login(username, password)
        }
    }

    fun login(username: String, password: String) {
        userViewModel.login(username, password).observe(viewLifecycleOwner, Observer { result ->
            if (result.success) {
                savedStateHandle.set(LOGIN_SUCCESSFUL, true)
                findNavController().popBackStack()
            } else {
                showErrorMessage()
            }
        })
    }

    fun showErrorMessage() {
        // Display a snackbar error message
    }
}

Java

public class LoginFragment extends Fragment {
    public static String LOGIN_SUCCESSFUL = "LOGIN_SUCCESSFUL"

    private UserViewModel userViewModel;
    private SavedStateHandle savedStateHandle;

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        userViewModel = new ViewModelProvider(requireActivity()).get(UserViewModel.class);

        savedStateHandle = Navigation.findNavController(view)
                .getPreviousBackStackEntry()
                .getSavedStateHandle();
        savedStateHandle.set(LOGIN_SUCCESSFUL, false);

        EditText usernameEditText = view.findViewById(R.id.username_edit_text);
        EditText passwordEditText = view.findViewById(R.id.password_edit_text);
        Button loginButton = view.findViewById(R.id.login_button);

        loginButton.setOnClickListener(v -> {
            String username = usernameEditText.getText().toString();
            String password = passwordEditText.getText().toString();
            login(username, password);
        });
    }

    private void login(String username, String password) {
        userViewModel.login(username, password).observe(viewLifecycleOwner, (Observer<LoginResult>) result -> {
            if (result.success) {
                savedStateHandle.set(LOGIN_SUCCESSFUL, true);
                NavHostFragment.findNavController(this).popBackStack();
            } else {
                showErrorMessage();
            }
        });
    }

    private void showErrorMessage() {
        // Display a snackbar error message
    }
}

Pamiętaj, że cała logika związana z uwierzytelnianiem znajduje się w pliku UserViewModel. To ważne, ponieważ ani LoginFragment, ani ProfileFragment nie odpowiadają za określanie sposobu uwierzytelniania użytkowników. Hermetyzacja logiki w ViewModel nie tylko ułatwia jej udostępnianie, ale też testowanie. Jeśli logika nawigacji jest złożona, należy ją dokładnie przetestować. Więcej informacji o tworzeniu architektury aplikacji wokół komponentów, które można testować, znajdziesz w Przewodniku po architekturze aplikacji.

Wróć do ProfileFragment. Wartość LOGIN_SUCCESSFUL przechowywaną w SavedStateHandle można zaobserwować w metodzie onCreate(). Gdy użytkownik wróci do ProfileFragment, wartość LOGIN_SUCCESSFUL zostanie sprawdzona. Jeśli wartość to false, użytkownik może zostać przekierowany z powrotem do MainFragment.

Kotlin

class ProfileFragment : Fragment() {
    ...

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

        val navController = findNavController()

        val currentBackStackEntry = navController.currentBackStackEntry!!
        val savedStateHandle = currentBackStackEntry.savedStateHandle
        savedStateHandle.getLiveData<Boolean>(LoginFragment.LOGIN_SUCCESSFUL)
                .observe(currentBackStackEntry, Observer { success ->
                    if (!success) {
                        val startDestination = navController.graph.startDestination
                        val navOptions = NavOptions.Builder()
                                .setPopUpTo(startDestination, true)
                                .build()
                        navController.navigate(startDestination, null, navOptions)
                    }
                })
    }

    ...
}

Java

public class ProfileFragment extends Fragment {
    ...

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

        NavController navController = NavHostFragment.findNavController(this);

        NavBackStackEntry navBackStackEntry = navController.getCurrentBackStackEntry();
        SavedStateHandle savedStateHandle = navBackStackEntry.getSavedStateHandle();
        savedStateHandle.getLiveData(LoginFragment.LOGIN_SUCCESSFUL)
                .observe(navBackStackEntry, (Observer<Boolean>) success -> {
                    if (!success) {
                        int startDestination = navController.getGraph().getStartDestination();
                        NavOptions navOptions = new NavOptions.Builder()
                                .setPopUpTo(startDestination, true)
                                .build();
                        navController.navigate(startDestination, null, navOptions);
                    }
                });
    }

    ...
}

Jeśli użytkownik zalogował się pomyślnie, ProfileFragment wyświetli komunikat powitalny.

Zastosowana tu technika sprawdzania wyniku pozwala rozróżnić 2 przypadki:

  • Przypadek początkowy, gdy użytkownik nie jest zalogowany i powinien zostać poproszony o zalogowanie się.
  • Użytkownik nie jest zalogowany, ponieważ nie zdecydował się na zalogowanie (wynik false).

Dzięki rozróżnieniu tych przypadków użycia możesz uniknąć wielokrotnego proszenia użytkownika o zalogowanie się. Logika biznesowa obsługi przypadków niepowodzenia zależy od Ciebie i może obejmować wyświetlanie nakładki wyjaśniającej, dlaczego użytkownik musi się zalogować, zakończenie całej aktywności lub przekierowanie użytkownika do miejsca docelowego, które nie wymaga logowania, jak w poprzednim przykładzie kodu.