如何在RecyclerView与多个Fragment间传递数据？点击项传值至Tab Fragment

Hey there! Let's walk through how to pass data from your RecyclerView to a specific tabbed Fragment—this is a super common use case, and I’ll break down a few reliable approaches that fit your tabbed navigation setup.

This is my go-to method because it’s lifecycle-safe, avoids messy fragment instance references, and handles configuration changes (like screen rotations) seamlessly. Here’s how to implement it:

Step 1: Create a Shared ViewModel #

Make a ViewModel class to hold the selected Employee data. This acts as a central data store accessible to both your RecyclerView’s host and the target Fragment.

import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class SharedEmployeeViewModel : ViewModel() {
    // MutableLiveData lets us update data and observe changes
    val selectedEmployee = MutableLiveData<Employee>()

    fun setSelectedEmployee(employee: Employee) {
        selectedEmployee.value = employee
    }
}

Note: Ensure your Employee class is either Parcelable or Serializable if you need to persist it across configuration changes, though LiveData handles in-memory persistence automatically.

Step 2: Connect the RecyclerView Adapter to the ViewModel #

In the fragment or activity hosting your RecyclerView, get an instance of the shared ViewModel (using the activity’s scope so all fragments under the same activity can access it). Then pass the selection event to the ViewModel when a list item is clicked:

import androidx.lifecycle.ViewModelProvider

class EmployeeListFragment : Fragment() {
    private lateinit var viewModel: SharedEmployeeViewModel
    private lateinit var employeeAdapter: EmployeeAdapter

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        // Get the ViewModel using the activity's provider scope
        viewModel = ViewModelProvider(requireActivity())[SharedEmployeeViewModel::class.java]
        
        // Initialize adapter with a click lambda
        employeeAdapter = EmployeeAdapter { employee ->
            viewModel.setSelectedEmployee(employee)
            // Switch to the target tab (replace TARGET_TAB_POSITION with your tab's index, e.g., 1)
            (activity as MainActivity).viewPager.currentItem = TARGET_TAB_POSITION
        }
    }

    // ... rest of your fragment code (setting up RecyclerView, etc.)
}

Here’s the adapter with a clean click lambda (simpler than interfaces for basic cases):

class EmployeeAdapter(private val onItemClick: (Employee) -> Unit) : RecyclerView.Adapter<EmployeeViewHolder>() {
    private val employeeList = mutableListOf<Employee>()

    // ... override onCreateViewHolder, getItemCount, etc.

    override fun onBindViewHolder(holder: EmployeeViewHolder, position: Int) {
        val employee = employeeList[position]
        // Bind employee data to views here
        
        // Set click listener
        holder.itemView.setOnClickListener {
            onItemClick(employee)
        }
    }

    // Update the list with new data
    fun submitList(list: List<Employee>) {
        employeeList.clear()
        employeeList.addAll(list)
        notifyDataSetChanged()
    }
}

Step 3: Observe Data in the Target Fragment #

In the tabbed Fragment where you want to display the employee data, observe the ViewModel’s selectedEmployee LiveData. Whenever the data updates (from a RecyclerView click), your fragment will automatically receive the new employee and can update its UI:

class EmployeeDetailFragment : Fragment() {
    private lateinit var viewModel: SharedEmployeeViewModel
    private lateinit var tvName: TextView
    private lateinit var tvId: TextView

    override fun onCreateView(inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?): View? {
        val view = inflater.inflate(R.layout.fragment_employee_detail, container, false)
        tvName = view.findViewById(R.id.tv_employee_name)
        tvId = view.findViewById(R.id.tv_employee_id)
        
        // Get the same shared ViewModel instance
        viewModel = ViewModelProvider(requireActivity())[SharedEmployeeViewModel::class.java]
        
        // Observe changes to the selected employee
        viewModel.selectedEmployee.observe(viewLifecycleOwner) { employee ->
            // Update your UI with the employee data
            tvName.text = employee.name
            tvId.text = employee.id.toString()
            // Add more UI updates as needed
        }
        return view
    }
}

If you prefer not to use Jetpack ViewModel, you can use an interface to pass data from the RecyclerView to the host, then to the target Fragment. Here’s a quick breakdown:

Step 1: Define a Click Listener Interface #

interface OnEmployeeSelectedListener {
    fun onEmployeeSelected(employee: Employee)
}

Step 2: Implement the Interface in the Host Activity/Fragment #

class EmployeeListFragment : Fragment(), OnEmployeeSelectedListener {
    // ...

    override fun onEmployeeSelected(employee: Employee) {
        // Switch to the target tab
        (activity as MainActivity).viewPager.currentItem = TARGET_TAB_POSITION
        
        // Get the target Fragment instance from the ViewPager adapter
        val detailFragment = (activity as MainActivity).viewPager.adapter?.let {
            it.instantiateItem((activity as MainActivity).viewPager, TARGET_TAB_POSITION) as EmployeeDetailFragment
        }
        
        // Pass data to the fragment via a public method
        detailFragment?.updateEmployeeDetails(employee)
    }
}

Step 3: Add the Listener to the Adapter #

class EmployeeAdapter(private val listener: OnEmployeeSelectedListener) : RecyclerView.Adapter<EmployeeViewHolder>() {
    // ...

    override fun onBindViewHolder(holder: EmployeeViewHolder, position: Int) {
        val employee = employeeList[position]
        holder.itemView.setOnClickListener {
            listener.onEmployeeSelected(employee)
        }
    }
}

Step 4: Add a Public Method to the Target Fragment #

class EmployeeDetailFragment : Fragment() {
    // ...

    fun updateEmployeeDetails(employee: Employee) {
        // Update UI here
        tvName.text = employee.name
        tvId.text = employee.id.toString()
    }
}

• ViewModel is preferred because it avoids potential memory leaks from holding references to fragments/activities, and it preserves data across configuration changes.
• If using the interface approach, be careful when getting the Fragment instance from the ViewPager—ensure the fragment is initialized and not null.
• Always make sure your Employee class implements Parcelable or Serializable if you need to pass it between components (though ViewModel holds it in memory, so it’s not strictly required unless you persist it).

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