如何用Switch Case结合Data Binding实现航班式切换交互？

Great question! Using switch-case with Data Binding makes your trip type logic more scalable and readable—perfect for scenarios like one-way/round-trip flight selection where you might add more options later (like multi-city). Let's walk through how to refactor your existing implementation step by step.

Step 1: Define a TripType Enum (Optional but Highly Recommended) #

First, replace the boolean flag with an enum to make your code more semantic. This eliminates confusion from vague true/false values and makes switch-case logic much clearer:

enum class TripType {
    ONE_WAY,
    ROUND_TRIP
    // Add MULTI_CITY later if you need to expand options!
}

Step 2: Update ViewModel to Use TripType & Switch-Case #

In your ViewModel, maintain an observable state for the selected trip type, then use a switch-case (Kotlin's when expression) to handle UI updates for each type. We'll use ObservableField for Data Binding compatibility:

class TripViewModel : ViewModel() {
    // Observable state for selected trip type
    val selectedTripType = ObservableField<TripType>(TripType.ONE_WAY)
    // Observable flag to control visibility of return input
    val showReturnInput = ObservableBoolean(false)

    fun selectTripType(type: TripType) {
        selectedTripType.set(type)
        // Use switch-case to handle each trip type's logic
        when (type) {
            TripType.ONE_WAY -> {
                showReturnInput.set(false)
                // Optional: Clear return input data if needed
            }
            TripType.ROUND_TRIP -> {
                showReturnInput.set(true)
                // Optional: Pre-fill return date with default value
            }
            // Add new cases here if you expand trip types later
        }
    }
}

Step 3: Bind Layout to ViewModel with TripType #

Update your layout buttons to pass the corresponding TripType directly to the ViewModel's selectTripType method. This is far more explicit than passing booleans:

<!-- Make sure to import the enum in your layout's data tag -->
<layout xmlns:android="http://schemas.android.com/apk/res/android">
    <data>
        <variable
            name="viewModel"
            type="com.yourpackage.TripViewModel" />
        <import type="com.yourpackage.TripType" />
        <import type="android.view.View" />
    </data>

    <!-- One-Way Button -->
    <Button
        android:id="@+id/btn_one_way"
        android:text="One-Way"
        android:onClick="@{() -> viewModel.selectTripType(TripType.ONE_WAY)}" />

    <!-- Round-Trip Button -->
    <Button
        android:id="@+id/btn_round_trip"
        android:text="Round-Trip"
        android:onClick="@{() -> viewModel.selectTripType(TripType.ROUND_TRIP)}" />

    <!-- Departure Input (Always Visible) -->
    <EditText
        android:id="@+id/et_departure"
        android:hint="Departure Details"
        android:visibility="visible" />

    <!-- Return Input (Visible Only for Round-Trip) -->
    <EditText
        android:id="@+id/et_return"
        android:hint="Return Details"
        android:visibility="@{viewModel.showReturnInput ? View.VISIBLE : View.GONE}" />
</layout>

Step 4: Simplify Fragment Code #

Your Fragment now only needs to handle Data Binding setup—all UI logic lives in the ViewModel:

class TripFragment : Fragment() {
    private lateinit var binding: TripFragmentBinding
    private val viewModel: TripViewModel by viewModels()

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = TripFragmentBinding.inflate(inflater, container, false)
        binding.viewModel = viewModel
        binding.lifecycleOwner = viewLifecycleOwner // Required for Data Binding to observe LiveData/Observables
        return binding.root
    }
}

Why This Is Better Than Boolean Flags #

• Scalability: Adding a multi-city option later is as simple as adding a new enum value and a case in the when block—no messy boolean refactoring needed.
• Readability: TripType.ROUND_TRIP is instantly understandable, unlike a vague true parameter.
• Maintainability: All UI state logic is centralized in the ViewModel, keeping your Fragment clean and focused on lifecycle management.

If you're using Java instead of Kotlin, the switch-case logic in the ViewModel would look like this:

public void selectTripType(TripType type) {
    selectedTripType.set(type);
    switch(type) {
        case ONE_WAY:
            showReturnInput.set(false);
            break;
        case ROUND_TRIP:
            showReturnInput.set(true);
            break;
    }
}

内容的提问来源于stack exchange，提问作者Shawn.Y