Jak správně organizovat práci s uživatelským…

Pro organizaci práce s uživatelským rozhraním na Androidu je třeba dodržovat architektonické principy a doporučení Google.

Hlavní komponenty a přístupy:

Activity/Fragment: Jsou vstupními body pro uživatelskou interakci, obsahují logiku zobrazení (View).

View Binding/Data Binding: Mechanismy pro bezpečnější a pohodlnější přístup k prvkům UI, snižují množství kódu a potenciální chyby. View Binding se doporučuje pro jednoduché případy, Data Binding pro složitější scénáře s přímým vázáním dat na rozložení.

<!-- res/layout/activity_main.xml (příklad s 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 (příklad s 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 z Android Architecture Components, odpovědný za uchovávání a správu dat UI specifickým způsobem s ohledem na životní cyklus. Přetrvává změny konfigurace Activity, čímž zabraňuje ztrátě dat.

// 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: Pozorovatelné držitele dat, integrované s životním cyklem Androidu. Umožňují automatické aktualizace UI při změně dat bez úniků paměti. LiveData se často používá s ViewModel. StateFlow a Flow (z Kotlin Coroutines) poskytují výkonnější možnosti reaktivního programování.

Příklad použití LiveData s ViewModel:

// MainActivity.kt (pokračování, s ViewModel a 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()
        }
    }
}

Architektonické vzory (MVVM, MVI): Rozdělují odpovědnost mezi komponenty. MVVM (Model-View-ViewModel) je nejvíce doporučovaný Googlem, kde View sleduje změny ve ViewModel, a ViewModel komunikuje s Modelem (zdroji dat). MVI (Model-View-Intent) je alternativní přístup založený na jednosměrném toku dat.

UI Toolkit (View System nebo Jetpack Compose): View System je tradiční imperativní UI systém. Jetpack Compose je moderní deklarativní UI nástroj, který usnadňuje tvorbu složitých rozhraní.

// Příklad s 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")
}

Managment tok: Všechny operace s UI by měly být prováděny v hlavním (UI) vlákně. Dlouhotrvající operace (síťové požadavky, práce s databází) by měly být přesunuty do pozadí (například pomocí Coroutines, RxJava nebo standardního ExecutorService) a výsledky vráceny do hlavního vlákna pro aktualizaci UI.

// Příklad s Coroutines
import kotlinx.coroutines.*

class MyRepository {
    suspend fun fetchData(): String = withContext(Dispatchers.IO) {
        // Simulace dlouhé operace
        delay(1000)
        "Data z pozadí"
    }
}

// V ViewModel nebo Activity/Fragment (ale preferovaně ve ViewModel)
fun loadData() {
    viewModelScope.launch { // Nebo lifecycleScope pro Activity/Fragment
        val data = MyRepository().fetchData()
        // Aktualizace LiveData, kterou sleduje UI
        _dataLiveData.value = data
    }
}

Zpracování událostí: Implementace posluchačů událostí (kliknutí tlačítek, zadání textu) v Activity/Fragment nebo View, delegování business logiky do ViewModel.
Správa stavu: Použití ViewModel, StateFlow nebo MutableState (v Compose) pro bezpečné a předvídatelné řízení stavu UI.

Dodržování těchto principů pomáhá vytvářet škálovatelné, udržovatelné a odolné aplikace. Výběr konkrétních nástrojů (View System vs Compose, LiveData vs StateFlow) závisí na projektu a preferencích týmu. Google aktivně podporuje Jetpack Compose a Kotlin Coroutines. Použití Android Architecture Components (ViewModel, LiveData, Room) je de facto standard.

Jak správně organizovat práci s uživatelským rozhraním na Androidu?