როგორ დავძახოთ აქტივობის მეთოდი ფრაგმენტიდან?

ფრაგმენტიდან აქტივობის მეთოდის გამოძახების რამდენიმე გზა არსებობს, დამოკიდებულია სიტუაციაზე და არქიტექტურაზე:

გადამცემის მეშვეობით:

ფრაგმენტი შეიძლება მიიღოს პირდაპირი მიმთითებელი იმ აქტივობაზე, რომელთანაც ის არის დაკავშირებული.
```
// ფრაგმენტის შიგნით
if (activity is YourActivity) {
    (activity as YourActivity).yourActivityMethod()
}
```
ეს მეთოდი მარტივია, მაგრამ ქმნის ძლიერ დამოკიდებულებას ფრაგმენტის და კონკრეტული აქტივობის შორის.

უკანასკნელი ზარის ინტერფეისის მეშვეობით:

ეს უფრო მოქნილი და რეკომენდებულია. ფრაგმენტში განსაზღვრულია ინტერფეისი, რომელსაც უნდა განახორციელოს აქტივობა.

// ფრაგმენტის შიგნით
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
}

// აქტივობის მეთოდის გამოძახება ფრაგმენტიდან
fun callActivityMethod() {
    listener?.onYourActivityMethodCalled()
}

// აქტივობაში
class YourActivity : AppCompatActivity(), YourFragment.OnYourActivityMethodListener {

    override fun onYourActivityMethodCalled() {
        // ლოგიკა, რომელიც უნდა შესრულდეს აქტივობაში
    }

    // ... სხვა კოდი
}

ეს მიდგომა ხდის ფრაგმენტს უფრო მეორადად გამოყენებად, რადგან ის დამოკიდებულია კონტრაქტზე (ინტერფეისზე), არა კონკრეტულ კლასზე.

ViewModel-ის მეშვეობით (რეკომენდებულია უფრო რთული ურთიერთქმედებისთვის):

საერთო ViewModel-ის გამოყენება ფრაგმენტსა და აქტივობას შორის საშუალებას აძლევს მათ გაცვალონ მონაცემები და მოვლენები, უშუალო კავშირების გარეშე.

// საერთო ViewModel
class SharedViewModel : ViewModel() {
    private val _callActivityMethodEvent = MutableLiveData<Event<Unit>>()
    val callActivityMethodEvent: LiveData<Event<Unit>> = _callActivityMethodEvent

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

// ერთჯერადი მოვლენების პაკეტი
open class Event<out T>(private val content: T) {
    var hasBeenHandled = false
        private set // გარე წაკითხვა, მაგრამ არა წერა

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

    fun peekContent(): T = content
}

// ფრაგმენტის შიგნით
private val sharedViewModel: SharedViewModel by activityViewModels() // გამოყენება activityViewModels()

// აქტივობის მეთოდის გამოძახება ViewModel-ის მეშვეობით
fun callActivityMethod() {
    sharedViewModel.triggerActivityMethod()
}

// აქტივობაში
private val sharedViewModel: SharedViewModel by viewModels()

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

    sharedViewModel.callActivityMethodEvent.observe(this, Observer { event ->
        event.getContentIfNotHandled()?.let {
            // ლოგიკა, რომელიც უნდა შესრულდეს აქტივობაში
        }
    })
}

ეს მიდგომა პასუხობს არქიტექტურული კომპონენტების რეკომენდაციებს და ამარტივებს ტესტირებას.

მეთოდის არჩევანი დამოკიდებულია ურთიერთქმედების სირთულეზე. მარტივ შემთხვევებში საკმარისია პირდაპირი გამოძახება ან ინტერფეისი. უფრო რთული სცენარებისთვის, განსაკუთრებით მონაცემების გადაცემასთან დაკავშირებული, უკეთესია გამოიყენოთ ViewModel.