Kako pravilno organizovati rad sa korisničkim…

Za organizaciju rada sa korisničkim interfejsom na Androidu, treba slediti principe arhitekture i preporuke Google-a.

Glavni sastavni delovi i pristupi:

Activity/Fragment: Predstavljaju tačke ulaska za korisničku interakciju, sadrže logiku prikaza (View).

View Binding/Data Binding: Mehanizmi za sigurniji i jednostavniji pristup elementima UI, smanjujući količinu koda i potencijalne greške. View Binding se preporučuje za jednostavne slučajeve, Data Binding za složenije scenarije sa direktnim vezivanjem podataka u markup.

<!-- res/layout/activity_main.xml (primer sa View Binding) -->
<LinearLayout
    xmlns:android="http://schemas.android.com/apk/res/android"
    android:layout_width="match_parent"
    android:layout_height="match_parent"
    android:orientation="vertical">

    <TextView
        android:id="@+id/textViewHello"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Hello, World!" />

    <Button
        android:id="@+id/buttonClick"
        android:layout_width="wrap_content"
        android:layout_height="wrap_content"
        android:text="Click Me" />
</LinearLayout>

// MainActivity.kt (primer sa View Binding)
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import com.example.myapp.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        binding.buttonClick.setOnClickListener {
            binding.textViewHello.text = "Button Clicked!"
        }
    }
}

ViewModel: Komponent iz Android Architecture Components, zadužen za čuvanje i upravljanje podacima UI-specifično na osnovu životnog ciklusa. Preživljava promenu konfiguracije Activity, sprečavajući gubitak podataka.

// MyViewModel.kt
import androidx.lifecycle.MutableLiveData
import androidx.lifecycle.ViewModel

class MyViewModel : ViewModel() {
    val counter = MutableLiveData<Int>().apply { value = 0 }

    fun incrementCounter() {
        counter.value = (counter.value ?: 0) + 1
    }
}

LiveData/StateFlow/Flow: Promenljive koje prate podatke i integrišu se sa životnim ciklusom Android-a. Omogućavaju automatsko osvežavanje UI pri promeni podataka bez curenja memorije. LiveData se često koristi sa ViewModel-om. StateFlow i Flow (iz Kotlin Coroutines) pružaju moćnije funkcionalnosti za reaktivno programiranje.

Primer korišćenja LiveData sa ViewModel-om:

// MainActivity.kt (nastavak, sa ViewModel i LiveData)
import androidx.appcompat.app.AppCompatActivity
import android.os.Bundle
import androidx.activity.viewModels
import androidx.lifecycle.Observer
import com.example.myapp.databinding.ActivityMainBinding

class MainActivity : AppCompatActivity() {

    private lateinit var binding: ActivityMainBinding
    private val viewModel: MyViewModel by viewModels()

    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        binding = ActivityMainBinding.inflate(layoutInflater)
        setContentView(binding.root)

        viewModel.counter.observe(this, Observer { count ->
            binding.textViewHello.text = "Counter: $count"
        })

        binding.buttonClick.setOnClickListener {
            viewModel.incrementCounter()
        }
    }
}

Arhitektonski obrasci (MVVM, MVI): Razlikuju odgovornosti između komponenti. MVVM (Model-View-ViewModel) je najpreporučljiviji od Google-a, gde View prati promene u ViewModel-u, a ViewModel komunicira sa Model-om (izvori podataka). MVI (Model-View-Intent) je alternativni pristup zasnovan na jednostranom toku podataka.

UI Toolkit (View System ili Jetpack Compose): View System je tradicionalni imperativni UI sistem. Jetpack Compose je savremeni deklarativni UI alat koji pojednostavljuje kreiranje složenih interfejsa.

// Primer sa Jetpack Compose
import android.os.Bundle
import androidx.activity.ComponentActivity
import androidx.activity.compose.setContent
import androidx.compose.foundation.layout.Column
import androidx.compose.material.Button
import androidx.compose.material.Text
import androidx.compose.runtime.*
import androidx.compose.ui.graphics.Color
import androidx.compose.ui.tooling.preview.Preview

class ComposeActivity : ComponentActivity() {
    override fun onCreate(savedInstanceState: Bundle?) {
        super.onCreate(savedInstanceState)
        setContent {
            Greeting("Compose World")
        }
    }
}

@Composable
fun Greeting(name: String) {
    var count by remember { mutableStateOf(0) }

    Column {
        Text(text = "Hello $name! Counter: $count")
        Button(onClick = { count++ }) {
            Text("Increment")
        }
    }
}

@Preview(showBackground = true)
@Composable
fun DefaultPreview() {
    Greeting("Compose Preview")
}

Rad sa tokovima: Sve operacije sa UI treba da se obavljaju u glavnom (UI) thread-u. Dugotrajne operacije (mrežni zahtevi, rad sa bazom podataka) treba da se prebace u pozadinske thread-ove (npr. korišćenjem Coroutines, RxJava ili standardnih ExecutorService) i rezultate vratiti u glavni thread za ažuriranje UI.

// Primer sa Coroutines
import kotlinx.coroutines.*

class MyRepository {
    suspend fun fetchData(): String = withContext(Dispatchers.IO) {
        // Simulacija dugotrajne operacije
        delay(1000)
        "Data from background"
    }
}

// U ViewModel ili Activity/Fragment (ali je preporučljivo u ViewModel-u)
fun loadData() {
    viewModelScope.launch { // Ili lifecycleScope za Activity/Fragment
        val data = MyRepository().fetchData()
        // Ažuriranje LiveData koja se prati u UI
        _dataLiveData.value = data
    }
}

Obrada događaja: Implementacija slušalaca događaja (klikovi na dugmad, unos teksta) u Activity/Fragment ili View, delegiranje poslovne logike u ViewModel.
Upravljanje stanjem: Korišćenje ViewModel, StateFlow ili MutableState (u Compose-u) za sigurno i predvidljivo upravljanje stanjem UI.

Poštovanje ovih principa pomaže u pravljenju skalabilnih, održivih i otpornijih aplikacija. Izbor konkretnih alata (View System vs Compose, LiveData vs StateFlow) zavisi od projekta i preferencija tima. Google aktivno promoviše Jetpack Compose i Kotlin Coroutines. Korišćenje Android Architecture Components (ViewModel, LiveData, Room) je standard.

Kako pravilno organizovati rad sa korisničkim interfejsom na Androidu?