ניווט מותנה

כשאתם מתכננים את הניווט באפליקציה, יכול להיות שתרצו לנווט ליעד אחד ולא ליעד אחר על סמך לוגיקה מותנית. לדוגמה, משתמש יכול ללחוץ על קישור עומק ליעד שדורש ממנו להתחבר, או שיכולים להיות יעדים שונים במשחק כשהשחקן מנצח או מפסיד.

התחברות של משתמשים

בדוגמה הזו, משתמש מנסה לעבור למסך פרופיל שדורש אימות. הפעולה הזו דורשת אימות, ולכן המשתמש צריך להיות מופנה למסך התחברות אם הוא עדיין לא מאומת.

תרשים הניווט בדוגמה הזו עשוי להיראות כך:

תהליך ההתחברות מטופל בנפרד מתהליך הניווט הראשי של האפליקציה.
תרשים 1. תהליך ההתחברות מטופל בנפרד מתהליך הניווט הראשי של האפליקציה.

כדי לבצע אימות, האפליקציה צריכה לעבור אל login_fragment, שם המשתמש יכול להזין שם משתמש וסיסמה כדי לבצע אימות. אם הבקשה תאושר, המשתמש יופנה חזרה למסך profile_fragment. אם הם לא מתקבלים, המשתמש מקבל הודעה על כך שפרטי הכניסה שלו לא חוקיים באמצעות Snackbar. אם המשתמש חוזר למסך הפרופיל בלי להתחבר, הוא מועבר למסך main_fragment.

זהו תרשים הניווט של האפליקציה הזו:

<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 מכיל כפתור שהמשתמש יכול ללחוץ עליו כדי לראות את הפרופיל שלו. כדי לראות את מסך הפרופיל, המשתמש צריך קודם לבצע אימות. האינטראקציה הזו מעוצבת באמצעות שני קטעים נפרדים, אבל היא תלויה במצב המשתמש המשותף. המידע על המצב הזה לא נמצא באחריות של אף אחד משני הפרגמנטים האלה, ומתאים יותר להחזיק אותו ב-UserViewModel משותף. ה-ViewModel הזה משותף בין הפרגמנטים על ידי הגדרת ההיקף שלו לפעילות, שמטמיעה את ViewModelStoreOwner. בדוגמה הבאה, requireActivity() הופך ל-MainActivity, כי MainActivity מארח את 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);
        ...
    }
    ...
}

נתוני המשתמש ב-UserViewModel נחשפים באמצעות LiveData, אז כדי להחליט לאן לנווט, צריך לבחון את הנתונים האלה. כשעוברים אל ProfileFragment, האפליקציה מציגה הודעת פתיחה אם נתוני המשתמש קיימים. אם נתוני המשתמש הם null, אתם מנווטים אל LoginFragment, כי המשתמש צריך לבצע אימות לפני שהוא יכול לראות את הפרופיל שלו. מגדירים את הלוגיקה של ההחלטה ב-ProfileFragment, כמו בדוגמה הבאה:

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() {
        ...
    }
}

אם נתוני המשתמש הם null כשהם מגיעים אל ProfileFragment, הם מופנים אל LoginFragment.

אפשר להשתמש ב-NavController.getPreviousBackStackEntry כדי לאחזר את NavBackStackEntry של היעד הקודם, שמכיל את המצב הספציפי של NavController ליעד. ‫LoginFragment משתמש ב-SavedStateHandle של ה-NavBackStackEntry הקודם כדי להגדיר ערך ראשוני שמציין אם המשתמש התחבר בהצלחה. זה המצב שאתם רוצים להחזיר אם המשתמש לוחץ מיד על הכפתור "הקודם" של המערכת. הגדרת המצב הזה באמצעות SavedStateHandle מבטיחה שהמצב יישמר גם אם התהליך יושבת.

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);
    }
}

אחרי שהמשתמש מזין שם משתמש וסיסמה, הם מועברים אל UserViewModel לאימות. אם האימות מצליח, UserViewModel שומר את נתוני המשתמש. לאחר מכן, LoginFragment מעדכן את הערך של LOGIN_SUCCESSFUL ב-SavedStateHandle ומוציא את עצמו ממקבץ הפעילויות הקודמות (back stack).

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
    }
}

שימו לב שכל הלוגיקה שקשורה לאימות נמצאת ב-UserViewModel. זה חשוב, כי לא LoginFragment ולא ProfileFragment אחראים לקבוע איך המשתמשים מאומתים. כשמכילים את הלוגיקה ב-ViewModel, לא רק שקל יותר לשתף אותה, אלא גם קל יותר לבדוק אותה. אם לוגיקת הניווט מורכבת, חשוב במיוחד לאמת אותה באמצעות בדיקה. במדריך לארכיטקטורה של אפליקציות מוסבר איך לבנות את הארכיטקטורה של האפליקציה כך שתתבסס על רכיבים שניתן לבדוק.

בחזרה אל ProfileFragment, אפשר לראות את הערך של LOGIN_SUCCESSFUL שמאוחסן ב-SavedStateHandle ב-method‏ onCreate(). כשהמשתמש יחזור אל ProfileFragment, הערך של LOGIN_SUCCESSFUL ייבדק. אם הערך הוא false, אפשר להפנות את המשתמש בחזרה אל 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);
                    }
                });
    }

    ...
}

אם המשתמש התחבר בהצלחה, תוצג הודעת פתיחה ב-ProfileFragment.

השיטה שבה השתמשנו כאן כדי לבדוק את התוצאה מאפשרת להבחין בין שני מקרים שונים:

  • המקרה הראשוני, שבו המשתמש לא מחובר וצריך לבקש ממנו להתחבר.
  • המשתמש לא מחובר כי הוא בחר לא להתחבר (כתוצאה מ-false).

ההבחנה בין תרחישי השימוש האלה תעזור לכם להימנע מבקשות חוזרות ונשנות מהמשתמשים להתחבר. אתם צריכים להחליט מה הלוגיקה העסקית לטיפול במקרים של כשלים. למשל, אתם יכולים להציג שכבת-על שמסבירה למה המשתמש צריך להתחבר, לסיים את כל הפעילות או להפנות את המשתמש ליעד שלא דורש התחברות, כמו בדוגמת הקוד הקודמת.