如何在 Android [Kotlin] 中处理 3 个嵌套回收器视图中的数据

Question

我有一个由三个回收器视图组成的结构。 因此，有一个父回收器视图包含一个子回收器视图，而该子回收器视图包含一个子回收器视图。

为了理解它就像第一个回收站视图是楼层总数。 第二个回收器视图是房间总数，第三个回收器视图是设备总数。

我有一个房间数据库，我可以从中编写查询以接收总楼层、房间、设备作为字符串列表。 因为它们作为字符串值存储在数据库中。

对于查询楼层，这是一个简单的查询。 为了查询房间，我通过了楼层 position 并且为了查询附加的设备，我通过了房间值。

该项目遵循 MVVM 架构，因此存在 DAO，数据从那里进入存储库，存储库进一步进入 Viewmodel，然后使用 LiveData 从 Fragment 观察。

主要问题：因此，获取楼层、房间和设备的大部分逻辑都发生在 ViewModel 内部。 我尝试了多种方法来使用 livedata 或挂起函数从房间数据库中获取数据。 但是在这些循环中插入数据 class 中的值时会出现问题。 我显然做错了什么（下面给出的代码），因为显示的数据格式不正确。 我得到了楼层和房间的列表，但就像所有房间都添加到每个楼层，而不是每个楼层的单独值。 同样，应该连接到各个房间的所有设备都连接到所有房间。 如果有人可以帮助我，那将非常有帮助，因为我被困在过去的两天里。 谢谢。 所有代码都在下面给出，如果您需要更多理解，请在评论中告诉我。

实体文件

@Entity(tableName = "added_device_information")
data class AddedDevicesInformation(

    @ColumnInfo(name = "floor_name")
    var floorName: String? = "",

    @ColumnInfo(name = "room_name")
    var roomName: String? = "",

    @ColumnInfo(name = "machine_name")
    var machineName: String? = "",

    @ColumnInfo(name = "device_name")
    var deviceName: String? = "",

    @ColumnInfo(name = "factory_status")
    var factoryStatus: Boolean? = false,

    @PrimaryKey(autoGenerate = true)
    var id: Int? = null,
) {
}

DAO 文件

@Dao
interface DevicesInformationDao {

    @Insert(onConflict = OnConflictStrategy.IGNORE)
    suspend fun insertAddedDevicesToDatabase(addedDevicesInformation: AddedDevicesInformation)

    //returns all floors in the database
    @Query("SELECT floor_name from added_device_information")
    fun readAllFloorsFromDatabase(): LiveData<List<String>>

    //returns all rooms associated with a floor
    @Query("SELECT room_name from added_device_information where floor_name =:floor")
    suspend fun readAllRoomsOnAFloor(floor: String): List<String>
    
    //Get all devices in a room
    @Query("SELECT device_name from added_device_information where room_name =:room")
    suspend fun readAllDevicesInRoom(room:String): List<String>
}

存储库文件

//This repository is for reading values from the database using [DevicesInformationDao]
class ControlPanelRepository(private val devicesInformationDao: DevicesInformationDao) {

    val getAllFloors: LiveData<List<String>> = devicesInformationDao.readAllFloorsFromDatabase()

    //for rooms associated with floors
    suspend fun getAllRooms(floor: String): List<String> = devicesInformationDao.readAllRoomsOnAFloor(floor)

    suspend fun getAllDevices(room: String): List<String> = devicesInformationDao.readAllDevicesInRoom(room)

}

ViewModel 文件（主要问题在此文件中）

class ControlPanelViewModel(private val repository: ControlPanelRepository) : ViewModel() {

    //Variable for getting all floors
    private val _getAllFloors: LiveData<List<String>> = repository.getAllFloors
    private val getAllFloors: LiveData<List<String>> = _getAllFloors

    //setting FloorDataClass objects
    private val floorListLiveData = MutableLiveData<List<FloorsDataClass>>()
    val floorList: LiveData<List<FloorsDataClass>> get() = floorListLiveData

    fun loadRooms() {

        val floorsList = mutableListOf<FloorsDataClass>()
        val roomsList = mutableListOf<RoomsDataClass>()
        val devicesList = mutableListOf<DevicesDataClass>()

        var distinctFloors: List<String>
        var distinctRooms: List<String>
        var distinctDevices: List<String>

        getAllFloors.observeForever(Observer {

            viewModelScope.launch(Dispatchers.Main) {

                distinctFloors = it.distinct().sorted()

                for (floorName in distinctFloors) {
                    val rooms = repository.getAllRooms(floorName)

                    distinctRooms = rooms.distinct()

                    for (roomName in distinctRooms) {

                        distinctDevices = repository.getAllDevices(roomName)

                        devicesList.add(DevicesDataClass(distinctDevices))

                        roomsList.add(RoomsDataClass(roomName, devicesList))

                        floorsList.add(FloorsDataClass(floorName, roomsList))

                        floorListLiveData.postValue(floorsList)
                        Timber.d("$floorsList")

                    }
                }
            }
        })
    }
}

片段文件：

 override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View? {
        _binding = FragmentControlPanelBinding.inflate(layoutInflater)

        adapter = FloorsAdapter(activity)
controlPanelViewModel = ViewModelProvider(this, factory)[ControlPanelViewModel::class.java]
        controlPanelViewModel.loadRooms()
        return binding.root
    }


 override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        binding.rvFloors.adapter = adapter
        binding.rvFloors.layoutManager = LinearLayoutManager(requireContext())
        binding.rvFloors.setHasFixedSize(true)

        controlPanelViewModel.floorList.observe(viewLifecycleOwner, Observer {
            adapter.floorList(floors = it)
            Timber.d("List is $it")
        })
    }

数据类 - FloorDataClass

data class FloorsDataClass(val floor: String, val rooms: List<RoomsDataClass>) {
}

房间数据类

data class RoomsDataClass(val room:String, val devices: List<DevicesDataClass>) {
}

设备数据类

data class DevicesDataClass(val machine: List<String>) {
}

回收者视图的适配器

• 地板适配器

open class FloorsAdapter(
    private val activity: FragmentActivity?
) : RecyclerView.Adapter<FloorsAdapter.FloorViewHolder>() {

    private var floorList = emptyList<FloorsDataClass>()

    inner class FloorViewHolder(
        val binding: ListItemControlPanelFloorsBinding,
        val roomsAdapter: RoomsAdapter
    ) : RecyclerView.ViewHolder(binding.root) {}

    override fun onCreateViewHolder(
        parent: ViewGroup,
        viewType: Int
    ): FloorViewHolder {
        val layoutInflater = LayoutInflater.from(parent.context)
        val binding = ListItemControlPanelFloorsBinding.inflate(layoutInflater, parent, false)

        //Create adapter per floor
        val adapter = RoomsAdapter(activity)
        binding.rvRoomControlPanel.adapter = adapter
        binding.rvRoomControlPanel.layoutManager = LinearLayoutManager(activity)
        return FloorViewHolder(binding, adapter)
    }

    @SuppressLint("NotifyDataSetChanged", "SetTextI18n")
    override fun onBindViewHolder(holder: FloorsAdapter.FloorViewHolder, position: Int) {
        //For a given floor set the rooms on that floor's room adapter
        val currentFloor = floorList[position]
        holder.apply {
            roomsAdapter.roomList(currentFloor.rooms)
            binding.tvFloor.text = "Floor : ${currentFloor.floor}"
            Timber.d("Rooms on floor: $currentFloor are : ${currentFloor.rooms}")
        }
    }

    @SuppressLint("NotifyDataSetChanged")
    fun floorList(floors: List<FloorsDataClass>) {
        this.floorList = floors
        notifyDataSetChanged()
    }

    override fun getItemCount(): Int {
        return floorList.size
    }
}

• 房间适配器

open class RoomsAdapter(
    private val activity: FragmentActivity?
) : RecyclerView.Adapter<RoomsAdapter.RoomViewHolder>() {

    private var roomList = emptyList<RoomsDataClass>()

    inner class RoomViewHolder(
        val binding: ListItemControlPanelRoomsBinding,
        val machinesAdapter: DevicesAdapter
    ) : RecyclerView.ViewHolder(binding.root) {}

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): RoomViewHolder {
        val layoutInflater = LayoutInflater.from(parent.context)
        val binding = ListItemControlPanelRoomsBinding.inflate(layoutInflater, parent, false)

        //setting machines for each room
        val adapter = DevicesAdapter()
        binding.rvMachineControlPanel.adapter = adapter
        binding.rvMachineControlPanel.layoutManager = LinearLayoutManager(activity)
        return RoomViewHolder(binding, adapter)
    }

    @SuppressLint("SetTextI18n")
    override fun onBindViewHolder(holder: RoomViewHolder, position: Int) {
        val currentRoom = roomList[position]
        Timber.d("Current room : $currentRoom")
        holder.apply {
            binding.tvRoom.text = "Room : ${currentRoom.room}"
            machinesAdapter.devicesLists(currentRoom.devices)
        }
    }

    @SuppressLint("NotifyDataSetChanged")
    fun roomList(room: List<RoomsDataClass>) {
        this.roomList = room
        Timber.d("List received : $room")
        notifyDataSetChanged()
    }

    override fun getItemCount(): Int {
        return roomList.size
    }
}

• 设备适配器

class DevicesAdapter : RecyclerView.Adapter<DevicesAdapter.MachinesViewHolder>() {

    private var devicesList = emptyList<DevicesDataClass>()

    inner class MachinesViewHolder(val binding: ListItemControlPanelMachinesBinding) :
        RecyclerView.ViewHolder(binding.root)

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): MachinesViewHolder {
        val inflater = LayoutInflater.from(parent.context)
        val binding = ListItemControlPanelMachinesBinding.inflate(inflater, parent, false)
        return MachinesViewHolder(binding)
    }

    override fun onBindViewHolder(holder: MachinesViewHolder, position: Int) {
        val currentMachine = devicesList[position]
        holder.apply {
            binding.tvDevice.text = currentMachine.machine.toString()
        }
    }

    override fun getItemCount(): Int {
        return devicesList.size
    }

    fun devicesLists(machine: List<DevicesDataClass>) {
        this.devicesList = machine
    }
}

编辑1 ：我需要片段上的数据为：Floor1 -> RoomA -> Device1, Device2 | 房间 B -> 设备 3 || 楼层 2 -> 房间 C -> 设备 4、设备 5 | 房间 D -> 设备 6，设备 7

我得到的数据是：Floor1 -> RoomA -> Device1, Device2, Device3, Device4....（直到最后一个设备）| RoomB -> 设备 1、设备 2、设备 3、设备 4....（直到最后一个设备）|| 楼层 2 -> 相同

Answer 1

loadRooms中的代码存在一些问题

• 如果每个楼层/房间是唯一的，则不应有房间或设备的外部列表。 您正在制作一个deviceList 并不断向其中添加内容，而不是为每个房间制作一个单独的 deviceList。 同样，您正在制作一个 roomList 并将其添加到其中，而不是每层单独的列表。
• 你不应该在最里面的循环中发布楼层列表

它应该看起来像这样：

fun loadRooms() {

    getAllFloors.observeForever(Observer {

        viewModelScope.launch(Dispatchers.Main) {

            val distinctFloorNames = it.distinct().sorted()
            val floorsList = mutableListOf<FloorsDataClass>()

            // Loop over floors
            for (floorName in distinctFloorNames) {

                // At *each* floor prepare a list of rooms
                val roomNames = repository.getAllRooms(floorName)
                val distinctRoomNames = roomNames.distinct().sorted()
                val roomsList = mutableListOf<RoomDataClass>

                // Loop over rooms in the floor
                for (roomName in distinctRoomNames) {

                    // In *each* room prepare a list of devices
                    val deviceNames = repository.getAllDevices(roomName)
                    val distinctDeviceNames = deviceNames.distinct().sorted()

                    // Transform the list of strings to a list of
                    // DeviceDataClass objects
                    val deviceData = distinctDeviceNames.map { dev -> DeviceDataClass(dev) }

                    // Add the device list to a room object
                    // and add the room to the room list
                    roomsList.add(RoomsDataClass(roomName, deviceData))
                }
                
                // Add the room list to a floor object and add
                // the floor to the floor list
                floorsList.add(FloorsDataClass(floorName, roomsList))
            }
            
            // Post the completed floor list
            floorListLiveData.postValue(floorsList)
            Timber.d("$floorsList")
        }
    })
}

修改为使DevicesDataClass是单个字符串，而不是字符串列表（因为房间已经包含设备列表）

data class DeviceDataClass(val machine: String) {}