Ինչպես կանչել ակտիվության մեթոդը ֆրագմենտից?

Կան մի քանի եղանակներ՝ ակտիվության մեթոդը ֆրագմենտից կանչելու համար՝ կախված իրավիճակից և ճարտարապետությունից:

Անհատական կապով՝ ակտիվության հետ:

Ֆրագմենտը կարող է ստանալ ուղիղ հղում այն ակտիվությանը, որի հետ կապված է:
```
// Ֆրագմենտի ներսում
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
Այս մեթոդը պարզ է, բայց ստեղծում է ուժեղ կախվածություն ֆրագմենտի և կոնկրետ ակտիվության միջև:

Հետադարձ կապի ինտերֆեյսի միջոցով:

Սա ավելի ճկուն և խորհուրդ է տրվում։ Ֆրագմենտում սահմանվում է ինտերֆեյս, որը պետք է իրականացնել ակտիվությունը:

// Ֆրագմենտի ներսում
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 must implement OnYourActivityMethodListener")
    }
}

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

// Ֆրագմենտից ակտիվության մեթոդի կանչում
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// Ակտիվության ներսում
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // Լոգիկա՝ որը պետք է կատարվի ակտիվությունում
    }

    // ... մնացյալ կոդը
}

Այս մոտեցումը դարձնում է ֆրագմենտը ավելի վերօգտագործելի, քանի որ այն կախված է պայմանագրից (ինտերֆեյսից), ոչ թե կոնկրետ ակտիվության դասից:

ViewModel-ով (առաջարկվում է ավելի բարդ փոխազդեցությունների համար):

Համատեղ ViewModel- ի օգտագործումը ֆրագմենտի և ակտիվության միջև թույլ է տալիս փոխանակել տվյալներ և իրադարձություններ՝ առանց ուղիղ հղումների:

// Ընդհանուր ViewModel
class SharedViewModel : ViewModel() {
    private val _callActivityMethodEvent = MutableLiveData<Event<Unit>>()
    val callActivityMethodEvent: LiveData<Event<Unit>> = _callActivityMethodEvent

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

// Օղակաձև կլասս՝ մեկանգամյա իրադարձությունների համար
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // Դրսից կարդալ, բայց չգրել

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

    fun peekContent(): T = content
}

// Ֆրագմենտի ներսում
private val sharedViewModel: SharedViewModel by activityViewModels() // Օգտագործում ենք activityViewModels()

// Ակտիվության մեթոդի կանչում ViewModel-ով
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// Ակտիվության ներսում
private val sharedViewModel: SharedViewModel by viewModels()

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

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // Լոգիկա՝ որը պետք է կատարվի ակտիվությունում
        }
    })
}

Այս մոտեցումը համապատասխանում է ճարտարապետական կոմպոնենտների առաջարկություններին և հեշտացնում է թեստավորումը:

Ընտրությունը կախված է փոխազդեցության բարդությունից։ Պարզ դեպքերում հարմար է ուղիղ կանչը կամ ինտերֆեյսը։ Ավելի բարդ սցենարների համար, հատկապես տվյալների փոխանցման հետ կապված, ավելի լավ է օգտագործել ViewModel։