Kā izsaukt aktivitātes metodi no fragmenta?

Ir vairākas veidi, kā izsaukt aktivitātes metodi no fragmenta, atkarībā no situācijas un arhitektūras:

1. Caur saiti uz aktivitāti:

   Fragments var iegūt tiešu saiti uz aktivitāti, ar kuru tas ir saistīts.

   // Fragmenta iekšpusē
   if (activity is YourActivity) {
       (activity as YourActivity).yourActivityMethod()
   }
   

   Šis veids ir vienkāršs, bet rada stipru atkarību starp fragmentu un konkrēto aktivitāti.

2. Caur atpakaļzvanu interfeisu (Callback Interface):

   Tas ir elastīgāks un ieteicams veids. Fragmentā tiek definēts interfeiss, ko aktivitāte ir jārealizē.

   // Fragmenta iekšpusē
   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
   }
   
   // Aktivtātes metodes izsaukšana no fragmenta
   fun callActivityMethod() {
       listener?.onYourActivityMethodCalled()
   }
   

   // Aktivitātē
   class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {
   
       override fun onYourActivityMethodCalled() {
           // Logika, kas jāizpilda aktivitātē
       }
   
       // ... pārējais aktivitātes kods
   }
   

   Šī pieeja padara fragmentu vairāk atkārtoti lietojamu, jo tas ir atkarīgs no līguma (saskares), nevis no konkrētas aktivitātes klases.

3. Caur ViewModel (ieteicams sarežģītākām mijiedarbībām):

   Kopīga ViewModel izmantošana starp fragmentu un aktivitāti ļauj tiem apmainīties ar datiem un notikumiem bez tiešām saitēm.

   // Kopīga ViewModel
   class SharedViewModel : ViewModel() {
       private val _callActivityMethodEvent = MutableLiveData<Event<Unit>>()
       val callActivityMethodEvent: LiveData<Event<Unit>> = _callActivityMethodEvent
   
       fun triggerActivityMethod() {
           _callActivityMethodEvent.value = Event(Unit)
       }
   }
   
   // Vienreizējas notikumu apvalks
   open class Event<out T>(private val content: T) {
       var hasBeenHandled = false
           private set // Ārējais lasījums, bet ne rakstīšana
   
       fun getContentIfNotHandled(): T? {
           return if (hasBeenHandled) {
               null
           } else {
               hasBeenHandled = true
               content
           }
       }
   
       fun peekContent(): T = content
   }
   

   // Fragmenta iekšpusē
   private val sharedViewModel: SharedViewModel by activityViewModels() // izmantojam activityViewModels()
   
   // Aktivtātes metodes izsaukšana caur ViewModel
   fun callActivityMethod() {
       sharedViewModel.triggerActivityMethod()
   }
   

   // Aktivitātē
   private val sharedViewModel: SharedViewModel by viewModels()
   
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       // ...
   
       sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
           event.getContentIfNotHandled()?.let {
               // Logika, kas jāizpilda aktivitātē
           }
       })
   }
   

   Šis pieejas veids atbilst arhitektūras komponentu ieteikumiem un atvieglo testēšanu.

Metodes izvēle ir atkarīga no mijiedarbības sarežģītības. Vienkāršiem gadījumiem der tiešs izsaukums vai interfeiss. Sarežģītākiem scenārijiem, īpaši ar datu pārsūtīšanu, labāk ir izmantot ViewModel.