如何从Fragment向Activity发送指令以调用相机？

Hey there! Let's walk through the best ways to handle communication between your Fragment and Activity, then trigger the camera from the Activity once the Fragment sends its command. These are the approaches I regularly use in production apps:

1. Interface Callback (Official Recommended Approach) #

This is the classic, straightforward way to keep communication between Fragment and Activity clear and type-safe. Here's how to implement it:

Step 1: Define an Interface in Your Fragment #

First, create an interface inside your Fragment to declare the events your Activity needs to respond to:

class YourFragment : Fragment() {

    // Define the listener interface
    interface OnFragmentActionCallback {
        fun onConfirmPressed()
        fun onCancelPressed()
    }

    private var callback: OnFragmentActionCallback? = null

    // Attach the callback when the Fragment is connected to the Activity
    override fun onAttach(context: Context) {
        super.onAttach(context)
        // Ensure the Activity implements the interface
        if (context is OnFragmentActionCallback) {
            callback = context
        } else {
            throw RuntimeException("$context must implement OnFragmentActionCallback")
        }
    }

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val binding = YourFragmentBinding.inflate(inflater, container, false)

        // Handle Confirm button click
        binding.btnConfirm.setOnClickListener {
            callback?.onConfirmPressed()
            // Close the Fragment (adjust this based on your navigation setup)
            findNavController().popBackStack()
        }

        // Handle Cancel button click
        binding.btnCancel.setOnClickListener {
            callback?.onCancelPressed()
            findNavController().popBackStack()
        }

        return binding.root
    }

    // Clean up the callback to avoid memory leaks
    override fun onDetach() {
        super.onDetach()
        callback = null
    }
}

Step 2: Implement the Interface in Your Activity #

Now have your Activity implement the interface and handle the camera launch:

class MainActivity : AppCompatActivity(), YourFragment.OnFragmentActionCallback {

    private val REQUEST_IMAGE_CAPTURE = 1

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContentView(R.layout.activity_main)
        // ... your existing setup code
    }

    // Respond to the Fragment's confirm event
    override fun onConfirmPressed() {
        launchCamera()
    }

    // Respond to the Fragment's cancel event (adjust logic as needed)
    override fun onCancelPressed() {
        // Optional: Reset UI state or handle cancellation
        Toast.makeText(this, "Action cancelled", Toast.LENGTH_SHORT).show()
    }

    // Launch the system camera
    private fun launchCamera() {
        val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        try {
            startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
        } catch (e: ActivityNotFoundException) {
            // Handle case where camera app isn't available
            Toast.makeText(this, "Camera app not found", Toast.LENGTH_SHORT).show()
        }
    }

    // Optional: Handle the camera result (if you need the captured image)
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
            val imageBitmap = data?.extras?.get("data") as Bitmap
            // Do something with the captured bitmap
        }
    }
}

2. ViewModel + LiveData (Jetpack-Based, Decoupled Approach) #

If you're using Jetpack components, this method is more elegant and handles configuration changes (like screen rotation) automatically. It keeps your Fragment and Activity decoupled without needing interfaces.

Step 1: Create a Shared ViewModel #

Create a ViewModel that both the Fragment and Activity can access:

class SharedActionViewModel : ViewModel() {
    // LiveData to trigger camera launch (use a wrapper if you need to avoid duplicate events)
    val launchCameraTrigger = MutableLiveData<Boolean>()

    // Call this from the Fragment to trigger the camera
    fun requestCameraLaunch() {
        launchCameraTrigger.value = true
    }

    // Reset the trigger to prevent re-triggering on configuration change
    fun resetCameraTrigger() {
        launchCameraTrigger.value = false
    }
}

Step 2: Update the Fragment to Use the ViewModel #

In your Fragment, get the ViewModel (scoped to the Activity) and trigger the camera request on button clicks:

class YourFragment : Fragment() {

    // Get the ViewModel scoped to the parent Activity
    private val sharedViewModel: SharedActionViewModel by activityViewModels()

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val binding = YourFragmentBinding.inflate(inflater, container, false)

        binding.btnConfirm.setOnClickListener {
            sharedViewModel.requestCameraLaunch()
            findNavController().popBackStack()
        }

        binding.btnCancel.setOnClickListener {
            // Optional: Send a cancel event if needed, or just close the Fragment
            findNavController().popBackStack()
        }

        return binding.root
    }
}

Step 3: Observe the Trigger in Your Activity #

Have your Activity observe the LiveData and launch the camera when triggered:

class MainActivity : AppCompatActivity() {

    private val REQUEST_IMAGE_CAPTURE = 1
    private val sharedViewModel: SharedActionViewModel by viewModels()

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

        // Observe the camera trigger
        sharedViewModel.launchCameraTrigger.observe(this) { shouldLaunch ->
            if (shouldLaunch) {
                launchCamera()
                sharedViewModel.resetCameraTrigger()
            }
        }
    }

    // Same camera launch method as before
    private fun launchCamera() {
        val takePictureIntent = Intent(MediaStore.ACTION_IMAGE_CAPTURE)
        try {
            startActivityForResult(takePictureIntent, REQUEST_IMAGE_CAPTURE)
        } catch (e: ActivityNotFoundException) {
            Toast.makeText(this, "Camera app not found", Toast.LENGTH_SHORT).show()
        }
    }

    // Optional: Handle camera result
    override fun onActivityResult(requestCode: Int, resultCode: Int, data: Intent?) {
        super.onActivityResult(requestCode, resultCode, data)
        if (requestCode == REQUEST_IMAGE_CAPTURE && resultCode == RESULT_OK) {
            val imageBitmap = data?.extras?.get("data") as Bitmap
            // Process the image
        }
    }
}

3. EventBus (Quick but Not Recommended) #

While EventBus libraries can work for rapid prototyping, they make code harder to maintain by hiding dependencies. I only recommend this for small throwaway projects. Here's a quick example:

// Define an event class
class LaunchCameraEvent

// In your Fragment, post the event on button click
binding.btnConfirm.setOnClickListener {
    EventBus.getDefault().post(LaunchCameraEvent())
    findNavController().popBackStack()
}

// In your Activity, register and listen for the event
override fun onStart() {
    super.onStart()
    EventBus.getDefault().register(this)
}

override fun onStop() {
    super.onStop()
    EventBus.getDefault().unregister(this)
}

@Subscribe(threadMode = ThreadMode.MAIN)
fun onLaunchCameraEvent(event: LaunchCameraEvent) {
    launchCamera()
}

Final Recommendations #

• Use Interface Callback if you're sticking to a traditional Android architecture—it's simple and explicit.
• Use ViewModel + LiveData if you're using Jetpack—it's the most robust and decoupled option, especially for handling configuration changes.
• Avoid EventBus unless you have a very specific reason to use it.

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