Dynamic putExtra()与getExtra()问题：跨Activity动态获取坐标值

Hey there! Let's tackle your question clearly:

首先，这个现象完全正常！ #

When you use Intent.putExtra() to pass data from Activity A to B, you're essentially sending a snapshot of the x/y/z values at the exact moment you call startActivity(). Once the Intent is sent, any subsequent changes to those values in Activity A won't automatically update the data stored in the Intent. That's just how Intent data transfer works—it's a one-time handoff, not a live connection. So seeing the initial value stuck in Activity B is totally expected behavior.

接下来，怎么动态获取实时的x/y/z值？ #

Below are the most practical solutions for Android, ordered by how recommended they are (based on lifecycle safety and maintainability):

1. ViewModel + LiveData (Top Recommendation) #

ViewModel is part of Android Jetpack, designed specifically to hold UI-related data independent of Activity lifecycle. Pair it with LiveData, and you get automatic real-time updates whenever your coordinates change—plus it's safe from memory leaks and configuration changes (like screen rotations).

Here's how to implement it:

• Create a shared ViewModel class:

import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class CoordinateSharedViewModel : ViewModel() {
    // LiveData objects to hold coordinate values
    val xValue = MutableLiveData<Float>()
    val yValue = MutableLiveData<Float>()
    val zValue = MutableLiveData<Float>()

    // Method to update coordinates from Activity A
    fun updateCoordinates(x: Float, y: Float, z: Float) {
        xValue.value = x
        yValue.value = y
        zValue.value = z
    }
}

• Update coordinates in Activity A:

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider

class ActivityA : AppCompatActivity() {
    private lateinit var sharedViewModel: CoordinateSharedViewModel

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

        // Get the ViewModel instance
        sharedViewModel = ViewModelProvider(
            applicationContext as ViewModelStoreOwner,
            ViewModelProvider.AndroidViewModelFactory.getInstance(application)
        )[CoordinateSharedViewModel::class.java]

        // Your coordinate calculation logic here
        fun calculateAndUpdateCoordinates() {
            val calculatedX = ... // Replace with your actual calculation
            val calculatedY = ...
            val calculatedZ = ...
            // Push new values to the ViewModel
            sharedViewModel.updateCoordinates(calculatedX, calculatedY, calculatedZ)
        }
    }
}

• Listen for updates in Activity B (and other floor Activities):

import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.lifecycle.ViewModelProvider
import androidx.lifecycle.observe

class ActivityB : AppCompatActivity() {
    private lateinit var sharedViewModel: CoordinateSharedViewModel

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

        // Get the same shared ViewModel instance
        sharedViewModel = ViewModelProvider(
            applicationContext as ViewModelStoreOwner,
            ViewModelProvider.AndroidViewModelFactory.getInstance(application)
        )[CoordinateSharedViewModel::class.java]

        // Listen for real-time updates
        sharedViewModel.xValue.observe(this) { newX ->
            // Do something with the updated x value
        }
        sharedViewModel.yValue.observe(this) { newY ->
            // Handle updated y value
        }
        sharedViewModel.zValue.observe(this) { newZ ->
            // Use z value to switch floor Activities as needed
        }
    }
}

Key note: Using applicationContext as the ViewModel owner ensures all Activities share the same instance—critical for live data sync.

2. Interface Callbacks (For Simple, Short-Lived Scenarios) #

If your use case is super basic (e.g., Activity A and B are both active at the same time), you can use an interface to pass updates directly. Just be careful to avoid memory leaks by unregistering the callback when Activity B is destroyed.

• Define the callback interface:

interface CoordinateUpdateListener {
    fun onCoordinatesChanged(x: Float, y: Float, z: Float)
}

• Manage listeners in Activity A:

class ActivityA : AppCompatActivity() {
    private val coordinateListeners = mutableListOf<CoordinateUpdateListener>()

    fun registerCoordinateListener(listener: CoordinateUpdateListener) {
        if (!coordinateListeners.contains(listener)) {
            coordinateListeners.add(listener)
        }
    }

    fun unregisterCoordinateListener(listener: CoordinateUpdateListener) {
        coordinateListeners.remove(listener)
    }

    private fun calculateCoordinates() {
        val x = ...
        val y = ...
        val z = ...
        // Notify all registered listeners
        coordinateListeners.forEach { it.onCoordinatesChanged(x, y, z) }
    }
}

• Implement the callback in Activity B:

class ActivityB : AppCompatActivity(), CoordinateUpdateListener {
    private lateinit var activityA: ActivityA

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

        // Get a reference to Activity A (e.g., via Activity stack or singleton)
        activityA = ... 
        activityA.registerCoordinateListener(this)
    }

    override fun onCoordinatesChanged(x: Float, y: Float, z: Float) {
        // Handle real-time coordinate updates here
    }

    override fun onDestroy() {
        super.onDestroy()
        // Critical: Unregister to avoid memory leaks
        activityA.unregisterCoordinateListener(this)
    }
}

This approach is simple but has limitations—you need to ensure Activity A is still alive, and managing references can get messy.

3. Singleton Class (Use With Caution) #

You can create a singleton object to store your coordinates, then access it from any Activity. Just be mindful that singletons live as long as your app, so avoid storing large data or holding Activity references.

• Create the singleton (with LiveData for updates):

object CoordinateManager {
    private val _x = MutableLiveData<Float>(0f)
    val x: LiveData<Float> = _x

    private val _y = MutableLiveData<Float>(0f)
    val y: LiveData<Float> = _y

    private val _z = MutableLiveData<Float>(0f)
    val z: LiveData<Float> = _z

    fun updateCoordinates(x: Float, y: Float, z: Float) {
        _x.value = x
        _y.value = y
        _z.value = z
    }
}

• Update in Activity A:

fun calculateCoordinates() {
    val x = ...
    val y = ...
    val z = ...
    CoordinateManager.updateCoordinates(x, y, z)
}

• Listen for updates in Activity B:

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

    CoordinateManager.x.observe(this) { newX ->
        // Handle updated x
    }
    // Repeat for y and z
}

This works, but it's less flexible than ViewModel and can lead to tight coupling between components.

Final Takeaway #

• Your initial issue is totally normal—Intent data is a one-time snapshot, not a live stream.
• ViewModel + LiveData is the best approach for most cases, as it's lifecycle-safe and officially recommended by Google.
• Use callbacks only for simple, short-lived interactions, and singletons sparingly to avoid memory issues.

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