Comment appeler la méthode d'activité depuis un…

Il existe plusieurs façons d'appeler la méthode d'une activité depuis un fragment, en fonction de la situation et de l'architecture :

Via une référence à l'activité :

Le fragment peut obtenir une référence directe à l'activité à laquelle il est attaché.
```
// Dans le fragment
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
Cette méthode est simple, mais crée une dépendance forte entre le fragment et une activité spécifique.

Via une interface de rappel (Callback Interface) :

C'est une méthode plus flexible et recommandée. Une interface est définie dans le fragment, que l'activité doit implémenter.

// Dans le 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 doit implémenter OnYourActivityMethodListener")
    }
}

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

// Appel de la méthode de l'activité depuis le fragment
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// Dans l'activité
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // Logique à exécuter dans l'activité
    }

    // ... reste du code de l'activité
}

Cette approche rend le fragment plus réutilisable, car il dépend du contrat (interface), et non d'une classe d'activité spécifique.

Via ViewModel (recommandé pour des interactions plus complexes) :

L'utilisation d'un ViewModel partagé entre le fragment et l'activité leur permet d'échanger des données et des événements sans références directes.

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

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

// Classe d'enveloppe pour LiveData pour gérer les événements à usage unique
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // Permet la lecture externe mais pas l'écriture

    /**
     * Retourne le contenu et empêche son utilisation à nouveau.
     */
    fun getContentIfNotHandled(): T? {
        return if (hasBeenHandled) {
            null
        } else {
            hasBeenHandled = true
            content
        }
    }

    /**
     * Retourne le contenu même s'il a déjà été traité.
     */
    fun peekContent(): T = content
}

// Dans le fragment
private val sharedViewModel: SharedViewModel by activityViewModels() // Utilise activityViewModels()

// Appel de la méthode de l'activité via le ViewModel
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// Dans l'activité
private val sharedViewModel: SharedViewModel by viewModels()

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

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // Logique à exécuter dans l'activité
        }
    })
}

Cette approche est conforme aux recommandations des composants architecturaux et facilite les tests.

Le choix de la méthode dépend de la complexité de l'interaction. Pour des cas simples, une invocation directe ou une interface suffisent. Pour des scénarios plus complexes, notamment liés au transfert de données, il est préférable d'utiliser ViewModel.

Comment appeler la méthode d'activité depuis un fragment ?