Kaip teisingai organizuoti darbą su naudotojo sąsaja…

Android naudotojo sąsajos darbo organizavimui turite laikytis Google architektūros principų ir rekomendacijų.

Pagrindiniai komponentai ir požiūriai:

Activity/Fragment: yra įėjimo taškai naudotojo sąveikai, juose yra vaizdo logika (View).

View Binding/Data Binding: mechanizmai saugesniam ir patogesniam prieigai prie UI elementų, sumažina kodo kiekį ir galimas klaidas. View Binding rekomenduojama paprastiems atvejams, Data Binding – sudėtingesniems scenarijams su duomenų ryšiu tiesiogiai prie maketo.

<!-- res/layout/activity_main.xml (pavyzdys su 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 (pavyzdys su 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: Android architektūros komponentas, atsakingas už duomenų saugojimą ir valdymą UI specifiniu būdu, atsižvelgiant į gyvavimo ciklą. Išgyvena Activity konfigūracijos keitimą, išvengia duomenų praradimo.

// 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: stebimi duomenų laikikliai, integruoti su Android gyvavimo ciklu. Leidžia UI automatiškai atnaujinti duomenų pokyčius be atminties nutekėjimų. Dažnai naudojama su ViewModel. StateFlow ir Flow (iš Kotlin Coroutines) siūlo galingesnes reaktyvaus programavimo galimybes.

Pavyzdys naudojant LiveData su ViewModel:

// MainActivity.kt (tęsinys, su ViewModel ir 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()
        }
    }
}

Architektūros modeliai (MVVM, MVI): skiria atsakomybę tarp komponentų. MVVM (Model-View-ViewModel) yra labiausiai rekomenduojamas Google, kur View stebi pokyčius ViewModel, o ViewModel sąveikauja su Model (duomenų šaltiniais). MVI (Model-View-Intent) – alternatyvus požiūris, pagrįstas vienpusišku duomenų srautu.

UI įrankių rinkinys (View System arba Jetpack Compose): View System – tradicinė imperatyvi UI sistema. Jetpack Compose – modernus deklaratyvus UI įrankis, palengvinantis sudėtingų sąsajų kūrimą.

// Pavyzdys su 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")
}

Srautų valdymas: visi UI operacijos turi būti vykdomi pagrindiniame (UI) sraute. Ilgalaikės operacijos (tinklo užklausos, duomenų bazės darbai) turi būti perkeltos į foninius srautus (pvz., naudojant Coroutines, RxJava ar standartinius ExecutorService) ir rezultatų grąžinimas į pagrindinį srautą UI atnaujinimui.

// Coroutines pavyzdys
import kotlinx.coroutines.*

class MyRepository {
    suspend fun fetchData(): String = withContext(Dispatchers.IO) {
        // Ilgalaikės operacijos imitacija
        delay(1000)
        "Data from background"
    }
}

// ViewModel arba Activity/Fragment (bet pageidautina ViewModel)
fun loadData() {
    viewModelScope.launch { // Arba lifecycleScope Activity/Fragment
        val data = MyRepository().fetchData()
        // UI stebimo LiveData atnaujinimas
        _dataLiveData.value = data
    }
}

Įvykių apdorojimas: įvykių klausytojų (mygtukų paspaudimų, teksto įvedimo) įgyvendinimas Activity/Fragment ar View, verslo logikos perdavimas į ViewModel.
Būsenos valdymas: naudojant ViewModel, StateFlow ar MutableState (Compose) saugiam ir prognozuojamam UI būsenos valdymui.

Laikantis šių principų padeda kurti mastelinius, palaikomus ir klaidų atsparius taikomus sprendimus. Konkretūs įrankiai (View System vs Compose, LiveData vs StateFlow) pasirinkimas priklauso nuo projekto ir komandos pageidavimų. Google aktyviai skatina Jetpack Compose ir Kotlin Coroutines. Android architektūros komponentų naudojimas (ViewModel, LiveData, Room) yra standartas.

Kaip teisingai organizuoti darbą su naudotojo sąsaja Android?