无需重启MainActivity，如何调用LoginActivity存储的SharedPreferences布尔值？

Nice question! Since you're already using SharedPreferences to store those boolean values in LoginActivity, there are a few straightforward ways to access them in MainActivity without restarting the activity. Let's break down the most practical options based on your needs:

1. Directly Read from SharedPreferences (Simple Use Cases) #

If you only need to fetch the boolean value at a specific moment (like when MainActivity is visible, or when a user triggers an action), you can just read directly from SharedPreferences whenever you need it. Since SharedPreferences is persistent storage, the value will be available as soon as it's saved from LoginActivity.

Kotlin Example: #

// In MainActivity, whenever you need the value
val sharedPref = getSharedPreferences("YourPrefsName", Context.MODE_PRIVATE)
val isLoggedIn = sharedPref.getBoolean("your_boolean_key", false) // false is default value

// Use the value (e.g., update UI, enable/disable features)
if (isLoggedIn) {
    // Do something like show a welcome message
} else {
    // Prompt login
}

Java Example: #

// In MainActivity, whenever you need the value
SharedPreferences sharedPref = getSharedPreferences("YourPrefsName", MODE_PRIVATE);
boolean isLoggedIn = sharedPref.getBoolean("your_boolean_key", false);

// Use the value
if (isLoggedIn) {
    // Update UI or business logic
}

Best for: Quick one-time checks, or when you don't need real-time updates when the value changes.

2. Listen for SharedPreferences Changes (Real-Time Updates) #

If you want MainActivity to automatically react when the boolean value is updated in LoginActivity (without manually checking), you can register a SharedPreferences.OnSharedPreferenceChangeListener. This will trigger a callback whenever the specific key's value changes.

Kotlin Example: #

class MainActivity : AppCompatActivity() {
    private lateinit var sharedPref: SharedPreferences
    private val prefChangeListener = SharedPreferences.OnSharedPreferenceChangeListener { _, key ->
        // Check if the changed key is the one we care about
        if (key == "your_boolean_key") {
            val isLoggedIn = sharedPref.getBoolean(key, false)
            // Update UI or handle the new value immediately
            updateLoginUI(isLoggedIn)
        }
    }

    override fun onResume() {
        super.onResume()
        // Initialize SharedPreferences and register the listener
        sharedPref = getSharedPreferences("YourPrefsName", Context.MODE_PRIVATE)
        sharedPref.registerOnSharedPreferenceChangeListener(prefChangeListener)
    }

    override fun onPause() {
        super.onPause()
        // Always unregister the listener to avoid memory leaks
        sharedPref.unregisterOnSharedPreferenceChangeListener(prefChangeListener)
    }

    private fun updateLoginUI(isLoggedIn: Boolean) {
        // Example: Toggle a button's visibility or text
        loginButton.visibility = if (isLoggedIn) View.GONE else View.VISIBLE
        welcomeText.visibility = if (isLoggedIn) View.VISIBLE else View.GONE
    }
}

Java Example: #

public class MainActivity extends AppCompatActivity {
    private SharedPreferences sharedPref;
    private SharedPreferences.OnSharedPreferenceChangeListener prefChangeListener = new SharedPreferences.OnSharedPreferenceChangeListener() {
        @Override
        public void onSharedPreferenceChanged(SharedPreferences sharedPreferences, String key) {
            if ("your_boolean_key".equals(key)) {
                boolean isLoggedIn = sharedPreferences.getBoolean(key, false);
                updateLoginUI(isLoggedIn);
            }
        }
    };

    @Override
    protected void onResume() {
        super.onResume();
        sharedPref = getSharedPreferences("YourPrefsName", MODE_PRIVATE);
        sharedPref.registerOnSharedPreferenceChangeListener(prefChangeListener);
    }

    @Override
    protected void onPause() {
        super.onPause();
        sharedPref.unregisterOnSharedPreferenceChangeListener(prefChangeListener);
    }

    private void updateLoginUI(boolean isLoggedIn) {
        // Update your UI components here
        Button loginButton = findViewById(R.id.login_button);
        TextView welcomeText = findViewById(R.id.welcome_text);
        
        loginButton.setVisibility(isLoggedIn ? View.GONE : View.VISIBLE);
        welcomeText.setVisibility(isLoggedIn ? View.VISIBLE : View.GONE);
    }
}

Best for: When you need MainActivity to react immediately to changes in the SharedPreferences value (e.g., updating UI right after the user logs in).

3. Use LiveData (Jetpack Recommended Approach) #

If your project uses Android Jetpack, wrapping the SharedPreferences value in a LiveData is a cleaner, lifecycle-safe way to handle real-time updates. This ensures your UI only updates when MainActivity is in an active state, avoiding memory leaks or unnecessary updates.

Step 1: Create a ViewModel #

import android.app.Application
import android.content.Context
import android.content.SharedPreferences
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.MutableLiveData

class AuthViewModel(application: Application) : AndroidViewModel(application) {
    private val sharedPref: SharedPreferences = 
        application.getSharedPreferences("YourPrefsName", Context.MODE_PRIVATE)
    
    // LiveData to expose the login status
    val isLoggedInLiveData = MutableLiveData<Boolean>()

    init {
        // Initialize with the current value from SharedPreferences
        isLoggedInLiveData.value = sharedPref.getBoolean("your_boolean_key", false)
        
        // Listen for changes in SharedPreferences
        sharedPref.registerOnSharedPreferenceChangeListener { _, key ->
            if (key == "your_boolean_key") {
                isLoggedInLiveData.value = sharedPref.getBoolean(key, false)
            }
        }
    }

    // Call this from LoginActivity to update the login status
    fun updateLoginStatus(isLoggedIn: Boolean) {
        sharedPref.edit().putBoolean("your_boolean_key", isLoggedIn).apply()
    }
}

Step 2: Update Value from LoginActivity #

// In LoginActivity's button onClick listener
val authViewModel = ViewModelProvider(this).get(AuthViewModel::class.java)
authViewModel.updateLoginStatus(true) // Or false, depending on your logic

Step 3: Observe LiveData in MainActivity #

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

        val authViewModel = ViewModelProvider(this).get(AuthViewModel::class.java)
        // Observe the LiveData - this will trigger whenever the value changes
        authViewModel.isLoggedInLiveData.observe(this) { isLoggedIn ->
            updateLoginUI(isLoggedIn)
        }
    }

    private fun updateLoginUI(isLoggedIn: Boolean) {
        // Handle UI updates here
    }
}

Best for: Modern Android projects using Jetpack, as it follows MVVM principles and ensures lifecycle safety.

内容的提问来源于stack exchange，提问作者Yash Randive