कंडिशनल नेविगेशन

अपने ऐप्लिकेशन के लिए नेविगेशन डिज़ाइन करते समय, हो सकता है कि आप कंडिशनल लॉजिक के आधार पर, एक डेस्टिनेशन के बजाय दूसरे डेस्टिनेशन पर जाना चाहें. उदाहरण के लिए, कोई उपयोगकर्ता किसी ऐसे डेस्टिनेशन के डीप लिंक को फ़ॉलो कर सकता है जिसके लिए उपयोगकर्ता को लॉग इन करना ज़रूरी है. इसके अलावा, किसी गेम में खिलाड़ी के जीतने या हारने पर, आपके पास अलग-अलग डेस्टिनेशन हो सकते हैं.

उपयोगकर्ता का लॉगिन

इस उदाहरण में, कोई उपयोगकर्ता किसी ऐसी प्रोफ़ाइल स्क्रीन पर जाने की कोशिश करता है जिसके लिए पुष्टि करना ज़रूरी है. इस कार्रवाई के लिए पुष्टि करना ज़रूरी है. इसलिए, अगर उपयोगकर्ता की पुष्टि पहले से नहीं हुई है, तो उसे लॉगिन स्क्रीन पर रीडायरेक्ट किया जाना चाहिए.

इस उदाहरण के लिए, नेविगेशन ग्राफ़ कुछ ऐसा दिख सकता है:

लॉगिन फ़्लो को ऐप्लिकेशन के मुख्य नेविगेशन फ़्लो से अलग मैनेज किया जाता है.
पहली इमेज. लॉगिन फ़्लो को ऐप्लिकेशन के मुख्य नेविगेशन फ़्लो से अलग मैनेज किया जाता है.

पुष्टि करने के लिए, ऐप्लिकेशन को 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, पिछले NavBackStackEntry के SavedStateHandle का इस्तेमाल करके, शुरुआती वैल्यू सेट करता है. इससे पता चलता है कि उपयोगकर्ता ने लॉग इन किया है या नहीं. यह वह स्थिति है जिस पर आपको वापस जाना है, अगर उपयोगकर्ता तुरंत सिस्टम का 'वापस जाएं' बटन दबाता है. 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, SavedStateHandle पर LOGIN_SUCCESSFUL की वैल्यू को अपडेट करता है और पिछली गतिविधियों से खुद को हटा देता है.

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 में वापस जाकर, SavedStateHandle में सेव की गई LOGIN_SUCCESSFUL वैल्यू को 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 की वजह से).

इस्तेमाल के इन उदाहरणों में अंतर करके, उपयोगकर्ता से बार-बार लॉगिन करने के लिए कहने से बचा जा सकता है. लॉगिन न हो पाने के मामलों को हैंडल करने के लिए कारोबारी नियम, आपको तय करने होंगे. इनमें, ओवरले दिखाना शामिल हो सकता है. इससे उपयोगकर्ता को यह पता चलता है कि उसे लॉगिन करने, पूरी गतिविधि को पूरा करने या उपयोगकर्ता को किसी ऐसे डेस्टिनेशन पर रीडायरेक्ट करने की ज़रूरत क्यों है जिसके लिए लॉगिन करने की ज़रूरत नहीं है. जैसा कि पिछले कोड के उदाहरण में बताया गया है.