Hoe roep je de activiteitsmethode aan vanuit een…

Er zijn verschillende manieren om de activiteitsmethode vanuit een fragment aan te roepen, afhankelijk van de situatie en architectuur:

Via een verwijzing naar de activiteit:

Het fragment kan een directe verwijzing krijgen naar de activiteit waarmee het verbonden is.
```
// Binnen het fragment
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
Deze methode is eenvoudig, maar creëert een sterke afhankelijkheid tussen het fragment en een specifieke activiteit.

Via een callback-interface:

Dit is een flexibelere en aanbevolen methode. Er wordt een interface in het fragment gedefinieerd, die de activiteit moet implementeren.

// Binnen het fragment
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 moet OnYourActivityMethodListener implementeren")
    }
}

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

// Methode om de activiteit aan te roepen vanuit het fragment
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// Binnen de activiteit
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // Logica die in de activiteit moet worden uitgevoerd
    }

    // ... overige code van de activiteit
}

Deze aanpak maakt het fragment herbruikbaarder, omdat het afhankelijk is van een contract (interface), niet van een specifieke activiteitklasse.

Via ViewModel (aanbevolen voor complexere interacties):

Het gebruik van een gedeelde ViewModel tussen fragment en activiteit stelt hen in staat gegevens en gebeurtenissen uit te wisselen zonder directe verwijzingen naar elkaar.

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

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

// Wrapper klasse voor LiveData om eenmalige gebeurtenissen te verwerken
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // Externe lezing mogelijk, schrijven niet

    /**
     * Geeft de inhoud terug en voorkomt dat deze opnieuw wordt gebruikt.
     */
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    /**
     * Geeft de inhoud terug, zelfs als deze al is afgehandeld.
     */
    fun peekContent(): T = content
}

// Binnen het fragment
private val sharedViewModel: SharedViewModel by activityViewModels() // Gebruik van activityViewModels()

// Methode om de activiteit aan te roepen via ViewModel
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// Binnen de activiteit
private val sharedViewModel: SharedViewModel by viewModels()

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

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // Logica die in de activiteit moet worden uitgevoerd
        }
    })
}

Deze aanpak voldoet aan de aanbevelingen van architectuurcomponenten en vergemakkelijkt testen.

De keuze van methode hangt af van de complexiteit van de interactie. Voor eenvoudige gevallen is directe aanroep of interface voldoende. Voor complexere scenario's, vooral bij gegevensoverdracht, is het gebruik van ViewModel aan te bevelen.

Hoe roep je de activiteitsmethode aan vanuit een fragment?