BaseActivity继承场景下SlidingUpPanel返回键销毁后更新异常求助

Hey there, let's work through this problem together! The core issue here is that your SlidingUpPanel's dynamic updates are tied to the lifecycle of individual BaseActivity subclass instances—when you press back, the current Activity (and its Base instance) gets destroyed, taking the update logic with it. Your current workaround of launching the previous Activity creates unnecessary overhead, so let's look at cleaner, more efficient solutions:

1. Separate Panel Update Logic from Activity Lifecycle #

The best approach is to decouple your panel's dynamic data and update logic from the Activity using Android Architecture Components. A ViewModel is perfect for this—it retains data across Activity destruction/recreation and lets multiple Activities observe the same data source.

Example Implementation:

// 1. Create a ViewModel to manage panel data and updates
class PanelUpdateViewModel(application: Application) : AndroidViewModel(application) {
    private val _dynamicPanelData = MutableLiveData<String>()
    val dynamicPanelData: LiveData<String> = _dynamicPanelData

    init {
        // Simulate your periodic update logic
        val updateTimer = Timer()
        updateTimer.scheduleAtFixedRate(object : TimerTask() {
            override fun run() {
                // Post updates to the main thread
                _dynamicPanelData.postValue("Last updated: ${System.currentTimeMillis()}")
            }
        }, 0, 1000)
    }
}

// 2. Update BaseActivity to use the ViewModel
abstract class BaseActivity : AppCompatActivity() {
    private lateinit var panelViewModel: PanelUpdateViewModel

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Initialize your SlidingUpPanel here...

        // Get the ViewModel (it will persist across Activity recreations)
        panelViewModel = ViewModelProvider(this).get(PanelUpdateViewModel::class.java)
        
        // Observe data changes to update the panel
        observePanelUpdates()
    }

    private fun observePanelUpdates() {
        panelViewModel.dynamicPanelData.observe(this) { newData ->
            // Update your SlidingUpPanel's views here
            findViewById<TextView>(R.id.panel_content_text).text = newData
        }
    }
}

This way, even if an Activity is destroyed when you press back, the ViewModel keeps running the update logic. When you navigate back to a previous Activity, it will automatically observe the latest data and refresh the panel.

2. Resume Updates When Activity Returns to Foreground #

If you prefer to keep the update logic within BaseActivity, you can pause/resume the updates using Activity lifecycle methods. This ensures updates only run when the Activity is visible, and resume automatically when you navigate back to it.

Example Implementation:

abstract class BaseActivity : AppCompatActivity() {
    private var updateTimer: Timer? = null

    override fun onResume() {
        super.onResume()
        // Restart panel updates when the Activity comes back to foreground
        startPanelUpdates()
    }

    override fun onPause() {
        super.onPause()
        // Pause updates when the Activity is no longer visible
        stopPanelUpdates()
    }

    private fun startPanelUpdates() {
        updateTimer?.cancel()
        updateTimer = Timer()
        updateTimer?.scheduleAtFixedRate(object : TimerTask() {
            override fun run() {
                runOnUiThread {
                    // Call abstract method to update panel views in subclasses
                    updatePanelContent()
                }
            }
        }, 0, 1000)
    }

    private fun stopPanelUpdates() {
        updateTimer?.cancel()
        updateTimer = null
    }

    // Subclasses implement this to update their specific panel views
    protected abstract fun updatePanelContent()
}

With this setup, pressing back will destroy the current Activity, but when you return to a previous one, onResume() will restart the updates automatically—no need to launch a new Activity instance.

3. Global Floating Panel (Advanced) #

If you need the panel to stay active across all three Activities without being tied to any single Activity's lifecycle, you can implement it as a system floating window. This requires the SYSTEM_ALERT_WINDOW permission and more careful lifecycle management, but it works for use cases where the panel needs to be visible at all times.

Recommendation #

Start with option 1 (using ViewModel)—it aligns with Android's best practices, keeps your code clean, and eliminates the slow Activity switching issue entirely. If you need simpler lifecycle-based control, option 2 is a lightweight alternative.

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