Bir fragmentten aktivite metodunu nasıl çağırırsınız…

Bir fragmentten aktivitenin metodunu çağırmanın birkaç yolu vardır, duruma ve mimariye bağlı olarak:

Aktivite referansı aracılığıyla:

Fragment, bağlı olduğu aktiviteye doğrudan bir referans alabilir.
```
// Fragment içinde
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
Bu yöntem basittir, ancak fragment ile belirli bir aktivite arasında güçlü bir bağımlılık oluşturur.

Geri çağrı arayüzü (Callback Interface) aracılığıyla:

Bu, daha esnek ve önerilen bir yoldur. Fragmentte bir arayüz tanımlanır ve aktivitenin bunu uygulaması gerekir.

// Fragment içinde
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 OnYourActivityMethodListener'ı uygulamalı")
    }
}

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

// Aktivite metodunu fragmentten çağırma
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// Aktivitede
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // Aktivitede çalıştırılacak mantık
    }

    // ... aktivitenin diğer kodları
}

Bu yaklaşım, fragmenti daha yeniden kullanılabilir yapar çünkü sözleşmeye (arayüze) dayanır, belirli bir aktivite sınıfına değil.

ViewModel aracılığıyla (daha karmaşık etkileşimler için önerilir):

Fragment ve aktivite arasında ortak bir ViewModel kullanmak, doğrudan referanslar olmadan veri ve olay alışverişi yapmalarını sağlar.

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

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

// Tek seferlik olaylar için LiveData sarmal sınıfı
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // Dışarıdan okunabilir, yazılamaz

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

    fun peekContent(): T = content
}

// Fragment içinde
private val sharedViewModel: SharedViewModel by activityViewModels() // activityViewModels() kullanılır

// ViewModel aracılığıyla aktivite metodunu çağır
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// Aktivitede
private val sharedViewModel: SharedViewModel by viewModels()

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

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // Aktivitede çalıştırılacak mantık
        }
    })
}

Bu yaklaşım, mimari bileşenlerin önerilerine uygundur ve test etmeyi kolaylaştırır.

Yöntem seçimi, etkileşimin karmaşıklığına bağlıdır. Basit durumlar için doğrudan çağrı veya arayüz yeterlidir. Daha karmaşık senaryolar, özellikle veri iletimi söz konusuysa, ViewModel kullanmak tercih edilir.

Bir fragmentten aktivite metodunu nasıl çağırırsınız?