Android Activity多视图状态热切换实现技术咨询

Hey there! Let's work through implementing smooth hot-switching for your Android Activity's three view states. Here's a structured, maintainable approach that fits your scenario perfectly:

First, wrap your three states in an enum to keep state logic clean and avoid magic values:

enum class DeviceConnectionState {
    LINK_DEVICE,
    CONNECTED,
    NO_CONNECTION
}

(If you're using Java, the same logic applies—just use a standard enum class.)

Instead of swapping entire layouts (which can cause jank), include all three state views in your Activity's main XML layout, with only the default state visible initially:

<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <!-- Link Device State -->
    <LinearLayout
        android:id="@+id/link_device_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:orientation="vertical"
        android:visibility="gone">

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_link_device"/>

        <Button
            android:id="@+id/btn_link_device"
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="Link Your Device"/>
    </LinearLayout>

    <!-- Connected State (Main Content) -->
    <LinearLayout
        android:id="@+id/connected_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:visibility="visible">

        <!-- Your main Activity content goes here -->
    </LinearLayout>

    <!-- No Connection State -->
    <LinearLayout
        android:id="@+id/no_connection_container"
        android:layout_width="match_parent"
        android:layout_height="match_parent"
        android:gravity="center"
        android:orientation="vertical"
        android:visibility="gone">

        <ImageView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:src="@drawable/ic_no_connection"/>

        <TextView
            android:layout_width="wrap_content"
            android:layout_height="wrap_content"
            android:text="No network connection available"/>
    </LinearLayout>
</LinearLayout>

Create a single method to handle all state transitions. This centralizes logic and ensures you never accidentally leave multiple views visible:

private fun switchToState(state: DeviceConnectionState) {
    // Hide all containers first to avoid overlap
    binding.linkDeviceContainer.visibility = View.GONE
    binding.connectedContainer.visibility = View.GONE
    binding.noConnectionContainer.visibility = View.GONE

    // Show the relevant container and set up any state-specific logic
    when (state) {
        DeviceConnectionState.LINK_DEVICE -> {
            binding.linkDeviceContainer.visibility = View.VISIBLE
            // Set up button click listener (if not already initialized)
            binding.btnLinkDevice.setOnClickListener {
                startActivity(Intent(this, LinkDeviceActivity::class.java))
            }
        }
        DeviceConnectionState.CONNECTED -> {
            binding.connectedContainer.visibility = View.VISIBLE
            // Optional: Refresh main content if needed
            refreshMainActivityData()
        }
        DeviceConnectionState.NO_CONNECTION -> {
            binding.noConnectionContainer.visibility = View.VISIBLE
        }
    }
}

For your recurring HTTP checks, always run network operations off the main thread, then update the UI on the main thread. Here's an example using Kotlin Coroutines (the modern approach for Android async work):

private fun startConnectionCheckLoop() {
    // Repeat checks every 5 seconds (adjust interval to fit your needs)
    lifecycleScope.launch {
        while (isActive) {
            val currentState = fetchCurrentDeviceState()
            switchToState(currentState)
            delay(5000)
        }
    }
}

private suspend fun fetchCurrentDeviceState(): DeviceConnectionState {
    return withContext(Dispatchers.IO) {
        try {
            // Execute your HTTP request and parse the response
            val response = yourHttpClient.execute(yourRequest)
            val responseData = parseResponseData(response)

            when {
                responseData.isDeviceConnected -> DeviceConnectionState.CONNECTED
                responseData.hasNoNetwork -> DeviceConnectionState.NO_CONNECTION
                else -> DeviceConnectionState.LINK_DEVICE
            }
        } catch (e: IOException) {
            // Network error falls back to no connection state
            DeviceConnectionState.NO_CONNECTION
        }
    }
}

Don't forget to start/stop the loop with your Activity's lifecycle to avoid memory leaks:

override fun onStart() {
    super.onStart()
    startConnectionCheckLoop()
}

override fun onStop() {
    super.onStop()
    lifecycleScope.cancel() // Cancels all coroutines tied to this Activity's lifecycle
}

• Add State Debouncing: If your HTTP checks might return frequent state changes, add a small delay or check to avoid redundant UI switches (e.g., don't switch to NO_CONNECTION if we're already in that state).
• Use ViewModel for State Retention: Move your state logic and HTTP loop to a ViewModel so your state persists through configuration changes (like screen rotations). Example snippet:

  // In your ViewModel
  val currentState = MutableLiveData<DeviceConnectionState>()
  
  fun startCheckLoop() {
      viewModelScope.launch {
          while (isActive) {
              val state = fetchCurrentDeviceState()
              currentState.postValue(state)
              delay(5000)
          }
      }
  }
  
  // In your Activity
  viewModel.currentState.observe(this) { state ->
      switchToState(state)
  }
  

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