Почему запрос к серверу выполняется только один раз? (android)

При переходе на другой фрагмент я отправляю запрос на сервер и получаю ответ. При первом переходе всё работает корректно, но если вернуться назад и снова попытаться открыть тот же фрагмент, запрос больше не отправляется. В чём может быть причина?

class PacketNegotiationDetailFragment : BaseFragment(), PacketNegotiationDetailView {

    private lateinit var binding: FragmentPacketNegotiationDetailBinding

    private lateinit var navController: NavController
    private var currentPacket: PacketNegotiation? = null

    @Inject
    @InjectPresenter
    lateinit var presenter: PacketNegotiationDetailPresenter

    override fun onAttach(context: Context) {
        super.onAttach(context)
        App.getApp(activity?.applicationContext).getComponentsHolder()
            .getComponent(javaClass)
            .inject(this)
    }

    override fun onCreateView(
        inflater: LayoutInflater,
        container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentPacketNegotiationDetailBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)
        setupNavigation()
        setupClickListeners()
        loadPacketData()
    }

    override fun onDetach() {
        super.onDetach()
        App.getApp(activity?.applicationContext).getComponentsHolder()
            .releaseComponent(javaClass)
    }

    private fun setupNavigation() {
        navController = Navigation.findNavController(binding.root)
    }

    private fun setupClickListeners() {
        binding.apply {
            btnBack.setOnClickListener { navController.popBackStack() }
            popupMenu.setOnClickListener { showPopupMenu(it) }
        }
    }

    private fun loadPacketData() {
        arguments?.getInt(KET_PACKET_NEGOTIATION_ID)?.takeIf { it != -1 }?.let { packetId ->
            presenter.loadPacketNegotiationDetail(packetId)
        } ?: navController.popBackStack()
    }

    override fun showPacketDetails(packet: PacketNegotiation) {
        currentPacket = packet
        binding.apply {
            this.packet = packet
            updateTextColor(packet.maxPackChangeSnm)
            executePendingBindings()
        }
    }

    override fun showProgress() {
        binding.progressBar.visibility = View.VISIBLE
    }

    override fun hideProgress() {
        binding.progressBar.visibility = View.INVISIBLE
    }

    private fun updateTextColor(maxPackChangeSnm: String?) {
        val context = context ?: return
        val colorRes = when (maxPackChangeSnm) {
            context.getString(R.string.rework) -> R.color.colorPacChangeRevision
            else -> R.color.colorPacChangeError
        }
        binding.tvTaskMaxPackChangeValue.setTextColor(
            ContextCompat.getColor(context, colorRes)
        )
    }

    private fun showPopupMenu(view: View) {
        val packet = currentPacket ?: return

        PopupMenu(requireContext(), view).apply {
            menuInflater.inflate(R.menu.popup_menu, menu)

            configureMenuItems(packet)
            setOnMenuItemClickListener { onMenuItemClick(it, packet) }

            show()
        }
    }

    private fun PopupMenu.configureMenuItems(packet: PacketNegotiation) {
        menu.findItem(R.id.packet_negotiation)?.let { item ->
            if (packet.isSigned == 1) {
                item.title = getString(R.string.no_packet_negotiation_text)
            }
        }
    }

    private fun onMenuItemClick(item: android.view.MenuItem, packet: PacketNegotiation): Boolean {
        return when (item.itemId) {
            R.id.packet_negotiation -> {
                handlePacketNegotiation(packet)
                true
            }

            R.id.package_content -> {
                val args = Bundle().apply { putInt(PreferencesConstants.PACK_ID, packet.packId) }
                navController.navigate(
                    R.id.action_packetNegotiationDetailsFragment_to_packetNegotiationContentFragment,
                    args
                )
                true
            }

            R.id.package_base -> {
                true
            }

            else -> false
        }
    }

    private fun handlePacketNegotiation(packet: PacketNegotiation) {
        presenter.updatePacketSigned(
            functionId = FunctionsConstants.PACKAGE_RECONCILIATION,
            sboName = SboName.DEV_PACK_CURATORS,
            packId = packet.packId.toString(),
            urcCurator = packet.urcCurator.toString(),
            urcSignTime = packet.urcSignTime
        )
    }

    @ProvidePresenter
    fun providePresenter(): PacketNegotiationDetailPresenter = presenter
}

    class PacketContentFragment : BaseFragment(), PacketContentView {

    private lateinit var binding: FragmentPacketContentBinding

    private lateinit var navController: NavController

    @Inject
    @InjectPresenter
    lateinit var presenter: PacketContentPresenter

    @ProvidePresenter
    fun providePresenter(): PacketContentPresenter = presenter

    override fun onAttach(context: Context) {
        super.onAttach(context)
        App.getApp(activity?.applicationContext).getComponentsHolder().getComponent(javaClass)
            .inject(this)
    }

    override fun onCreateView(
        inflater: LayoutInflater, container: ViewGroup?,
        savedInstanceState: Bundle?
    ): View {
        binding = FragmentPacketContentBinding.inflate(inflater, container, false)
        return binding.root
    }

    override fun onViewCreated(view: View, savedInstanceState: Bundle?) {
        super.onViewCreated(view, savedInstanceState)

        val id = arguments?.getInt(PreferencesConstants.PACK_ID, -1) ?: -1
        navController = Navigation.findNavController(binding.root)
        binding.btnMenu.setOnClickListener { navController.popBackStack() }
        presenter.packId = id
    }

    override fun showProgress() {
        binding.progressBar.visibility = View.VISIBLE
    }

    override fun hideProgress() {
        binding.progressBar.visibility = View.INVISIBLE
    }}



    @InjectViewState
    class PacketContentPresenter(private val interactor: PacketContentInteractor):
    ) : BasePresenter<PacketContentView>() {

    private var _packId = -1
    var packId: Int
        get() = _packId
        set(value) {
            _packId = value
            loadPackets()
        }

    private fun loadPackets() {
        viewState.showProgress()
        subscription.add(
            interactor.loadPacket(PACKAGE_RECONCILIATION, packId)
                .subscribe({
                    viewState.hideProgress()
                }, {})
        )
    }
}

    class PacketContentRepositoryImpl(
    private val api: FunctionsApi,
    private val dao: PacketContentDao,
    private val mapper: PacketContentMapper
) : PacketContentRepository {

    override fun loadPacketContent(
        functionSession: String,
        id: Int,
        applicationCode: String,
        applicationVersion: String,
        packId: Int
    ): Single<List<PacketContent>> {
        val filterList = mutableListOf<Filter>().apply {
            add(Filter(PACK_ID, equals_params, packId.toString()))
        }
        val requestBody = GettingDataRequest(
            sessionId = functionSession,
            functionId = id,
            name = DEV_PACK_CONTENT,
            order = emptyList(),
            filter = filterList,
            reqlist = emptyList()
        )

        return api.getData(requestBody)
            .map { response ->
                val packetContent = mutableListOf<PacketContent>()

                response.values.forEach {
                    val packetContentItem = mapper.fromSchemaToEntity(it)
                    packetContent.add(packetContentItem as PacketContent)
                }
                packetContent.toList()
            }
    }
}