Specificități Kotlin în dezvoltarea mobilă: ce este, ce construcții și cum funcționează

Clase (data class, sealed class, object, companion object)

Kotlin extinde conceptele de clase din Java. data class, sealed class, object și companion object — construcții care nu există în Java sau sunt implementate diferit.

data class vs sealed class

data class — o clasă care generează automat equals(), hashCode(), toString(), copy() și componentN(). Ideală pentru modele de date (DTO, Entity). Cerințe: cel puțin un parametru în constructorul primar, val/var, nu poate fi open/sealed/inner. sealed class — o clasă cu o ierarhie de subclase restricționată. Toate subclasele sunt cunoscute la compilare și declarate în același fișier. Expresia when cu sealed class nu necesită ramură else. sealed interface (Kotlin 1.9+) — la fel ca sealed class, dar permite moștenire multiplă. object — singleton, declarat cu cuvântul cheie object (nu class). Inițializare lazy thread-safe. companion object — membri statici ai unei clase. Are un nume (implicit Companion). Poate implementa interfețe și poate avea extension functions.

data class — pentru 90% din modele. sealed class — pentru UI State și Rezultat. object — pentru singleton-uri. IT Sectr recomandă sealed class pentru toate stările ecranului (Loading, Success, Error).

Sealed class în practică

Sealed class — un instrument puternic pentru modelarea stărilor. Exemplu: UiState<T> cu subclase Loading, Success(data: T), Error(message: String). Expresia when garantează gestionarea tuturor stărilor. Sealed interface — pentru evenimente și acțiuni unde este necesară implementare multiplă. Value class (Kotlin 1.5+) — un wrapper pentru o singură valoare fără overhead. Folosit pentru identificatori type-safe: @JvmInline value class UserId(val id: String).

Funcții (extension, inline, higher-order, scope functions)

Extension Function — adăugarea unei metode la o clasă existentă fără moștenire. fun String.isEmail(): Boolean. Extension Property — la fel pentru proprietăți (fără backing field). Inline Function — inserarea corpului funcției la locul apelului — fără overhead de apel. Folosit pentru funcții higher-order cu lambda. Higher-Order Function — o funcție care primește sau returnează altă funcție. Scope Functions — cinci funcții pentru lucrul cu contextul obiectului: let, run, with, apply, also.

Scope Functions

let — context it, returnează rezultatul lambda. Folosit pentru apeluri null-safe (?.let {}). apply — context this, returnează contextul. Pentru configurarea obiectului. run — context this, returnează rezultatul lambda. Pentru calcule cu context. also — context it, returnează contextul. Pentru efecte secundare (logare). with — nu este extension, context this, returnează rezultatul lambda. Pentru un grup de operații pe un obiect. Lambda — funcție anonimă. Destructuring Declaration — despachetarea data class în variabile: val (name, age) = person.

Inline + reified

Inline function cu reified — singura modalitate de a păstra un tip generic în JVM. Folosit pentru: builder-e type-safe (Gson.fromJson<T>()), verificare tip (is T), obținerea clasei (T::class). Crossinline și Noinline — modificatori pentru parametrii lambda în funcții inline. crossinline — interzice non-local return, noinline — interzice inline-ul unei anumite lambda. IT Sectr recomandă inline + reified doar când lucrați cu tipuri; pentru funcții higher-order obișnuite, inline poate crește dimensiunea bytecodului.

Corutine (Coroutine Builder, Dispatchers, Scope)

Corutine — fire ușoare pentru programare asincronă. Nu blochează firul — se suspendă. suspend function — o funcție care poate fi suspendată fără a bloca firul. Poate fi apelată doar dintr-o corutină sau altă suspend function.

CoroutineScope

CoroutineScope — un domeniu pentru corutine. Conține CoroutineContext (Job + Dispatcher). lifecycleScope — pentru Activity/Fragment (Lifecycle-aware). viewModelScope — pentru ViewModel (anulare automată la onCleared()). GlobalScope — domeniu global (nu utilizați în producție — scurgeri de memorie). Dispatchers: Dispatchers.Main (UI), Dispatchers.IO (rețea/discuri), Dispatchers.Default (CPU-intensive), Dispatchers.Unconfined (nerecomandat). launch — pornește o corutină: Job. async — pornește cu rezultat: Deferred<T>. runBlocking — pod blocant. withContext — schimbă Dispatcher în cadrul unei suspend function.

// Exemplu corutine: încărcare date în ViewModel
class MainViewModel : ViewModel() {
    private val _state = MutableStateFlow<UiState>(UiState.Loading)
    val state: StateFlow<UiState> = _state.asStateFlow()

    fun loadData() {
        viewModelScope.launch {
            _state.value = UiState.Loading
            try {
                val data = withContext(Dispatchers.IO) {
                    repository.fetchData()
                }
                _state.value = UiState.Success(data)
            } catch (e: Exception) {
                _state.value = UiState.Error(e.message)
            }
        }
    }
}

// Cereri paralele cu async
suspend fun loadCombinedData(): CombinedData = coroutineScope {
    val users = async(Dispatchers.IO) { api.getUsers() }
    val posts = async(Dispatchers.IO) { api.getPosts() }
    CombinedData(users.await(), posts.await())
}

viewModelScope.launch — pornire standard de corutină în ViewModel. withContext(Dispatchers.IO) — comutare la firul IO pentru cerere de rețea. Dispatchers determină pe ce pool de fire se execută corutina. IT Sectr recomandă viewModelScope pentru ViewModel și lifecycleScope pentru Activity/Fragment.

Caracteristici avansate (reified, destructuring, lateinit/lazy)

reified — un modificator de tip în funcții inline. Permite utilizarea tipului: T::class, is T, as T. Fără reified, genericele în JVM sunt șterse (type erasure). inline fun + reified — o combinație puternică pentru API-uri type-safe. Destructuring Declaration — val (x, y) = point. Funcționează pentru data class și tipuri cu componentN(). typealias — alias de tip: typealias Callback = (String) -> Unit. lateinit — inițializare întârziată var (pentru dependency injection). Nu este thread-safe. lazy — inițializare lazy val (implicit thread-safe). lazy(LazyThreadSafetyMode.NONE) — fără sincronizare. Extension function și Extension property — adăugare funcționalitate fără moștenire. Kotlin este un limbaj în care extension functions rezolvă 90% din sarcinile utilitare.

Proprietăți Delegated

Delegated Properties — delegarea getter/setter către un alt obiect. Delegați standard: lazy, observable, vetoable, map. Delegat personalizat prin operatorii getValue/setValue. by — cuvânt cheie de delegare: val name by lazy { loadName() }. Proprietățile delegated stau la baza delegaților ViewModel (by viewModels()). IT Sectr recomandă lazy pentru inițializare întârziată și Delegates.observable pentru observarea schimbărilor.

reified — pentru API-uri type-safe. lazy — pentru încărcare întârziată. delegated properties — pentru reutilizarea logicii proprietăților. IT Sectr recomandă stăpânirea tuturor acestor caracteristici pentru o dezvoltare eficientă în Kotlin.

Flow și StateFlow

Flow — flux de date asincron rece în Kotlin. Emite valori la cererea colectorului. StateFlow — Flow fierbinte cu o singură valoare curentă. Folosit în ViewModel pentru UI State. SharedFlow — Flow fierbinte pentru evenimente (evenimente unice). flowOf, asFlow — creare Flow din colecții. catch, retry, debounce — operatori. stateIn, shareIn — conversie Flow rece în fierbinte. IT Sectr recomandă StateFlow pentru UI State și SharedFlow pentru evenimente (Snackbar, navigare).

class SearchViewModel : ViewModel() {
    private val _query = MutableStateFlow("")
    val suggestions: StateFlow<List<String>> = _query
        .debounce(300)
        .filter { it.length >= 2 }
        .flatMapLatest { repository.search(it) }
        .stateIn(viewModelScope, SharingStarted.WhileSubscribed(5000), emptyList())

    fun onQueryChanged(query: String) {
        _query.value = query
    }
}

Serializare (kotlinx.serialization, Parcelize)

kotlinx.serialization — bibliotecă Kotlin pentru serializare JSON. @Serializable — adnotare. @SerialName — nume de câmp personalizat. Suportă: JSON, CBOR, ProtoBuf. Parcelize — @Parcelize pentru Android Parcelable (fără implementare manuală). Gson vs Moshi vs kotlinx: kotlinx.serialization — Kotlin-first, sigur la compilare, fără reflection. Moshi — adnotări + codegen. IT Sectr recomandă kotlinx.serialization pentru proiecte noi și Moshi pentru cele existente.

@Serializable
data class ApiResponse<T>(
    val success: Boolean,
    @SerialName("data") val data: T? = null,
    val error: String? = null
)

@Serializable
data class User(
    val id: Int,
    val name: String,
    val email: String
)

// Deserializare
val json = Json { ignoreUnknownKeys = true }
val response = json.decodeFromString<ApiResponse<List<User>>>(jsonString)
println("Users: ${response.data?.size ?: 0}")