सेटिंग   Android Jetpack का हिस्सा है.

सेटिंग की मदद से, उपयोगकर्ता किसी ऐप्लिकेशन के फ़ंक्शन और काम करने के तरीके में बदलाव कर सकते हैं. सेटिंग से बैकग्राउंड में ऐप्लिकेशन के काम करने के तरीके पर असर पड़ सकता है. जैसे, ऐप्लिकेशन कितनी बार क्लाउड के साथ डेटा सिंक करता है. इसके अलावा, सेटिंग का असर ज़्यादा भी हो सकता है. जैसे, यूज़र इंटरफ़ेस का कॉन्टेंट और उसे दिखाने का तरीका बदलना.

अपने ऐप्लिकेशन में, उपयोगकर्ता के हिसाब से कॉन्फ़िगर की जा सकने वाली सेटिंग को इंटिग्रेट करने के लिए, AndroidX की प्राथमिकता लाइब्रेरी का इस्तेमाल करें. यह लाइब्रेरी, यूज़र इंटरफ़ेस को मैनेज करती है और स्टोरेज से इंटरैक्ट करती है, ताकि आप सिर्फ़ उन अलग-अलग सेटिंग को तय कर सकें जिन्हें उपयोगकर्ता कॉन्फ़िगर कर सकता है. लाइब्रेरी में Material Design थीम होती है, जो सभी डिवाइसों और OS वर्शन पर एक जैसा उपयोगकर्ता अनुभव देती है.

शुरू करें

Preference, प्राथमिकता लाइब्रेरी का बुनियादी ब्लॉक है. सेटिंग स्क्रीन में Preference क्रम होता है. इस हैरारकी को एक्सएमएल रिसॉर्स के तौर पर तय किया जा सकता है या कोड में हैरारकी बनाई जा सकती है.

नीचे दिए गए सेक्शन में, AndroidX की प्राथमिकता लाइब्रेरी का इस्तेमाल करके, सेटिंग वाली आसान स्क्रीन बनाने का तरीका बताया गया है.

शुरू करने से पहले, अपनी build.gradle फ़ाइल में प्राथमिकता लाइब्रेरी डिपेंडेंसी जोड़ें:

dependencies {
    implementation "androidx.preference:preference-ktx:1.2.0"
}

dependencies {
    implementation("androidx.preference:preference-ktx:1.2.0")
}

Gradle सिंक करने के बाद, टास्क के एक्सएमएल हिस्से पर जाया जा सकता है.

हैरारकी बनाना

अपने प्रोजेक्ट में, res/xml फ़ोल्डर पर जाएं और preferences.xml फ़ाइल बनाएं. इसके बाद, उसमें यह कोड जोड़ें:

<PreferenceScreen
    xmlns:app="http://schemas.android.com/apk/res-auto">

    <SwitchPreferenceCompat
        app:key="notifications"
        app:title="Enable message notifications"/>

    <Preference
        app:key="feedback"
        app:title="Send feedback"
        app:summary="Report technical issues or suggest new features"/>

</PreferenceScreen>

इस हैरारकी में दो Preference ऑब्जेक्ट होते हैं: एक ऐसा SwitchPreferenceCompat जो उपयोगकर्ताओं को किसी सेटिंग को चालू और बंद करने की सुविधा देता है. दूसरा, बिना विजेट वाला बुनियादी Preference.

हैरारकी बनाते समय, हर Preference के लिए एक यूनीक कुंजी होनी चाहिए.

हैरारकी को बड़ा करना

किसी एक्सएमएल एट्रिब्यूट से हैरारकी को इन्फ़्लेट करने के लिए, एक PreferenceFragmentCompat बनाएं, onCreatePreferences() को बदलें, और इन्फ़्लेट करने के लिए एक्सएमएल रिसॉर्स दें, जैसा कि यहां दिए गए उदाहरण में दिखाया गया है:

class MySettingsFragment : PreferenceFragmentCompat() {
    override fun onCreatePreferences(savedInstanceState: Bundle?, rootKey: String?) {
        setPreferencesFromResource(R.xml.preferences, rootKey)
    }
}

public class MySettingsFragment extends PreferenceFragmentCompat {
    @Override
    public void onCreatePreferences(Bundle savedInstanceState, String rootKey) {
        setPreferencesFromResource(R.xml.preferences, rootKey);
    }
}

इसके बाद, इस Fragment को अपने Activity में जोड़ा जा सकता है, जैसे कि किसी भी दूसरे Fragment को जोड़ा जाता है:

class MySettingsActivity : AppCompatActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        supportFragmentManager
                .beginTransaction()
                .replace(R.id.settings_container, MySettingsFragment())
                .commit()
    }
}

public class MySettingsActivity extends AppCompatActivity {
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
        getSupportFragmentManager()
                .beginTransaction()
                .replace(R.id.settings_container, new MySettingsFragment())
                .commit();
    }
}

नतीजा, नीचे दी गई इमेज में दिखाया गया है:

प्राथमिकताओं को मॉनिटर करें

किसी लिसनर को किसी प्राथमिकता के लिए रजिस्टर करके, प्राथमिकता में बदलाव होने पर इवेंट मिल सकता है:

findPreference<SwitchPreferenceCompat>("notifications")
    ?.setOnPreferenceChangeListener { _, newValue ->
        Log.d("Preferences", "Notifications enabled: $newValue")
        true // Return true if the event is handled.
    }

findPreference<Preference>("feedback")
    ?.setOnPreferenceClickListener {
        Log.d("Preferences", "Feedback was clicked")
        true // Return true if the click is handled.
    }

SwitchPreferenceCompat notificationsPref = findPreference("notifications");

if (notificationsPref != null) {
    notificationsPref.setOnPreferenceChangeListener((preference, newValue) -> {
        Log.d("Preferences", String.format("Notifications enabled: %s", newValue));
        return true; // Return true if the event is handled.
    });
}

Preference feedbackPref = findPreference("feedback");

if (feedbackPref != null) {
    feedbackPref.setOnPreferenceClickListener((preference) -> {
        Log.d("Preferences", "Feedback was clicked");
        return true; // Return true if the event is handled.
    });
}

प्राथमिकता की मौजूदा वैल्यू पढ़ना

PreferenceFragmentCompat, प्राथमिकताओं को सेव करने और पढ़ने में इस्तेमाल होने वाली ज़्यादातर मशीनों को छिपा देता है. हालांकि, सभी जानकारी को SharedPreferences का इस्तेमाल करके सेव किया जाता है. साथ ही, इन वैल्यू को वैसे ही पढ़ा जा सकता है जैसे आम तौर पर SharedPreferences का इस्तेमाल करके किया जाता है:

val preferences = PreferenceManager.getDefaultSharedPreferences(this).all

preferences.forEach {
    Log.d("Preferences", "${it.key} -> ${it.value}")
}

var preferences = PreferenceManager.getDefaultSharedPreferences(context).getAll();

preferences.forEach((key, value) ->{
    Log.d("Preferences", String.format("%s -> %s", key, value));
});

पिछला स्निपेट, ऐप्लिकेशन के लिए डिफ़ॉल्ट SharedPreferences का एक इंस्टेंस पाता है. साथ ही, सेव की गई सभी वैल्यू को ऐक्सेस करता है, उन पर लूप करता है, और उन्हें Logcat में प्रिंट करता है.