Kuidas korraldada õigesti tööd kasutajaliidesega…

Androidi kasutajaliidese töö korraldamiseks tuleb järgida Google'i arhitektuuriprintsiipe ja soovitusi.

Põhikomponendid ja lähenemised:

Activity/Fragment: on kasutajaliidese interaktsiooni sissepääsupunktid, sisaldavad esitlusloogikat (View).

View Binding/Data Binding: mehhanismid turvalisemaks ja mugavamaks juurdepääsuks UI elementidele, vähendavad koodi hulka ja potentsiaalseid vigu. View Binding on soovitatav lihtsate juhtumite jaoks, Data Binding keerulisemate stsenaariumide jaoks, kus andmed on otse seotud markupiga.

<!-- res/layout/activity_main.xml (näide View Binding'iga) -->
<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 (näide View Binding'iga)
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 arhitektuurikomponent, mis vastutab andmete salvestamise ja haldamise eest UI spetsiifilisel viisil, võttes arvesse elutsüklit. Säilitab andmeid konfiguratsiooni muutuste ajal.

// 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: jälgitavad andmete hoidjad, mis on integreeritud Androidi elutsükliga. Annab võimaluse UI automaatselt uuendada andmete muutumisel ilma mälulekkedeta. Sageli kasutatakse koos ViewModel'iga. StateFlow ja Flow (Kotlin Coroutines'ist) pakuvad võimsamaid reaktiivprogrammeerimise võimalusi.

Näide LiveData kasutamisest koos ViewModel'iga:

// MainActivity.kt (jätk, koos ViewModel ja 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()
        }
    }
}

Arhitektuurimustrid (MVVM, MVI): jagavad vastutuse komponentide vahel. MVVM (Model-View-ViewModel) on Google'i poolt kõige soovitatavam, kus View jälgib muutusi ViewModel'is, ja ViewModel suhtleb Model'iga (andmeallikatega). MVI (Model-View-Intent) on alternatiivne lähenemine, mis põhineb ühesuunalisel andmevoogul.

UI tööriistakomplekt (View System või Jetpack Compose): View System on traditsiooniline imperatiivne UI süsteem. Jetpack Compose on kaasaegne deklaratiivne UI tööriist, mis lihtsustab keerukate kasutajaliideste loomist.

// Näide Jetpack Compose'iga
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 imitācija
        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 LiveData atjaunināšana
        _dataLiveData.value = data
    }
}

Notikumu apstrāde: notikumu klausītāju (pogu klikšķi, teksta ievade) realizācija Activity/Fragment vai View, biznesa loģikas nodošana uz ViewModel.
Stāvokļa pārvaldība: izmantojot ViewModel, StateFlow vai MutableState (Compose) drošai un prognozējamai UI stāvokļa pārvaldībai.

Šo principu ievērošana palīdz veidot mērogošas, uzturamas un kļūdām izturīgas lietotnes. Konkrētu rīku izvēle (View System vs Compose, LiveData vs StateFlow) ir atkarīga no projekta un komandas vēlmēm. Google aktīvi virza Jetpack Compose un Kotlin Coroutines. Android arhitektūras komponentu izmantošana (ViewModel, LiveData, Room) ir standarts.

Kuidas korraldada õigesti tööd kasutajaliidesega Androidis?