Jak wywołać metodę aktywności z fragmentu?

Istnieje kilka sposobów wywołania metody aktywności z fragmentu, w zależności od sytuacji i architektury:

1. Przez odniesienie do aktywności:

   Fragment może uzyskać bezpośrednie odniesienie do aktywności, do której jest dołączony.

   // Wewnątrz fragmentu
   if (activity is YourActivity) {
       (activity as YourActivity).yourActivityMethod()
   }
   

   Ten sposób jest prosty, ale tworzy silną zależność między fragmentem a konkretną aktywnością.

2. Przez interfejs zwrotny (Callback Interface):

   Jest to bardziej elastyczny i zalecany sposób. Definiuje się interfejs wewnątrz fragmentu, który musi zaimplementować aktywność.

   // Wewnątrz fragmentu
   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 musi implementować OnYourActivityMethodListener")
       }
   }
   
   override fun onDetach() {
       super.onDetach()
       listener = null
   }
   
   // Wywołanie metody aktywności z fragmentu
   fun callActivityMethod() {
       listener?.onYourActivityMethodCalled()
   }
   

   // W aktywności
   class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {
   
       override fun onYourActivityMethodCalled() {
           // Logika do wykonania w aktywności
       }
   
       // ... reszta kodu aktywności
   }
   

   To podejście czyni fragment bardziej wielokrotnego użytku, ponieważ zależy od kontraktu (interfejsu), a nie od konkretnej klasy aktywności.

3. Przez ViewModel (zalecane dla bardziej złożonych interakcji):

   Użycie wspólnego ViewModel pomiędzy fragmentem a aktywnością pozwala na wymianę danych i zdarzeń bez bezpośrednich odniesień.

   // Wspólny ViewModel
   class SharedViewModel : ViewModel() {
       private val _callActivityMethodEvent = MutableLiveData<Event<Unit>>()
       val callActivityMethodEvent: LiveData<Event<Unit>> = _callActivityMethodEvent
   
       fun triggerActivityMethod() {
           _callActivityMethodEvent.value = Event(Unit)
       }
   }
   
   // Klasa opakowująca dla LiveData do obsługi zdarzeń jednostkowych
   open class Event<out T>(private val content: T) {
       var hasBeenHandled = false
           private set // Pozwala na odczyt z zewnątrz, ale nie zapis
   
       fun getContentIfNotHandled(): T? {
           return if (hasBeenHandled) {
               null
           } else {
               hasBeenHandled = true
               content
           }
       }
   
       fun peekContent(): T = content
   }
   

   // Wewnątrz fragmentu
   private val sharedViewModel: SharedViewModel by activityViewModels() // Używamy activityViewModels()
   
   // Wywołanie metody aktywności przez ViewModel
   fun callActivityMethod() {
       sharedViewModel.triggerActivityMethod()
   }
   

   // W aktywności
   private val sharedViewModel: SharedViewModel by viewModels()
   
   override fun onCreate(savedInstanceState: Bundle?) {
       super.onCreate(savedInstanceState)
       // ...
   
       sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
           event.getContentIfNotHandled()?.let {
               // Logika do wykonania w aktywności
           }
       })
   }
   

   Ten sposób jest zgodny z zaleceniami komponentów architektonicznych i ułatwia testowanie.

Wybór metody zależy od złożoności interakcji. Dla prostych przypadków wystarczy bezpośredni wywołanie lub interfejs. Dla bardziej złożonych scenariuszy, szczególnie związanych z przesyłaniem danych, lepiej używać ViewModel.