Android应用预加载用户资料，点击按钮自动填充UserProfileActivity求助

Hey there! Let's work through this together. First, a quick heads-up: AsyncTask has been deprecated since Android API 30, so I’ll cover both the AsyncTask method you asked about and a more modern, recommended approach using Kotlin Coroutines (since they’re better for handling lifecycles and avoiding memory leaks).

When to use it: #

Start the AsyncTask in your MainActivity's onCreate() method. This way, data loading kicks off as soon as the activity starts, so by the time the user taps the button, the profile data is likely already ready.

Step-by-Step Implementation: #

First, define a simple data class to hold user profile data:

data class UserProfile(val name: String, val age: Int, val gender: String)

Next, create an AsyncTask subclass to handle background database loading:

class LoadUserProfileTask(private val activity: MainActivity) : AsyncTask<Void, Void, UserProfile?>() {

    override fun doInBackground(vararg params: Void?): UserProfile? {
        // Database operations MUST run on a background thread
        return try {
            val dbRef = FirebaseDatabase.getInstance().getReference("users/currentUser")
            val snapshot = dbRef.get().result // Synchronous fetch (safe here since we're off the main thread)
            snapshot.getValue(UserProfile::class.java)
        } catch (e: Exception) {
            // Handle errors (e.g., network issues, missing data)
            null
        }
    }

    override fun onPostExecute(result: UserProfile?) {
        super.onPostExecute(result)
        // Pass loaded data back to MainActivity once done
        activity.userProfile = result
    }
}

Then, integrate this into your MainActivity:

class MainActivity : AppCompatActivity() {
    private var userProfile: UserProfile? = null
    private lateinit var profileLoadTask: LoadUserProfileTask

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

        // Start loading profile data immediately
        profileLoadTask = LoadUserProfileTask(this)
        profileLoadTask.execute()

        // Set up button click listener
        findViewById<Button>(R.id.btn_view_profile).setOnClickListener {
            userProfile?.let { profile ->
                // Launch UserProfileActivity with preloaded data
                val intent = Intent(this, UserProfileActivity::class.java).apply {
                    putExtra("EXTRA_NAME", profile.name)
                    putExtra("EXTRA_AGE", profile.age)
                    putExtra("EXTRA_GENDER", profile.gender)
                }
                startActivity(intent)
            } ?: run {
                // Show a toast if data is still loading
                Toast.makeText(this, "Loading profile, please wait...", Toast.LENGTH_SHORT).show()
            }
        }
    }

    override fun onDestroy() {
        super.onDestroy()
        // Cancel the task to prevent memory leaks if activity is destroyed early
        profileLoadTask.cancel(true)
    }
}

Finally, display the data in UserProfileActivity:

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

        val name = intent.getStringExtra("EXTRA_NAME") ?: "Unknown"
        val age = intent.getIntExtra("EXTRA_AGE", 0)
        val gender = intent.getStringExtra("EXTRA_GENDER") ?: "Unknown"

        findViewById<TextView>(R.id.tv_profile_details).text = """
            Name: $name
            Age: $age
            Gender: $gender
        """.trimIndent()
    }
}

AsyncTask is outdated, so coroutines are the preferred way to handle background work in Android. They’re simpler, lifecycle-aware, and avoid common AsyncTask pitfalls like memory leaks.

Implementation: #

class MainActivity : AppCompatActivity() {
    // Use LiveData to observe profile data changes (optional but useful for updates)
    private val userProfileLiveData = MutableLiveData<UserProfile?>()

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

        // Load profile data using coroutines
        loadUserProfile()

        findViewById<Button>(R.id.btn_view_profile).setOnClickListener {
            userProfileLiveData.value?.let { profile ->
                val intent = Intent(this, UserProfileActivity::class.java).apply {
                    putExtra("EXTRA_NAME", profile.name)
                    putExtra("EXTRA_AGE", profile.age)
                    putExtra("EXTRA_GENDER", profile.gender)
                }
                startActivity(intent)
            } ?: run {
                Toast.makeText(this, "Loading profile...", Toast.LENGTH_SHORT).show()
            }
        }
    }

    private fun loadUserProfile() {
        // lifecycleScope automatically cancels coroutines when the activity is destroyed
        lifecycleScope.launch {
            val profile = withContext(Dispatchers.IO) {
                try {
                    val dbRef = FirebaseDatabase.getInstance().getReference("users/currentUser")
                    val snapshot = dbRef.get().await() // Coroutine-friendly async fetch
                    snapshot.getValue(UserProfile::class.java)
                } catch (e: Exception) {
                    null
                }
            }
            // Update LiveData on the main thread
            userProfileLiveData.postValue(profile)
        }
    }
}

• Always handle database errors (add try-catch blocks) to avoid crashes if the network fails or data is missing.
• If user profiles might update while the app is running, using LiveData ensures the UI gets the latest data automatically.
• Never run database operations on the main thread—this will cause ANRs (Application Not Responding) errors.

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