Fragmentdan faoliyat metodini qanday chaqirish…

Fragmentdan faoliyat usulini chaqirishning bir nechta usuli mavjud, vaziyat va arxitekturaga qarab:

Faoliyatga havola orqali:

Fragment unga biriktirilgan faoliyatga to'g'ridan-to'g'ri havola olishi mumkin.
```
// Fragment ichida
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
Bu usul oddiy, lekin fragment va aniq faoliyat o'rtasida kuchli bog'liqlik yaratadi.

Callback interfeysi orqali:

Bu yanada moslashuvchan va tavsiya etilgan usul. Fragmentda interfeys aniqlanadi, uni faoliyat amalga oshirishi kerak.

// Fragment ichida
interface OnYourActivityMethodListener {
    fun onYourActivityMethodCalled()
}

private var listener: OnYourActivityMethodListener? = null

override fun onAttach(context: Context) {
    super.onAttach(context)
    if (context is OnYourActivityMethodListener) {
        listener = context
    } else {
        throw RuntimeException("$context OnYourActivityMethodListener ni amalga oshirmoqda")
    }
}

override fun onDetach() {
    super.onDetach()
    listener = null
}

// Fragmentdan faoliyat metodini chaqirish
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// Faoliyat ichida
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // Faoliyatda bajariladigan mantiq
    }

    // ... faoliyat kodining qolgan qismi
}

Bu yondashuv fragmentni qayta ishlatishni osonlashtiradi, chunki u shartnoma (interfeys) ga bog'liq, faoliyatning aniq sinfiga emas.

ViewModel orqali (kengash uchun tavsiya etiladi):

Fragment va faoliyat o'rtasida umumiy ViewModeldan foydalanish, ularning to'g'ridan-to'g'ri havolalarisiz ma'lumotlar va voqealarni almashish imkonini beradi.

// Umumiy ViewModel
class SharedViewModel : ViewModel() {
    private val _callActivityMethodEvent = MutableLiveData<Event<Unit>>()
    val callActivityMethodEvent: LiveData<Event<Unit>> = _callActivityMethodEvent

    fun triggerActivityMethod() {
        _callActivityMethodEvent.value = Event(Unit)
    }
}

// Bir martalik voqealarni boshqarish uchun LiveData uchun qadoqlash sinfi
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // Tashqaridan o'qish mumkin, yozish mumkin emas

    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    fun peekContent(): T = content
}

// Fragment ichida
private val sharedViewModel: SharedViewModel by activityViewModels() // activityViewModels() dan foydalanamiz

// ViewModel orqali faoliyat metodini chaqirish
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// Faoliyat ichida
private val sharedViewModel: SharedViewModel by viewModels()

override fun onCreate(savedInstanceState: Bundle?) {
    super.onCreate(savedInstanceState)
    // ...

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // Faoliyatda bajariladigan mantiq
        }
    })
}

Bu yondashuv arxitektura komponentlarining tavsiyalariga mos keladi va test qilishni osonlashtiradi.

Usul tanlovi, o'zaro ta'sirning murakkabligiga bog'liq. Oddiy holatlar uchun to'g'ridan-to'g'ri chaqirish yoki interfeys etarli. Ko'proq murakkab ssenariylar uchun, ayniqsa ma'lumotlarni uzatishda, ViewModeldan foydalanish afzaldir.

Fragmentdan faoliyat metodini qanday chaqirish mumkin?