Android技术问题：如何在当前类检测其他类中Switch的选中状态

Hey there! Let's tackle how to check the state of that Switch in ManualControls from your other Fragments. Here are a few solid, Android-native approaches you can use:

This is a standard way to communicate between components without tight coupling.

• First, define a callback interface inside ManualControls to expose the Switch state, and add a listener to notify state changes:

public class ManualControls extends Fragment {
    private Switch switchLED;
    private OnSwitchStateChangeListener listener;

    // Define the callback interface
    public interface OnSwitchStateChangeListener {
        void onSwitchStateChanged(boolean isChecked);
    }

    @Override
    public void onAttach(@NonNull Context context) {
        super.onAttach(context);
        // Ensure the host Activity implements the interface
        try {
            listener = (OnSwitchStateChangeListener) context;
        } catch (ClassCastException e) {
            throw new ClassCastException(context.toString() + " must implement OnSwitchStateChangeListener");
        }
    }

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_manual_controls, container, false);
        switchLED = view.findViewById(R.id.LEDSwitch1);
        switchLED.setChecked(false);
        switchLED.setTextOn("On");
        switchLED.setTextOff("Off");

        // Listen for Switch changes and notify the callback
        switchLED.setOnCheckedChangeListener((buttonView, isChecked) -> {
            if (listener != null) {
                listener.onSwitchStateChanged(isChecked);
            }
        });
        return view;
    }

    // Method to let external components fetch the current state
    public boolean isSwitchChecked() {
        return switchLED != null && switchLED.isChecked();
    }
}

• Next, implement the interface in your host Activity, then pass the state to other Fragments:

public class MainActivity extends AppCompatActivity implements ManualControls.OnSwitchStateChangeListener {
    private boolean isLedSwitchChecked = false;

    @Override
    public void onSwitchStateChanged(boolean isChecked) {
        isLedSwitchChecked = isChecked;
        // Notify other Fragments (e.g., DashboardFragment)
        DashboardFragment dashboardFragment = (DashboardFragment) getSupportFragmentManager().findFragmentById(R.id.dashboard_fragment);
        if (dashboardFragment != null) {
            dashboardFragment.updateLedSwitchState(isChecked);
        }
    }

    // Expose state to other Fragments
    public boolean getLedSwitchState() {
        return isLedSwitchChecked;
    }
}

• Finally, use the state in your target Fragment (e.g., DashboardFragment):

public class DashboardFragment extends Fragment {
    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        // Fetch initial state
        MainActivity activity = (MainActivity) getActivity();
        if (activity != null) {
            boolean isChecked = activity.getLedSwitchState();
            executeActionBasedOnSwitch(isChecked);
        }
    }

    // Receive state updates from Activity
    public void updateLedSwitchState(boolean isChecked) {
        executeActionBasedOnSwitch(isChecked);
    }

    private void executeActionBasedOnSwitch(boolean isChecked) {
        if (isChecked) {
            // Do something when Switch is ON
        } else {
            // Do something when Switch is OFF
        }
    }
}

This is the modern, lifecycle-safe approach that works seamlessly with Android Jetpack, avoiding issues like Fragment recreation.

• First, create a shared ViewModel to hold the Switch state:

import androidx.lifecycle.LiveData;
import androidx.lifecycle.MutableLiveData;
import androidx.lifecycle.ViewModel;

public class SharedSwitchViewModel extends ViewModel {
    private final MutableLiveData<Boolean> switchState = new MutableLiveData<>(false);

    public void setSwitchState(boolean isChecked) {
        switchState.setValue(isChecked);
    }

    public LiveData<Boolean> getSwitchState() {
        return switchState;
    }
}

• Update the LiveData from ManualControls:

public class ManualControls extends Fragment {
    private Switch switchLED;
    private SharedSwitchViewModel viewModel;

    @Override
    public View onCreateView(LayoutInflater inflater, ViewGroup container, Bundle savedInstanceState) {
        View view = inflater.inflate(R.layout.fragment_manual_controls, container, false);
        // Get the shared ViewModel (using Activity scope so all Fragments share the same instance)
        viewModel = new ViewModelProvider(requireActivity()).get(SharedSwitchViewModel.class);
        
        switchLED = view.findViewById(R.id.LEDSwitch1);
        switchLED.setChecked(false);
        switchLED.setTextOn("On");
        switchLED.setTextOff("Off");

        switchLED.setOnCheckedChangeListener((buttonView, isChecked) -> {
            viewModel.setSwitchState(isChecked);
        });
        return view;
    }
}

• Observe the state in any other Fragment (e.g., AlertsFragment):

public class AlertsFragment extends Fragment {
    private SharedSwitchViewModel viewModel;

    @Override
    public void onViewCreated(@NonNull View view, @Nullable Bundle savedInstanceState) {
        super.onViewCreated(view, savedInstanceState);
        viewModel = new ViewModelProvider(requireActivity()).get(SharedSwitchViewModel.class);
        
        // Observe state changes (automatically handles lifecycle events)
        viewModel.getSwitchState().observe(getViewLifecycleOwner(), isChecked -> {
            executeActionBasedOnSwitch(isChecked);
        });

        // Fetch initial state if needed
        Boolean currentState = viewModel.getSwitchState().getValue();
        if (currentState != null) {
            executeActionBasedOnSwitch(currentState);
        }
    }

    private void executeActionBasedOnSwitch(boolean isChecked) {
        // Your logic here
    }
}

You can fetch the ManualControls instance via FragmentManager, but this creates tight coupling and risks null pointers if the Fragment is destroyed:

// In another Fragment
ManualControls manualControls = (ManualControls) getParentFragmentManager().findFragmentByTag("manual_controls_tag");
if (manualControls != null) {
    boolean isChecked = manualControls.isSwitchChecked();
    executeActionBasedOnSwitch(isChecked);
}

Note: You'll need to set a tag when adding ManualControls to the FragmentManager, e.g., in your Activity:

getSupportFragmentManager().beginTransaction()
    .add(R.id.container, new ManualControls(), "manual_controls_tag")
    .commit();

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