Kā pareizi organizēt darbu ar lietotāja saskarni…

Android lietotāja saskarnes darba organizēšanai jāievēro Google arhitektūras principi un ieteikumi.

Galvenās sastāvdaļas un pieejas:

Activity/Fragment: ir ieejas punkti lietotāja mijiedarbībai, satur attēlojuma loģiku (View).

View Binding/Data Binding: mehānismi drošākai un ērtākai piekļuvei UI elementiem, samazina koda daudzumu un potenciālās kļūdas. View Binding ieteicams vienkāršiem gadījumiem, Data Binding – sarežģītākiem scenārijiem ar datu sasaisti tieši ar izkārtojumu.

<!-- res/layout/activity_main.xml (piemērs ar 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 (piemērs ar 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 arhitektūras sastāvdaļa, kas atbild par datu glabāšanu un pārvaldību UI specifiskā veidā, ņemot vērā dzīves ciklu. Saglabā datus konfigurācijas maiņas laikā.

// 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: novērojamie datu turētāji, integrēti ar Android dzīves ciklu. Ļauj UI automātiski atjaunoties, mainoties datiem, bez atmiņas noplūdēm. Bieži lieto ar ViewModel. StateFlow un Flow (no Kotlin Coroutines) nodrošina jaudīgākas reakcijas programmēšanas iespējas.

Piemērs ar LiveData un ViewModel:

// MainActivity.kt (turpinājums ar ViewModel un 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()
        }
    }
}

Arhitektūras modeļi (MVVM, MVI): sadala atbildību starp komponentiem. MVVM (Model-View-ViewModel) ir visbiežāk ieteicams Google, kur View novēro izmaiņas ViewModel, bet ViewModel sadarbojas ar Model (datu avotiem). MVI (Model-View-Intent) ir alternatīva pieeja, balstīta uz vienvirziena datu plūsmu.

UI rīku komplekts (View System vai Jetpack Compose): View System ir tradicionāla imperatīva UI sistēma. Jetpack Compose ir mūsdienīgs deklaratīvs UI rīks, kas vienkāršo sarežģītu saskarnes izveidi.

// Piemērs ar 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")
}

Sailu plūsmu pārvaldība: visi UI darbi jāveic galvenajā (UI) plūsmā. Ilgstošas operācijas (tīkla pieprasījumi, datu bāzes darbi) jāizceļ fonā (piem., ar Coroutines, RxJava vai standarta ExecutorService) un rezultāti jāatgriež galvenajā plūsmā, lai atjauninātu UI.

// Coroutines piemērs
import kotlinx.coroutines.*

class MyRepository {
    suspend fun fetchData(): String = withContext(Dispatchers.IO) {
        // Ilgstošas operācijas imitācija
        delay(1000)
        "Data from background"
    }
}

// ViewModel vai Activity/Fragment (bet vēlams ViewModel)
fun loadData() {
    viewModelScope.launch { // Vai 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.

Kā pareizi organizēt darbu ar lietotāja saskarni Android?