when clicking on the note in my app it doesnt open and doesnt throw an error code

Question

in my app there's an area where you can create notes of different equipment you input but after creating the note, when I click on it to edit it doesn't open at all. I want it to be where I can be able to click the notes to edit them after they have been created.

Homefragment.kt

package davis.cameron.maintenanceapp.ui.Fragments

import android.os.Bundle
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.View
import android.view.ViewGroup
import androidx.appcompat.widget.SearchView
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.lifecycle.LiveData
import androidx.navigation.findNavController
import androidx.recyclerview.widget.LinearLayoutManager
import androidx.recyclerview.widget.StaggeredGridLayoutManager
import davis.cameron.maintenanceapp.Models.Notes
import davis.cameron.maintenanceapp.R
import davis.cameron.maintenanceapp.databinding.FragmentHomeBinding
import davis.cameron.maintenanceapp.ui.Adapter.NotesAdapter
import davis.cameron.maintenanceapp.viewModel.NotesViewModel

class HomeFragment : Fragment() {

    private var _binding: FragmentHomeBinding? = null
    private val binding get() = _binding!!
    private val viewModel: NotesViewModel by viewModels()
    private lateinit var adapter: NotesAdapter

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?, savedInstanceState: Bundle?
    ): View {
        _binding = FragmentHomeBinding.inflate(inflater, container, false)
        setHasOptionsMenu(true)

        setupRecyclerView()

        binding.btnAddNotes.setOnClickListener {
            it.findNavController().navigate(R.id.action_homeFragment_to_createNotesFragment)
        }

        return binding.root
    }


    private fun setupRecyclerView() {
        adapter = NotesAdapter(listOf())
        binding.rcvAllNotes.layoutManager = StaggeredGridLayoutManager(2, LinearLayoutManager.VERTICAL)
        binding.rcvAllNotes.adapter = adapter

        viewModel.getNotes().observe(viewLifecycleOwner) { notesList ->
            adapter.filtering(notesList)
        }

        binding.allNotes.setOnClickListener { filterNotes(viewModel::getNotes) }
        binding.filterFmc.setOnClickListener { filterNotes(viewModel::getFmcNotes) }
        binding.filterFaults.setOnClickListener { filterNotes(viewModel::getFaultsNotes) }
        binding.filterNmc.setOnClickListener { filterNotes(viewModel::getNmcNotes) }
    }

    private fun filterNotes(filterMethod: () -> LiveData<List<Notes>>) {
        filterMethod().observe(viewLifecycleOwner) { notesList ->
            adapter.filtering(notesList)
        }
    }

    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
        inflater.inflate(R.menu.search_menu, menu)
        (menu.findItem(R.id.app_bar_search).actionView as? SearchView)?.apply {
            queryHint = "Enter Notes Here"
            setOnQueryTextListener(object : SearchView.OnQueryTextListener {
                override fun onQueryTextSubmit(query: String?): Boolean = true

                override fun onQueryTextChange(newText: String?): Boolean {
                    NotesFiltering(newText)
                    return true
                }
            })
        }
    }

    private fun NotesFiltering(query: String?) {
        query?.let {
            val filteredList = adapter.notesList.filter { note ->
                note.bumperNumber.contains(it, ignoreCase = true) ||
                        note.equipmentType.contains(it, ignoreCase = true) ||
                        note.model.contains(it, ignoreCase = true) ||
                        note.serialNumber.contains(it, ignoreCase = true) ||
                        note.serviceDate.contains(it, ignoreCase = true)
            }
            adapter.filtering(filteredList)
        }
    }

    override fun onDestroyView() {
        super.onDestroyView()
        _binding = null
    }
}

EditFragment.kt

package davis.cameron.maintenanceapp.ui.Fragments

import android.os.Bundle
import android.text.format.DateFormat
import android.view.LayoutInflater
import android.view.Menu
import android.view.MenuInflater
import android.view.MenuItem
import android.view.View
import android.view.ViewGroup
import android.widget.TextView
import android.widget.Toast
import androidx.fragment.app.Fragment
import androidx.fragment.app.viewModels
import androidx.navigation.fragment.findNavController
import androidx.navigation.fragment.navArgs
import com.google.android.material.bottomsheet.BottomSheetDialog
import davis.cameron.maintenanceapp.Models.Notes
import davis.cameron.maintenanceapp.R
import davis.cameron.maintenanceapp.databinding.FragmentEditNotesBinding
import davis.cameron.maintenanceapp.viewModel.NotesViewModel
import java.util.Date

class EditNotesFragment : Fragment() {

    private val oldNotes by navArgs<EditNotesFragmentArgs>()
    private lateinit var binding: FragmentEditNotesBinding
    private var priority: String = "1"
    private val viewModel: NotesViewModel by viewModels()

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

        // Initialize the fields with existing note data
        initializeFields()

        // Setup click listeners
        setupPrioritySelection()

        binding.btnEditSaveNotes.setOnClickListener {
            updateNotes()
        }

        return binding.root
    }

    private fun initializeFields() {
        binding.apply {
            edtBumperNumber.setText(oldNotes.data.bumperNumber)
            edtEquipmentType.setText(oldNotes.data.equipmentType)
            edtModel.setText(oldNotes.data.model)
            edtSerialNumber.setText(oldNotes.data.serialNumber)
            edtServiceDate.setText(oldNotes.data.serviceDate)
            // Set initial priority state
            updatePrioritySelection(oldNotes.data.priority)
        }
    }

    private fun setupPrioritySelection() {
        binding.fmc.setOnClickListener {
            updatePrioritySelection("1")
        }
        binding.fault.setOnClickListener {
            updatePrioritySelection("2")
        }
        binding.nmc.setOnClickListener {
            updatePrioritySelection("3")
        }
    }

    private fun updatePrioritySelection(selectedPriority: String) {
        priority = selectedPriority
        binding.fmc.setImageResource(if (priority == "1") R.drawable.baseline_check_24 else 0)
        binding.fault.setImageResource(if (priority == "2") R.drawable.baseline_check_24 else 0)
        binding.nmc.setImageResource(if (priority == "3") R.drawable.baseline_check_24 else 0)
    }

    private fun updateNotes() {
        val data = Notes(
            oldNotes.data.id,
            bumperNumber = binding.edtBumperNumber.text.toString(),
            equipmentType = binding.edtEquipmentType.text.toString(),
            model = binding.edtModel.text.toString(),
            serialNumber = binding.edtSerialNumber.text.toString(),
            serviceDate = binding.edtServiceDate.text.toString(),
            date = DateFormat.format("MMMM d, yyyy ", Date().time).toString(),
            priority = priority
        )

        viewModel.updateNotes(data)
        Toast.makeText(requireContext(), "Notes Updated Successfully", Toast.LENGTH_SHORT).show()
        findNavController().navigate(R.id.action_editNotesFragment_to_homeFragment)
    }

    override fun onCreateOptionsMenu(menu: Menu, inflater: MenuInflater) {
        inflater.inflate(R.menu.delete_menu, menu)
    }

    override fun onOptionsItemSelected(item: MenuItem): Boolean {
        when (item.itemId) {
            R.id.menu_delete -> {
                showDeleteConfirmationDialog()
                return true
            }
        }
        return super.onOptionsItemSelected(item)
    }

    private fun showDeleteConfirmationDialog() {
        val bottomSheet = BottomSheetDialog(requireContext(), R.style.BottomSheetStyle)
        bottomSheet.setContentView(R.layout.dialog_delete)
        bottomSheet.findViewById<TextView>(R.id.diaglog_yes)?.setOnClickListener {
            viewModel.deleteNotes(oldNotes.data.id!!)
            bottomSheet.dismiss()
            Toast.makeText(requireContext(), "Note Deleted", Toast.LENGTH_SHORT).show()
            findNavController().popBackStack()
        }

        bottomSheet.findViewById<TextView>(R.id.dialog_no)?.setOnClickListener {
            bottomSheet.dismiss()
        }

        bottomSheet.show()
    }
}

NotesAdapter.kt

package davis.cameron.maintenanceapp.ui.Adapter

import android.view.LayoutInflater
import android.view.ViewGroup
import androidx.recyclerview.widget.RecyclerView
import davis.cameron.maintenanceapp.Models.Notes
import davis.cameron.maintenanceapp.R
import davis.cameron.maintenanceapp.databinding.ItemNotesBinding

class NotesAdapter(
    var notesList: List<Notes>
) : RecyclerView.Adapter<NotesAdapter.NotesViewHolder>() {

    fun filtering(newFilteredList: List<Notes>) {
        notesList = newFilteredList
        notifyDataSetChanged()
    }

    class NotesViewHolder(val binding: ItemNotesBinding) : RecyclerView.ViewHolder(binding.root)

    override fun onCreateViewHolder(parent: ViewGroup, viewType: Int): NotesViewHolder {
        return NotesViewHolder(
            ItemNotesBinding.inflate(
                LayoutInflater.from(parent.context),
                parent,
                false
            )
        )
    }

    override fun onBindViewHolder(holder: NotesViewHolder, position: Int) {
        val data = notesList[position]
        with(holder.binding) {
            notesBumperNumber.text = data.bumperNumber
            notesEquipmentType.text = data.equipmentType
            notesModelType.text = data.model
            notesSerialNumber.text = data.serialNumber
            notesServiceDate.text = data.serviceDate
            notesDate.text = data.date

            when (data.priority) {
                "1" -> viewPriority.setBackgroundResource(R.drawable.green_dot)
                "2" -> viewPriority.setBackgroundResource(R.drawable.yellow_dot)
                "3" -> viewPriority.setBackgroundResource(R.drawable.red_dot)
            }
        }
    }

    override fun getItemCount(): Int = notesList.size
}

NotesViewModel.kt

package davis.cameron.maintenanceapp.viewModel

import android.app.Application
import androidx.lifecycle.AndroidViewModel
import androidx.lifecycle.LiveData
import androidx.lifecycle.viewModelScope
import davis.cameron.maintenanceapp.Database.NotesDatabase
import davis.cameron.maintenanceapp.Models.Notes
import davis.cameron.maintenanceapp.Repository.NotesRepository
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.launch

class NotesViewModel(application: Application) : AndroidViewModel(application) {

    private val repository: NotesRepository

    init {
        val dao = NotesDatabase.getDataBaseInstance(application.applicationContext).myNotesDao()
        repository = NotesRepository(dao)
    }

    fun addNotes(notes: Notes) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.insertNotes(notes)
        }
    }

    fun getNotes(): LiveData<List<Notes>> = repository.getAllNotes()

    fun getFmcNotes(): LiveData<List<Notes>> = repository.getFmcNotes()

    fun getFaultsNotes(): LiveData<List<Notes>> = repository.getFaultsNotes()

    fun getNmcNotes(): LiveData<List<Notes>> = repository.getNmcNotes()

    fun deleteNotes(id: Int) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.deleteNotes(id)
        }
    }

    fun updateNotes(notes: Notes) {
        viewModelScope.launch(Dispatchers.IO) {
            repository.updateNotes(notes)
        }
    }
}

NotesRepository.kt

package davis.cameron.maintenanceapp.Repository

import androidx.lifecycle.LiveData
import davis.cameron.maintenanceapp.Dao.NotesDao
import davis.cameron.maintenanceapp.Models.Notes
import kotlinx.coroutines.Dispatchers
import kotlinx.coroutines.withContext

class NotesRepository(private val dao: NotesDao) {

    // LiveData queries can be executed on the main thread
    fun getAllNotes(): LiveData<List<Notes>> = dao.getNotes()

    fun getFmcNotes(): LiveData<List<Notes>> = dao.getFmcNotes()

    fun getFaultsNotes(): LiveData<List<Notes>> = dao.getFaultsNotes()

    fun getNmcNotes(): LiveData<List<Notes>> = dao.getNmcNotes()

    // Asynchronous database operations
    suspend fun insertNotes(notes: Notes) {
        withContext(Dispatchers.IO) {
            dao.insertNotes(notes)
        }
    }

    suspend fun deleteNotes(id: Int) {
        withContext(Dispatchers.IO) {
            dao.deleteNotes(id)
        }
    }

    suspend fun updateNotes(notes: Notes) {
        withContext(Dispatchers.IO) {
            dao.updateNotes(notes)
        }
    }
}

Notes.kt

package davis.cameron.maintenanceapp.Models

import android.os.Parcelable
import androidx.room.Entity
import androidx.room.PrimaryKey
import kotlinx.parcelize.Parcelize

@Parcelize
@Entity(tableName = "Notes")
data class Notes(
    @PrimaryKey(autoGenerate = true)
    var id: Int,
    var bumperNumber: String,
    var equipmentType: String,
    var model: String,
    var serialNumber: String,
    var serviceDate: String,
    var priority: String,
    var date: String
) : Parcelable

nav_graph.xml

<?xml version="1.0" encoding="utf-8"?>
<navigation xmlns:android="http://schemas.android.com/apk/res/android"
    xmlns:app="http://schemas.android.com/apk/res-auto"
    xmlns:tools="http://schemas.android.com/tools"
    android:id="@+id/nav_graph"
    app:startDestination="@id/homeFragment">

    <fragment
        android:id="@+id/homeFragment"
        android:name="davis.cameron.maintenanceapp.ui.Fragments.HomeFragment"
        android:label="Notes App"
        tools:layout="@layout/fragment_home" >
        <action
            android:id="@+id/action_homeFragment_to_editNotesFragment"
            app:destination="@id/editNotesFragment" >
            <argument
                android:name="noteId"
                app:argType="integer" />
            <argument
                android:name="data"
                app:argType="davis.cameron.maintenanceapp.Models.Notes" />
        </action>
        <action
            android:id="@+id/action_homeFragment_to_createNotesFragment"
            app:destination="@id/createNotesFragment" />
    </fragment>

    <fragment
        android:id="@+id/createNotesFragment"
        android:name="davis.cameron.maintenanceapp.ui.Fragments.CreateNotesFragment"
        android:label="Add New Notes"
        tools:layout="@layout/fragment_create_notes" >
        <action
            android:id="@+id/action_createNotesFragment_to_homeFragment"
            app:destination="@id/homeFragment" />
    </fragment>

    <fragment
        android:id="@+id/editNotesFragment"
        android:name="davis.cameron.maintenanceapp.ui.Fragments.EditNotesFragment"
        android:label="Edit Notes"
        tools:layout="@layout/fragment_edit_notes">
        <argument
            android:name="noteId"
            app:argType="integer" />
        <argument
            android:name="data"
            app:argType="davis.cameron.maintenanceapp.Models.Notes" />
        <action
            android:id="@+id/action_editNotesFragment_to_homeFragment"
            app:destination="@id/homeFragment">

            <argument
                android:name="noteId"
                app:argType="integer" />
            <argument
                android:name="data"
                app:argType="davis.cameron.maintenanceapp.Models.Notes" />
        </action>
    </fragment>
</navigation>

ServiceTrackerActivity.kt

package davis.cameron.maintenanceapp

import android.os.Bundle
import androidx.appcompat.app.AppCompatActivity
import androidx.navigation.NavController
import androidx.navigation.fragment.NavHostFragment
import androidx.navigation.ui.setupActionBarWithNavController
import davis.cameron.maintenanceapp.databinding.ActivityServiceTrackerBinding

class ServiceTrackerActivity : AppCompatActivity() {

    private lateinit var binding: ActivityServiceTrackerBinding
    private lateinit var navController: NavController

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityServiceTrackerBinding.inflate(layoutInflater)
        setContentView(binding.root)

        val navHostFragment = supportFragmentManager
            .findFragmentById(R.id.fragmentContainerView) as NavHostFragment
        navController = navHostFragment.navController

        setupActionBarWithNavController(navController)
    }

    override fun onSupportNavigateUp(): Boolean {
        return navController.navigateUp() || super.onSupportNavigateUp()
    }
}